case-study/jdt-before/core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/MoveStaticMemberAnalyzer.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2011 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package org.eclipse.jdt.internal.corext.refactoring.structure;
  12
  13 import java.util.HashSet;
  14 import java.util.Set;
  15
  16 import org.eclipse.ltk.core.refactoring.RefactoringStatus;
  17
  18 import org.eclipse.jdt.core.dom.AST;
  19 import org.eclipse.jdt.core.dom.ASTNode;
  20 import org.eclipse.jdt.core.dom.ASTVisitor;
  21 import org.eclipse.jdt.core.dom.Expression;
  22 import org.eclipse.jdt.core.dom.FieldAccess;
  23 import org.eclipse.jdt.core.dom.IBinding;
  24 import org.eclipse.jdt.core.dom.IPackageBinding;
  25 import org.eclipse.jdt.core.dom.ITypeBinding;
  26 import org.eclipse.jdt.core.dom.MemberRef;
  27 import org.eclipse.jdt.core.dom.MethodInvocation;
  28 import org.eclipse.jdt.core.dom.MethodRef;
  29 import org.eclipse.jdt.core.dom.Name;
  30 import org.eclipse.jdt.core.dom.QualifiedName;
  31 import org.eclipse.jdt.core.dom.SimpleName;
  32 import org.eclipse.jdt.core.dom.Type;
  33 import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext;
  34
  35 import org.eclipse.jdt.internal.corext.codemanipulation.ContextSensitiveImportRewriteContext;
  36 import org.eclipse.jdt.internal.corext.dom.ASTFlattener;
  37 import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
  38 import org.eclipse.jdt.internal.corext.dom.ASTNodes;
  39 import org.eclipse.jdt.internal.corext.dom.Bindings;
  40 import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages;
  41 import org.eclipse.jdt.internal.corext.refactoring.base.JavaStatusContext;
  42
  43 /* package */ class MoveStaticMemberAnalyzer extends ASTVisitor {
  44
  45         protected RefactoringStatus fStatus;
  46
  47         protected ITypeBinding fSource;
  48         protected ITypeBinding fTarget;
  49         protected CompilationUnitRewrite fCuRewrite;
  50         protected IBinding[] fMembers;
  51
  52         protected boolean fNeedsImport;
  53
  54         protected Set<SimpleName> fProcessed;
  55
  56         protected static final String REFERENCE_UPDATE= RefactoringCoreMessages.MoveMembersRefactoring_referenceUpdate;
  57
  58         public MoveStaticMemberAnalyzer(CompilationUnitRewrite cuRewrite, IBinding[] members, ITypeBinding source, ITypeBinding target) {
  59                 super(true);
  60                 fStatus= new RefactoringStatus();
  61                 fCuRewrite= cuRewrite;
  62                 fMembers= members;
  63                 fSource= source;
  64                 fTarget= target;
  65                 fProcessed= new HashSet<SimpleName>();
  66         }
  67
  68         public RefactoringStatus getStatus() {
  69                 return fStatus;
  70         }
  71
  72         protected boolean isProcessed(ASTNode node) {
  73                 return fProcessed.contains(node);
  74         }
  75
  76         protected void rewrite(SimpleName node, ITypeBinding type) {
  77                 AST ast= node.getAST();
  78                 ImportRewriteContext context= new ContextSensitiveImportRewriteContext(node, fCuRewrite.getImportRewrite());
  79                 Type result= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context);
  80                 fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName());
  81                 Name dummy= ASTNodeFactory.newName(fCuRewrite.getAST(), ASTFlattener.asString(result));
  82                 QualifiedName name= ast.newQualifiedName(dummy, ast.newSimpleName(node.getIdentifier()));
  83                 fCuRewrite.getASTRewrite().replace(node, name, fCuRewrite.createGroupDescription(REFERENCE_UPDATE));
  84                 fCuRewrite.getImportRemover().registerRemovedNode(node);
  85                 fProcessed.add(node);
  86                 fNeedsImport= true;
  87         }
  88
  89         protected void rewrite(QualifiedName node, ITypeBinding type) {
  90                 rewriteName(node.getQualifier(), type);
  91                 fProcessed.add(node.getName());
  92         }
  93
  94         protected void rewrite(FieldAccess node, ITypeBinding type) {
  95                 Expression exp= node.getExpression();
  96                 if (exp == null) {
  97                         ImportRewriteContext context= new ContextSensitiveImportRewriteContext(node, fCuRewrite.getImportRewrite());
  98                         Type result= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context);
  99                         fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName());
 100                         exp= ASTNodeFactory.newName(fCuRewrite.getAST(), ASTFlattener.asString(result));
 101                         fCuRewrite.getASTRewrite().set(node, FieldAccess.EXPRESSION_PROPERTY, exp,  fCuRewrite.createGroupDescription(REFERENCE_UPDATE));
 102                         fNeedsImport= true;
 103                 } else if (exp instanceof Name) {
 104                         rewriteName((Name)exp, type);
 105                 } else {
 106                         rewriteExpression(node, exp, type);
 107                 }
 108                 fProcessed.add(node.getName());
 109         }
 110
 111         protected void rewrite(MethodInvocation node, ITypeBinding type) {
 112                 Expression exp= node.getExpression();
 113                 if (exp == null) {
 114                         ImportRewriteContext context= new ContextSensitiveImportRewriteContext(node, fCuRewrite.getImportRewrite());
 115                         Type result= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context);
 116                         fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName());
 117                         exp= ASTNodeFactory.newName(fCuRewrite.getAST(), ASTFlattener.asString(result));
 118                         fCuRewrite.getASTRewrite().set(node, MethodInvocation.EXPRESSION_PROPERTY, exp, fCuRewrite.createGroupDescription(REFERENCE_UPDATE));
 119                         fNeedsImport= true;
 120                 } else if (exp instanceof Name) {
 121                         rewriteName((Name)exp, type);
 122                 } else {
 123                         rewriteExpression(node, exp, type);
 124                 }
 125                 fProcessed.add(node.getName());
 126         }
 127
 128         protected void rewrite(MemberRef node, ITypeBinding type) {
 129                 Name qualifier= node.getQualifier();
 130                 if (qualifier == null) {
 131                         ImportRewriteContext context= new ContextSensitiveImportRewriteContext(node, fCuRewrite.getImportRewrite());
 132                         Type result= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context);
 133                         fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName());
 134                         qualifier= ASTNodeFactory.newName(fCuRewrite.getAST(), ASTFlattener.asString(result));
 135                         fCuRewrite.getASTRewrite().set(node, MemberRef.QUALIFIER_PROPERTY, qualifier, fCuRewrite.createGroupDescription(REFERENCE_UPDATE));
 136                         fNeedsImport= true;
 137                 } else {
 138                         rewriteName(qualifier, type);
 139                 }
 140                 fProcessed.add(node.getName());
 141         }
 142
 143         protected void rewrite(MethodRef node, ITypeBinding type) {
 144                 Name qualifier= node.getQualifier();
 145                 if (qualifier == null) {
 146                         ImportRewriteContext context= new ContextSensitiveImportRewriteContext(node, fCuRewrite.getImportRewrite());
 147                         Type result= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context);
 148                         fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName());
 149                         qualifier= ASTNodeFactory.newName(fCuRewrite.getAST(), ASTFlattener.asString(result));
 150                         fCuRewrite.getASTRewrite().set(node, MethodRef.QUALIFIER_PROPERTY, qualifier, fCuRewrite.createGroupDescription(REFERENCE_UPDATE));
 151                         fNeedsImport= true;
 152                 } else {
 153                         rewriteName(qualifier, type);
 154                 }
 155                 fProcessed.add(node.getName());
 156         }
 157
 158         private void rewriteName(Name name, ITypeBinding type) {
 159                 AST creator= name.getAST();
 160                 boolean fullyQualified= false;
 161                 if (name instanceof QualifiedName) {
 162                         SimpleName left= ASTNodes.getLeftMostSimpleName(name);
 163                         if (left.resolveBinding() instanceof IPackageBinding)
 164                                 fullyQualified= true;
 165                 }
 166                 if (fullyQualified) {
 167                         fCuRewrite.getASTRewrite().replace(
 168                                 name,
 169                                 ASTNodeFactory.newName(creator, type.getQualifiedName()),
 170                                 fCuRewrite.createGroupDescription(REFERENCE_UPDATE));
 171                         fCuRewrite.getImportRemover().registerRemovedNode(name);
 172                 } else {
 173                         ImportRewriteContext context= new ContextSensitiveImportRewriteContext(name, fCuRewrite.getImportRewrite());
 174                         Type result= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context);
 175                         fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName());
 176                         Name n= ASTNodeFactory.newName(fCuRewrite.getAST(), ASTFlattener.asString(result));
 177                         fCuRewrite.getASTRewrite().replace(
 178                                 name,
 179                                 n,
 180                                 fCuRewrite.createGroupDescription(REFERENCE_UPDATE));
 181                         fCuRewrite.getImportRemover().registerRemovedNode(name);
 182                         fNeedsImport= true;
 183                 }
 184         }
 185
 186         private void rewriteExpression(ASTNode node, Expression exp, ITypeBinding type) {
 187                 ImportRewriteContext context= new ContextSensitiveImportRewriteContext(exp, fCuRewrite.getImportRewrite());
 188                 Type typeNode= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context);
 189                 fCuRewrite.getASTRewrite().replace(exp, typeNode, fCuRewrite.createGroupDescription(REFERENCE_UPDATE));
 190                 fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName());
 191                 fCuRewrite.getImportRemover().registerRemovedNode(exp);
 192                 fNeedsImport= true;
 193                 nonStaticAccess(node);
 194         }
 195
 196         protected void nonStaticAccess(ASTNode node) {
 197                 fStatus.addWarning(RefactoringCoreMessages.MoveStaticMemberAnalyzer_nonStatic,
 198                         JavaStatusContext.create(fCuRewrite.getCu(), node));
 199         }
 200
 201         protected boolean isStaticAccess(Expression exp, ITypeBinding type) {
 202                 if (!(exp instanceof Name))
 203                         return false;
 204                 return Bindings.equals(type, ((Name)exp).resolveBinding());
 205         }
 206
 207         protected boolean isMovedMember(IBinding binding) {
 208                 if (binding == null)
 209                         return false;
 210                 for (int i= 0; i < fMembers.length; i++) {
 211                         if (Bindings.equalDeclarations(fMembers[i], binding))
 212                                 return true;
 213                 }
 214                 return false;
 215         }
 216 }