コード例 #1
0
    /** {@inheritDoc} */
    @Override
    public void rewriteAST(CompilationUnitRewrite cuRewrite) throws CoreException {
      ASTRewrite rewrite = cuRewrite.getASTRewrite();

      TextEditGroup group =
          createTextEditGroup(
              FixMessages.INSTANCE.UnusedCodeFix_RemoveCast_description(), cuRewrite);

      while (fUnnecessaryCasts.size() > 0) {
        CastExpression castExpression = fUnnecessaryCasts.iterator().next();
        fUnnecessaryCasts.remove(castExpression);
        CastExpression down = castExpression;
        while (fUnnecessaryCasts.contains(down.getExpression())) {
          down = (CastExpression) down.getExpression();
          fUnnecessaryCasts.remove(down);
        }

        Expression expression = down.getExpression();
        ASTNode move = rewrite.createMoveTarget(expression);

        CastExpression top = castExpression;
        while (fUnnecessaryCasts.contains(top.getParent())) {
          top = (CastExpression) top.getParent();
          fUnnecessaryCasts.remove(top);
        }

        ASTNode toReplace = top;
        if (top.getParent() instanceof ParenthesizedExpression
            && !NecessaryParenthesesChecker.needsParentheses(
                expression, top.getParent(), top.getLocationInParent())) {
          toReplace = top.getParent();
        }
        rewrite.replace(toReplace, move, group);
      }
    }
コード例 #2
0
    private void splitUpDeclarations(
        ASTRewrite rewrite,
        TextEditGroup group,
        VariableDeclarationFragment frag,
        ListRewrite statementRewrite,
        VariableDeclarationStatement originalStatement) {
      Expression initializer = frag.getInitializer();
      // keep constructors and method invocations
      if (initializer instanceof MethodInvocation || initializer instanceof ClassInstanceCreation) {
        Expression movedInitializer = (Expression) rewrite.createMoveTarget(initializer);

        ExpressionStatement newInitializer =
            rewrite.getAST().newExpressionStatement(movedInitializer);
        statementRewrite.insertAfter(newInitializer, originalStatement, group);

        VariableDeclarationStatement newDeclaration = null;
        List<VariableDeclarationFragment> fragments = originalStatement.fragments();
        int fragIndex = fragments.indexOf(frag);
        ListIterator<VariableDeclarationFragment> fragmentIterator =
            fragments.listIterator(fragIndex + 1);
        while (fragmentIterator.hasNext()) {
          VariableDeclarationFragment currentFragment = fragmentIterator.next();
          VariableDeclarationFragment movedFragment =
              (VariableDeclarationFragment) rewrite.createMoveTarget(currentFragment);
          if (newDeclaration == null) {
            newDeclaration = rewrite.getAST().newVariableDeclarationStatement(movedFragment);
            Type copiedType = (Type) rewrite.createCopyTarget(originalStatement.getType());
            newDeclaration.setType(copiedType);
          } else newDeclaration.fragments().add(movedFragment);
        }
        if (newDeclaration != null) {
          statementRewrite.insertAfter(newDeclaration, newInitializer, group);
        }
        if (originalStatement.fragments().size() == newDeclaration.fragments().size() + 1) {
          rewrite.remove(originalStatement, group);
        }
      }
    }
コード例 #3
0
 private void removeVariableWithInitializer(
     ASTRewrite rewrite, ASTNode initializerNode, ASTNode statementNode, TextEditGroup group) {
   boolean performRemove = fForceRemove;
   if (!performRemove) {
     ArrayList<Expression> sideEffectNodes = new ArrayList<Expression>();
     initializerNode.accept(new SideEffectFinder(sideEffectNodes));
     performRemove = sideEffectNodes.isEmpty();
   }
   if (performRemove) {
     removeStatement(rewrite, statementNode, group);
     fRemovedAssignmentsCount++;
   } else {
     ASTNode initNode = rewrite.createMoveTarget(initializerNode);
     ExpressionStatement statement =
         rewrite.getAST().newExpressionStatement((Expression) initNode);
     rewrite.replace(statementNode, statement, null);
     fAlteredAssignmentsCount++;
   }
 }
コード例 #4
0
  public static void rewriteModifiers(
      final FieldDeclaration declarationNode,
      final VariableDeclarationFragment[] toChange,
      final int includedModifiers,
      final int excludedModifiers,
      final ASTRewrite rewrite,
      final TextEditGroup group) {
    final List<VariableDeclarationFragment> fragmentsToChange = Arrays.asList(toChange);
    AST ast = declarationNode.getAST();
    /*
     * Problem: Same declarationNode can be the subject of multiple calls to this method.
     * For the 2nd++ calls, the original declarationNode has already been rewritten, and this has to be taken into account.
     *
     * Assumption:
     * - Modifiers for each VariableDeclarationFragment are modified at most once.
     *
     * Solution:
     * - Maintain a map from original VariableDeclarationFragments to their new FieldDeclaration.
     * - Original modifiers in declarationNode belong to the first fragment.
     * - When a later fragment needs different modifiers, we create a new FieldDeclaration and move all successive fragments into that
     * declaration
     * - When a fragment has been moved to a new declaration, make sure we don't create a new move target again,
     * but instead use the already created one
     */
    List<VariableDeclarationFragment> fragments = declarationNode.fragments();
    Iterator<VariableDeclarationFragment> iter = fragments.iterator();

    ListRewrite blockRewrite;
    if (declarationNode.getParent() instanceof AbstractTypeDeclaration) {
      blockRewrite =
          rewrite.getListRewrite(
              declarationNode.getParent(),
              ((AbstractTypeDeclaration) declarationNode.getParent())
                  .getBodyDeclarationsProperty());
    } else {
      blockRewrite =
          rewrite.getListRewrite(
              declarationNode.getParent(), AnonymousClassDeclaration.BODY_DECLARATIONS_PROPERTY);
    }

    VariableDeclarationFragment lastFragment = iter.next();
    ASTNode lastStatement = declarationNode;

    if (fragmentsToChange.contains(lastFragment)) {
      ModifierRewrite modifierRewrite = ModifierRewrite.create(rewrite, declarationNode);
      modifierRewrite.setModifiers(includedModifiers, excludedModifiers, group);
    }

    ListRewrite fragmentsRewrite = null;
    while (iter.hasNext()) {
      VariableDeclarationFragment currentFragment = iter.next();

      Map<VariableDeclarationFragment, MovedFragment> lookup =
          (Map<VariableDeclarationFragment, MovedFragment>)
              rewrite.getProperty(MovedFragment.class.getName());
      if (lookup == null) {
        lookup = new HashMap<VariableDeclarationFragment, MovedFragment>();
        rewrite.setProperty(MovedFragment.class.getName(), lookup);
      }
      MovedFragment currentMovedFragment = lookup.get(currentFragment);

      boolean changeLast = fragmentsToChange.contains(lastFragment);
      boolean changeCurrent = fragmentsToChange.contains(currentFragment);
      if (changeLast != changeCurrent || lookup.containsKey(lastFragment)) {
        ModifierRewrite modifierRewrite = null;
        if (currentMovedFragment != null) {
          // Current fragment has already been moved.

          if (currentMovedFragment.fUsesOriginalModifiers) {
            // Need to put in the right modifiers (removing any existing ones).
            modifierRewrite = ModifierRewrite.create(rewrite, currentMovedFragment.fDeclaration);
            ListRewrite listRewrite =
                rewrite.getListRewrite(
                    currentMovedFragment.fDeclaration, FieldDeclaration.MODIFIERS2_PROPERTY);
            List<ASTNode> extendedList = listRewrite.getRewrittenList();
            for (int i = 0; i < extendedList.size(); i++) {
              ASTNode curr = extendedList.get(i);
              if (curr instanceof Modifier) rewrite.remove(curr, group);
            }
          }
          // otherwise, don't need to touch the modifiers, so leave modifierRewrite null

        } else { // need to split an existing field declaration
          VariableDeclarationFragment moveTarget;
          moveTarget = (VariableDeclarationFragment) rewrite.createMoveTarget(currentFragment);

          FieldDeclaration newStatement =
              (FieldDeclaration) ast.createInstance(FieldDeclaration.FIELD_DECLARATION);
          rewrite
              .getListRewrite(newStatement, FieldDeclaration.FRAGMENTS_PROPERTY)
              .insertLast(moveTarget, group);
          lookup.put(currentFragment, new MovedFragment(moveTarget, newStatement, !changeCurrent));
          rewrite.set(
              newStatement,
              FieldDeclaration.TYPE_PROPERTY,
              rewrite.createCopyTarget(declarationNode.getType()),
              group);

          modifierRewrite = ModifierRewrite.create(rewrite, newStatement);
          modifierRewrite.copyAllAnnotations(declarationNode, group);
          blockRewrite.insertAfter(newStatement, lastStatement, group);

          fragmentsRewrite =
              rewrite.getListRewrite(newStatement, FieldDeclaration.FRAGMENTS_PROPERTY);
          lastStatement = newStatement;
        }

        if (modifierRewrite != null) {
          if (changeCurrent) {
            int newModifiers =
                (declarationNode.getModifiers() & ~excludedModifiers) | includedModifiers;
            modifierRewrite.setModifiers(newModifiers, excludedModifiers, group);
          } else {
            int newModifiers = declarationNode.getModifiers();
            modifierRewrite.setModifiers(newModifiers, Modifier.NONE, group);
          }
        }

      } else if (fragmentsRewrite != null) {
        VariableDeclarationFragment fragment0;
        boolean usesOriginalModifiers = true;
        if (currentMovedFragment != null) {
          fragment0 = currentMovedFragment.fMoveTarget;
          usesOriginalModifiers = currentMovedFragment.fUsesOriginalModifiers;
          rewrite
              .getListRewrite(
                  currentMovedFragment.fDeclaration, FieldDeclaration.FRAGMENTS_PROPERTY)
              .remove(fragment0, group);
        } else {
          fragment0 = (VariableDeclarationFragment) rewrite.createMoveTarget(currentFragment);
        }
        lookup.put(
            currentFragment, new MovedFragment(fragment0, lastStatement, usesOriginalModifiers));
        fragmentsRewrite.insertLast(fragment0, group);
      }
      lastFragment = currentFragment;
    }
  }
コード例 #5
0
  public static void rewriteModifiers(
      final VariableDeclarationStatement declarationNode,
      final VariableDeclarationFragment[] toChange,
      final int includedModifiers,
      final int excludedModifiers,
      ASTRewrite rewrite,
      final TextEditGroup group) {
    final List<VariableDeclarationFragment> fragmentsToChange = Arrays.asList(toChange);
    AST ast = declarationNode.getAST();

    List<VariableDeclarationFragment> fragments = declarationNode.fragments();
    Iterator<VariableDeclarationFragment> iter = fragments.iterator();

    ListRewrite blockRewrite = null;
    ASTNode parentStatement = declarationNode.getParent();
    if (parentStatement instanceof SwitchStatement) {
      blockRewrite = rewrite.getListRewrite(parentStatement, SwitchStatement.STATEMENTS_PROPERTY);
    } else if (parentStatement instanceof Block) {
      blockRewrite = rewrite.getListRewrite(parentStatement, Block.STATEMENTS_PROPERTY);
    } else {
      // should not happen. VariableDeclaration's can not be in a control statement body
      Assert.isTrue(false);
    }

    VariableDeclarationFragment lastFragment = iter.next();
    ASTNode lastStatement = declarationNode;

    boolean modifiersModified = false;
    if (fragmentsToChange.contains(lastFragment)) {
      ModifierRewrite modifierRewrite = ModifierRewrite.create(rewrite, declarationNode);
      modifierRewrite.setModifiers(includedModifiers, excludedModifiers, group);
      modifiersModified = true;
    }

    ListRewrite fragmentsRewrite = null;
    while (iter.hasNext()) {
      VariableDeclarationFragment currentFragment = iter.next();

      if (fragmentsToChange.contains(lastFragment) != fragmentsToChange.contains(currentFragment)) {

        VariableDeclarationStatement newStatement =
            ast.newVariableDeclarationStatement(
                (VariableDeclarationFragment) rewrite.createMoveTarget(currentFragment));
        newStatement.setType((Type) rewrite.createCopyTarget(declarationNode.getType()));

        ModifierRewrite modifierRewrite = ModifierRewrite.create(rewrite, newStatement);
        if (fragmentsToChange.contains(currentFragment)) {
          modifierRewrite.copyAllAnnotations(declarationNode, group);
          int newModifiers =
              (declarationNode.getModifiers() & ~excludedModifiers) | includedModifiers;
          modifierRewrite.setModifiers(newModifiers, excludedModifiers, group);
        } else {
          modifierRewrite.copyAllModifiers(declarationNode, group, modifiersModified);
        }
        blockRewrite.insertAfter(newStatement, lastStatement, group);

        fragmentsRewrite =
            rewrite.getListRewrite(newStatement, VariableDeclarationStatement.FRAGMENTS_PROPERTY);
        lastStatement = newStatement;
      } else if (fragmentsRewrite != null) {
        ASTNode fragment0 = rewrite.createMoveTarget(currentFragment);
        fragmentsRewrite.insertLast(fragment0, group);
      }
      lastFragment = currentFragment;
    }
  }
コード例 #6
0
    /**
     * Remove the field or variable declaration including the initializer.
     *
     * @param rewrite the AST rewriter to use
     * @param reference a reference to the variable to remove
     * @param group the text edit group to use
     */
    private void removeVariableReferences(
        ASTRewrite rewrite, SimpleName reference, TextEditGroup group) {
      ASTNode parent = reference.getParent();
      while (parent instanceof QualifiedName) {
        parent = parent.getParent();
      }
      if (parent instanceof FieldAccess) {
        parent = parent.getParent();
      }

      int nameParentType = parent.getNodeType();
      if (nameParentType == ASTNode.ASSIGNMENT) {
        Assignment assignment = (Assignment) parent;
        Expression rightHand = assignment.getRightHandSide();

        ASTNode assignParent = assignment.getParent();
        if (assignParent.getNodeType() == ASTNode.EXPRESSION_STATEMENT
            && rightHand.getNodeType() != ASTNode.ASSIGNMENT) {
          removeVariableWithInitializer(rewrite, rightHand, assignParent, group);
        } else {
          rewrite.replace(assignment, rewrite.createCopyTarget(rightHand), group);
        }
      } else if (nameParentType == ASTNode.SINGLE_VARIABLE_DECLARATION) {
        rewrite.remove(parent, group);
      } else if (nameParentType == ASTNode.VARIABLE_DECLARATION_FRAGMENT) {
        VariableDeclarationFragment frag = (VariableDeclarationFragment) parent;
        ASTNode varDecl = frag.getParent();
        List<VariableDeclarationFragment> fragments;
        if (varDecl instanceof VariableDeclarationExpression) {
          fragments = ((VariableDeclarationExpression) varDecl).fragments();
        } else if (varDecl instanceof FieldDeclaration) {
          fragments = ((FieldDeclaration) varDecl).fragments();
        } else {
          fragments = ((VariableDeclarationStatement) varDecl).fragments();
        }
        Expression initializer = frag.getInitializer();
        if (initializer instanceof CastExpression) {
          initializer = ((CastExpression) initializer).getExpression();
        }
        boolean sideEffectInitializer =
            initializer instanceof MethodInvocation || initializer instanceof ClassInstanceCreation;
        if (fragments.size() == fUnusedNames.length) {
          if (fForceRemove) {
            rewrite.remove(varDecl, group);
            return;
          }
          if (parent.getParent() instanceof FieldDeclaration) {
            rewrite.remove(varDecl, group);
            return;
          }
          if (sideEffectInitializer) {
            Expression movedInit = (Expression) rewrite.createMoveTarget(initializer);
            ExpressionStatement wrapped = rewrite.getAST().newExpressionStatement(movedInit);
            rewrite.replace(varDecl, wrapped, group);
          } else {
            rewrite.remove(varDecl, group);
          }
        } else {
          if (fForceRemove) {
            rewrite.remove(frag, group);
            return;
          }
          // multiple declarations in one line
          ASTNode declaration = parent.getParent();
          if (declaration instanceof FieldDeclaration) {
            rewrite.remove(frag, group);
            return;
          }
          if (declaration instanceof VariableDeclarationStatement) {
            ASTNode lst = declaration.getParent();
            ListRewrite listRewrite = null;
            if (lst instanceof Block) {
              listRewrite = rewrite.getListRewrite(lst, Block.STATEMENTS_PROPERTY);
            } else if (lst instanceof SwitchStatement) {
              listRewrite = rewrite.getListRewrite(lst, SwitchStatement.STATEMENTS_PROPERTY);
            } else {
              Assert.isTrue(false);
            }
            splitUpDeclarations(
                rewrite, group, frag, listRewrite, (VariableDeclarationStatement) declaration);
            rewrite.remove(frag, group);
            return;
          }
          if (declaration instanceof VariableDeclarationExpression) {
            // keep constructors and method invocations
            if (!sideEffectInitializer) {
              rewrite.remove(frag, group);
            }
          }
        }
      } else if (nameParentType == ASTNode.POSTFIX_EXPRESSION
          || nameParentType == ASTNode.PREFIX_EXPRESSION) {
        Expression expression = (Expression) parent;
        ASTNode expressionParent = expression.getParent();
        if (expressionParent.getNodeType() == ASTNode.EXPRESSION_STATEMENT) {
          removeStatement(rewrite, expressionParent, group);
        } else {
          rewrite.remove(expression, group);
        }
      }
    }