001: /*******************************************************************************
002: * Copyright (c) 2000, 2005 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.corext.refactoring.structure;
011:
012: import org.eclipse.jdt.core.dom.FieldAccess;
013: import org.eclipse.jdt.core.dom.IBinding;
014: import org.eclipse.jdt.core.dom.IMethodBinding;
015: import org.eclipse.jdt.core.dom.ITypeBinding;
016: import org.eclipse.jdt.core.dom.IVariableBinding;
017: import org.eclipse.jdt.core.dom.MemberRef;
018: import org.eclipse.jdt.core.dom.MethodInvocation;
019: import org.eclipse.jdt.core.dom.MethodRef;
020: import org.eclipse.jdt.core.dom.Modifier;
021: import org.eclipse.jdt.core.dom.QualifiedName;
022: import org.eclipse.jdt.core.dom.SimpleName;
023:
024: import org.eclipse.jdt.internal.corext.dom.Bindings;
025:
026: /**
027: * Updates references in moved static members.
028: * Accepts <code>BodyDeclaration</code>s.
029: */
030: /* package */class MovedMemberAnalyzer extends
031: MoveStaticMemberAnalyzer {
032: /*
033: * cases:
034: * - access to moved member (or to member of moved member) -> do nothing.
035: * - (static) access to source -> change to source, import source.
036: * - (static) access to target -> change to target.
037: * - access to other type -> do nothing (import is done in MoveStaticMembersRefactoring#getUpdatedMemberSource())
038: */
039: // TW: Adapted references to type
040: // - Reference to type inside moved type:
041: // - if originally resolved by qualification -> no problem
042: // - if originally resolved by import -> must add import in target too (qualify if import ambiguous)
043: public MovedMemberAnalyzer(CompilationUnitRewrite cuRewrite,
044: IBinding[] members, ITypeBinding source, ITypeBinding target) {
045: super (cuRewrite, members, source, target);
046: }
047:
048: public boolean targetNeedsSourceImport() {
049: return fNeedsImport;
050: }
051:
052: //---- types and fields --------------------------
053:
054: public boolean visit(SimpleName node) {
055: if (node.isDeclaration() || isProcessed(node))
056: return super .visit(node);
057: IBinding binding = node.resolveBinding();
058: if (isMovedMember(binding))
059: return super .visit(node);
060:
061: if (isSourceAccess(binding))
062: rewrite(node, fSource);
063: return super .visit(node);
064: }
065:
066: public boolean visit(QualifiedName node) {
067: IBinding binding = node.resolveBinding();
068: if (isSourceAccess(binding)) {
069: if (isMovedMember(binding)) {
070: rewrite(node, fTarget);
071: return false;
072: } else {
073: rewrite(node, fSource);
074: return false;
075: }
076: } else if (isTargetAccess(binding)) {
077: // remove qualifier:
078: SimpleName replace = (SimpleName) fCuRewrite
079: .getASTRewrite().createCopyTarget(node.getName());
080: fCuRewrite.getASTRewrite().replace(node, replace, null);
081: fCuRewrite.getImportRemover().registerRemovedNode(node);
082: return false;
083: }
084: return super .visit(node);
085: }
086:
087: public boolean visit(FieldAccess node) {
088: IBinding binding = node.resolveFieldBinding();
089: if (isSourceAccess(binding)) {
090: if (isMovedMember(binding)) {
091: if (node.getExpression() != null)
092: rewrite(node, fTarget);
093: } else
094: rewrite(node, fSource);
095:
096: } else if (isTargetAccess(binding)) {
097: fCuRewrite.getASTRewrite().remove(node.getExpression(),
098: null);
099: fCuRewrite.getImportRemover().registerRemovedNode(
100: node.getExpression());
101: }
102: return super .visit(node);
103: }
104:
105: //---- method invocations ----------------------------------
106:
107: public boolean visit(MethodInvocation node) {
108: IBinding binding = node.resolveMethodBinding();
109: if (isSourceAccess(binding)) {
110: if (isMovedMember(binding)) {
111: if (node.getExpression() != null)
112: rewrite(node, fTarget);
113: } else
114: rewrite(node, fSource);
115:
116: } else if (isTargetAccess(binding)) {
117: if (node.getExpression() != null) {
118: fCuRewrite.getASTRewrite().remove(node.getExpression(),
119: null);
120: fCuRewrite.getImportRemover().registerRemovedNode(
121: node.getExpression());
122: }
123: }
124: return super .visit(node);
125: }
126:
127: //---- javadoc references ----------------------------------
128:
129: public boolean visit(MemberRef node) {
130: IBinding binding = node.resolveBinding();
131: if (isSourceAccess(binding)) {
132: if (isMovedMember(binding)) {
133: if (node.getQualifier() != null)
134: rewrite(node, fTarget);
135: } else
136: rewrite(node, fSource);
137:
138: } else if (isTargetAccess(binding)) {
139: // remove qualifier:
140: SimpleName replace = (SimpleName) fCuRewrite
141: .getASTRewrite().createCopyTarget(node.getName());
142: fCuRewrite.getASTRewrite().replace(node, replace, null);
143: fCuRewrite.getImportRemover().registerRemovedNode(node);
144: }
145: return super .visit(node);
146: }
147:
148: public boolean visit(MethodRef node) {
149: IBinding binding = node.resolveBinding();
150: if (isSourceAccess(binding)) {
151: if (isMovedMember(binding)) {
152: if (node.getQualifier() != null)
153: rewrite(node, fTarget);
154: } else
155: rewrite(node, fSource);
156:
157: } else if (isTargetAccess(binding)) {
158: // remove qualifier:
159: SimpleName replace = (SimpleName) fCuRewrite
160: .getASTRewrite().createCopyTarget(node.getName());
161: fCuRewrite.getASTRewrite().replace(node, replace, null);
162: fCuRewrite.getImportRemover().registerRemovedNode(node);
163: }
164: return super .visit(node);
165: }
166:
167: //---- helper methods --------------------------------------
168:
169: private boolean isSourceAccess(IBinding binding) {
170: if (binding instanceof IMethodBinding) {
171: IMethodBinding method = (IMethodBinding) binding;
172: return Modifier.isStatic(method.getModifiers())
173: && Bindings.equals(fSource, method
174: .getDeclaringClass());
175: } else if (binding instanceof ITypeBinding) {
176: ITypeBinding type = (ITypeBinding) binding;
177: return Modifier.isStatic(type.getModifiers())
178: && Bindings.equals(fSource, type
179: .getDeclaringClass());
180: } else if (binding instanceof IVariableBinding) {
181: IVariableBinding field = (IVariableBinding) binding;
182: return field.isField()
183: && Modifier.isStatic(field.getModifiers())
184: && Bindings.equals(fSource, field
185: .getDeclaringClass());
186: }
187: return false;
188: }
189:
190: private boolean isTargetAccess(IBinding binding) {
191: if (binding instanceof IMethodBinding) {
192: IMethodBinding method = (IMethodBinding) binding;
193: return Modifier.isStatic(method.getModifiers())
194: && Bindings.equals(fTarget, method
195: .getDeclaringClass());
196: } else if (binding instanceof ITypeBinding) {
197: ITypeBinding type = (ITypeBinding) binding;
198: return Modifier.isStatic(type.getModifiers())
199: && Bindings.equals(fTarget, type
200: .getDeclaringClass());
201: } else if (binding instanceof IVariableBinding) {
202: IVariableBinding field = (IVariableBinding) binding;
203: return field.isField()
204: && Modifier.isStatic(field.getModifiers())
205: && Bindings.equals(fTarget, field
206: .getDeclaringClass());
207: }
208: return false;
209: }
210: }
|