case-study/jdt-before/core extension/org/eclipse/jdt/internal/corext/dom/ModifierRewrite.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.dom;
  12
  13 import java.util.ArrayList;
  14 import java.util.Iterator;
  15 import java.util.List;
  16
  17 import org.eclipse.text.edits.TextEditGroup;
  18
  19 import org.eclipse.jdt.core.dom.AST;
  20 import org.eclipse.jdt.core.dom.ASTNode;
  21 import org.eclipse.jdt.core.dom.Annotation;
  22 import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
  23 import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
  24 import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
  25 import org.eclipse.jdt.core.dom.EnumDeclaration;
  26 import org.eclipse.jdt.core.dom.FieldDeclaration;
  27 import org.eclipse.jdt.core.dom.IExtendedModifier;
  28 import org.eclipse.jdt.core.dom.MethodDeclaration;
  29 import org.eclipse.jdt.core.dom.Modifier;
  30 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
  31 import org.eclipse.jdt.core.dom.TypeDeclaration;
  32 import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
  33 import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
  34 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
  35 import org.eclipse.jdt.core.dom.rewrite.ITrackedNodePosition;
  36 import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
  37
  38 import org.eclipse.jdt.internal.corext.fix.LinkedProposalPositionGroup;
  39 import org.eclipse.jdt.internal.corext.fix.LinkedProposalPositionGroup.PositionInformation;
  40
  41 /**
  42  *
  43  */
  44 public class ModifierRewrite {
  45
  46         public static final int VISIBILITY_MODIFIERS= Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED;
  47
  48         private ListRewrite fModifierRewrite;
  49         private AST fAst;
  50
  51
  52         public static ModifierRewrite create(ASTRewrite rewrite, ASTNode declNode) {
  53                 return new ModifierRewrite(rewrite, declNode);
  54         }
  55
  56         private ModifierRewrite(ASTRewrite rewrite, ASTNode declNode) {
  57                 fModifierRewrite= evaluateListRewrite(rewrite, declNode);
  58                 fAst= declNode.getAST();
  59         }
  60
  61         private ListRewrite evaluateListRewrite(ASTRewrite rewrite, ASTNode declNode) {
  62                 switch (declNode.getNodeType()) {
  63                         case ASTNode.METHOD_DECLARATION:
  64                                 return rewrite.getListRewrite(declNode, MethodDeclaration.MODIFIERS2_PROPERTY);
  65                         case ASTNode.FIELD_DECLARATION:
  66                                 return rewrite.getListRewrite(declNode, FieldDeclaration.MODIFIERS2_PROPERTY);
  67                         case ASTNode.VARIABLE_DECLARATION_EXPRESSION:
  68                                 return rewrite.getListRewrite(declNode, VariableDeclarationExpression.MODIFIERS2_PROPERTY);
  69                         case ASTNode.VARIABLE_DECLARATION_STATEMENT:
  70                                 return rewrite.getListRewrite(declNode, VariableDeclarationStatement.MODIFIERS2_PROPERTY);
  71                         case ASTNode.SINGLE_VARIABLE_DECLARATION:
  72                                 return rewrite.getListRewrite(declNode, SingleVariableDeclaration.MODIFIERS2_PROPERTY);
  73                         case ASTNode.TYPE_DECLARATION:
  74                                 return rewrite.getListRewrite(declNode, TypeDeclaration.MODIFIERS2_PROPERTY);
  75                         case ASTNode.ENUM_DECLARATION:
  76                                 return rewrite.getListRewrite(declNode, EnumDeclaration.MODIFIERS2_PROPERTY);
  77                         case ASTNode.ANNOTATION_TYPE_DECLARATION:
  78                                 return rewrite.getListRewrite(declNode, AnnotationTypeDeclaration.MODIFIERS2_PROPERTY);
  79                         case ASTNode.ENUM_CONSTANT_DECLARATION:
  80                                 return rewrite.getListRewrite(declNode, EnumConstantDeclaration.MODIFIERS2_PROPERTY);
  81                         case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
  82                                 return rewrite.getListRewrite(declNode, AnnotationTypeMemberDeclaration.MODIFIERS2_PROPERTY);
  83                         default:
  84                                 throw new IllegalArgumentException("node has no modifiers: " + declNode.getClass().getName()); //$NON-NLS-1$
  85                 }
  86         }
  87
  88         public ListRewrite getModifierRewrite() {
  89                 return fModifierRewrite;
  90         }
  91
  92         /**
  93          * Sets the given modifiers. Removes all other flags, but leaves annotations in place.
  94          *
  95          * @param modifiers the modifiers to set
  96          * @param editGroup the edit group in which to collect the corresponding text edits, or
  97          *            <code>null</code> if ungrouped
  98          * @return a tracked position that contains the changed modifiers
  99          */
 100         public PositionInformation setModifiers(int modifiers, TextEditGroup editGroup) {
 101                 return internalSetModifiers(modifiers, -1, editGroup);
 102         }
 103
 104         /**
 105          * Sets the included modifiers and removes the excluded modifiers. Does not touch other flags
 106          * and leaves annotations in place.
 107          *
 108          * @param included the modifiers to set
 109          * @param excluded the modifiers to remove
 110          * @param editGroup the edit group in which to collect the corresponding text edits, or
 111          *            <code>null</code> if ungrouped
 112          * @return a tracked position that contains the changed modifiers
 113          */
 114         public PositionInformation setModifiers(int included, int excluded, TextEditGroup editGroup) {
 115                 return  internalSetModifiers(included, included | excluded, editGroup);
 116         }
 117
 118         /**
 119          * Sets the included visibility modifiers and removes existing visibility modifiers. Does not
 120          * touch other flags and leaves annotations in place.
 121          *
 122          * @param visibilityFlags the new visibility modifiers
 123          * @param editGroup the edit group in which to collect the corresponding text edits, or
 124          *            <code>null</code> if ungrouped
 125          * @return a tracked position that contains the changed modifiers, or <code>null</code> iff <code>editGroup == null</code>
 126          */
 127         public PositionInformation setVisibility(int visibilityFlags, TextEditGroup editGroup) {
 128                 return internalSetModifiers(visibilityFlags, VISIBILITY_MODIFIERS, editGroup);
 129         }
 130
 131         public void copyAllModifiers(ASTNode otherDecl, TextEditGroup editGroup) {
 132                 copyAllModifiers(otherDecl, editGroup, false);
 133         }
 134
 135         public void copyAllModifiers(ASTNode otherDecl, TextEditGroup editGroup, boolean copyIndividually) {
 136                 ListRewrite modifierList= evaluateListRewrite(fModifierRewrite.getASTRewrite(), otherDecl);
 137                 List<IExtendedModifier> originalList= modifierList.getOriginalList();
 138                 if (originalList.isEmpty()) {
 139                         return;
 140                 }
 141
 142                 if (copyIndividually) {
 143                         for (Iterator<IExtendedModifier> iterator= originalList.iterator(); iterator.hasNext();) {
 144                                 ASTNode modifier= (ASTNode) iterator.next();
 145                                 ASTNode copy= fModifierRewrite.getASTRewrite().createCopyTarget(modifier);
 146                                 if (copy != null) { //paranoia check (only left here because we're in RC1)
 147                                         fModifierRewrite.insertLast(copy, editGroup);
 148                                 }
 149                         }
 150                 } else {
 151                         ASTNode copy= modifierList.createCopyTarget((ASTNode) originalList.get(0), (ASTNode) originalList.get(originalList.size() - 1));
 152                         if (copy != null) { //paranoia check (only left here because we're in RC1)
 153                                 fModifierRewrite.insertLast(copy, editGroup);
 154                         }
 155                 }
 156         }
 157
 158         public void copyAllAnnotations(ASTNode otherDecl, TextEditGroup editGroup) {
 159                 ListRewrite modifierList= evaluateListRewrite(fModifierRewrite.getASTRewrite(), otherDecl);
 160                 List<IExtendedModifier> originalList= modifierList.getOriginalList();
 161
 162                 for (Iterator<IExtendedModifier> iterator= originalList.iterator(); iterator.hasNext();) {
 163                         IExtendedModifier modifier= iterator.next();
 164                         if (modifier.isAnnotation()) {
 165                                 fModifierRewrite.insertLast(fModifierRewrite.getASTRewrite().createCopyTarget((Annotation) modifier), editGroup);
 166                         }
 167                 }
 168         }
 169
 170         /**
 171          * Sets the given modifiers and removes all other modifiers that match the consideredFlags mask.
 172          * Does not touch other flags and leaves annotations in place.
 173          *
 174          * @param modifiers the modifiers to set
 175          * @param consideredFlags mask of modifiers to consider
 176          * @param editGroup the edit group in which to collect the corresponding text edits, or
 177          *            <code>null</code> if ungrouped
 178          * @return a tracked position that contains the changed modifiers
 179          */
 180         private PositionInformation internalSetModifiers(int modifiers, int consideredFlags, TextEditGroup editGroup) {
 181                 int newModifiers= modifiers & consideredFlags;
 182
 183                 ITrackedNodePosition trackedFallback= null;
 184                 List<ITrackedNodePosition> trackedNodes= new ArrayList<ITrackedNodePosition>();
 185
 186                 // remove modifiers
 187                 List<IExtendedModifier> originalList= fModifierRewrite.getOriginalList();
 188                 for (int i= 0; i < originalList.size(); i++) {
 189                         ASTNode curr= (ASTNode) originalList.get(i);
 190                         if (curr instanceof Modifier) {
 191                                 int flag= ((Modifier)curr).getKeyword().toFlagValue();
 192                                 if ((consideredFlags & flag) != 0) {
 193                                         if ((newModifiers & flag) == 0) {
 194                                                 fModifierRewrite.remove(curr, editGroup);
 195                                                 if (trackedFallback == null)
 196                                                         trackedFallback= fModifierRewrite.getASTRewrite().track(curr);
 197                                         }
 198                                         newModifiers &= ~flag;
 199                                 }
 200                         }
 201                 }
 202
 203                 // find last annotation
 204                 IExtendedModifier lastAnnotation= null;
 205                 List<IExtendedModifier> extendedList= fModifierRewrite.getRewrittenList();
 206                 for (int i= 0; i < extendedList.size(); i++) {
 207                         IExtendedModifier curr= extendedList.get(i);
 208                         if (curr.isAnnotation())
 209                                 lastAnnotation= curr;
 210                 }
 211
 212                 // add modifiers
 213                 List<Modifier> newNodes= ASTNodeFactory.newModifiers(fAst, newModifiers);
 214                 for (int i= 0; i < newNodes.size(); i++) {
 215                         Modifier curr= newNodes.get(i);
 216                         if ((curr.getKeyword().toFlagValue() & VISIBILITY_MODIFIERS) != 0) {
 217                                 if (lastAnnotation != null)
 218                                         fModifierRewrite.insertAfter(curr, (ASTNode) lastAnnotation, editGroup);
 219                                 else
 220                                         fModifierRewrite.insertFirst(curr, editGroup);
 221                         } else {
 222                                 fModifierRewrite.insertLast(curr, editGroup);
 223                         }
 224                         trackedNodes.add(fModifierRewrite.getASTRewrite().track(curr));
 225                 }
 226
 227                 if (trackedNodes.isEmpty()) {
 228                         if (trackedFallback == null) {
 229                                 // out of tricks...
 230                                 trackedFallback= fModifierRewrite.getASTRewrite().track(fModifierRewrite.getParent());
 231                         }
 232                         return new LinkedProposalPositionGroup.StartPositionInformation(trackedFallback);
 233                 } else {
 234                         return new LinkedProposalPositionGroup.TrackedNodesPosition(trackedNodes);
 235                 }
 236         }
 237 }