private void replaceExpressionsWithConstant() throws JavaModelException {
    ASTRewrite astRewrite = fCuRewrite.getASTRewrite();
    AST ast = astRewrite.getAST();

    IASTFragment[] fragmentsToReplace = getFragmentsToReplace();
    for (int i = 0; i < fragmentsToReplace.length; i++) {
      IASTFragment fragment = fragmentsToReplace[i];
      ASTNode node = fragment.getAssociatedNode();
      boolean inTypeDeclarationAnnotation = isInTypeDeclarationAnnotation(node);
      if (inTypeDeclarationAnnotation && JdtFlags.VISIBILITY_STRING_PRIVATE == getVisibility())
        continue;

      SimpleName ref = ast.newSimpleName(fConstantName);
      Name replacement = ref;
      boolean qualifyReference = qualifyReferencesWithDeclaringClassName();
      if (!qualifyReference) {
        qualifyReference = inTypeDeclarationAnnotation;
      }
      if (qualifyReference) {
        replacement =
            ast.newQualifiedName(ast.newSimpleName(getContainingTypeBinding().getName()), ref);
      }
      TextEditGroup description =
          fCuRewrite.createGroupDescription(
              RefactoringCoreMessages.ExtractConstantRefactoring_replace);

      fragment.replace(astRewrite, replacement, description);
      if (fLinkedProposalModel != null)
        fLinkedProposalModel
            .getPositionGroup(KEY_NAME, true)
            .addPosition(astRewrite.track(ref), false);
    }
  }
  @Override
  public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException {
    pm.beginTask(RefactoringCoreMessages.ExtractConstantRefactoring_checking_preconditions, 2);

    /* Note: some checks are performed on change of input widget
     * values. (e.g. see ExtractConstantRefactoring.checkConstantNameOnChange())
     */

    // TODO: possibly add more checking for name conflicts that might
    //      lead to a change in behavior

    try {
      RefactoringStatus result = new RefactoringStatus();

      createConstantDeclaration();
      replaceExpressionsWithConstant();
      fChange =
          fCuRewrite.createChange(
              RefactoringCoreMessages.ExtractConstantRefactoring_change_name,
              true,
              new SubProgressMonitor(pm, 1));

      if (fCheckResultForCompileProblems) {
        checkSource(new SubProgressMonitor(pm, 1), result);
      }
      return result;
    } finally {
      fConstantTypeCache = null;
      fCuRewrite.clearASTAndImportRewrites();
      pm.done();
    }
  }
  @Override
  protected Statement convert(
      CompilationUnitRewrite cuRewrite, TextEditGroup group, LinkedProposalModel positionGroups)
      throws CoreException {
    ASTRewrite rewrite = cuRewrite.getASTRewrite();
    ImportRewrite importRewrite = cuRewrite.getImportRewrite();

    ForStatement forStatement = getForStatement();

    IJavaProject javaProject =
        ((CompilationUnit) forStatement.getRoot()).getJavaElement().getJavaProject();
    String[] proposals = getVariableNameProposals(fArrayAccess.resolveTypeBinding(), javaProject);

    String parameterName;
    if (fElementDeclaration != null) {
      parameterName = fElementDeclaration.getName().getIdentifier();
    } else {
      parameterName = proposals[0];
    }

    LinkedProposalPositionGroup pg = positionGroups.getPositionGroup(parameterName, true);
    if (fElementDeclaration != null) pg.addProposal(parameterName, null, 10);
    for (int i = 0; i < proposals.length; i++) {
      pg.addProposal(proposals[i], null, 10);
    }

    AST ast = forStatement.getAST();
    EnhancedForStatement result = ast.newEnhancedForStatement();

    SingleVariableDeclaration parameterDeclaration =
        createParameterDeclaration(
            parameterName,
            fElementDeclaration,
            fArrayAccess,
            forStatement,
            importRewrite,
            rewrite,
            group,
            pg,
            fMakeFinal);
    result.setParameter(parameterDeclaration);

    result.setExpression((Expression) rewrite.createCopyTarget(fArrayAccess));

    convertBody(
        forStatement.getBody(), fIndexBinding, fArrayBinding, parameterName, rewrite, group, pg);
    result.setBody(getBody(cuRewrite, group, positionGroups));

    positionGroups.setEndPosition(rewrite.track(result));

    return result;
  }
Beispiel #4
0
  private RefactoringStatus addDelegates() throws JavaModelException, CoreException {

    RefactoringStatus status = new RefactoringStatus();
    CompilationUnitRewrite rewrite = new CompilationUnitRewrite(fField.getCompilationUnit());
    rewrite.setResolveBindings(true);

    // add delegate for the field
    if (RefactoringAvailabilityTester.isDelegateCreationAvailable(fField)) {
      FieldDeclaration fieldDeclaration =
          ASTNodeSearchUtil.getFieldDeclarationNode(fField, rewrite.getRoot());
      if (fieldDeclaration.fragments().size() > 1) {
        status.addWarning(
            Messages.format(
                RefactoringCoreMessages
                    .DelegateCreator_cannot_create_field_delegate_more_than_one_fragment,
                BasicElementLabels.getJavaElementName(fField.getElementName())),
            JavaStatusContext.create(fField));
      } else if (((VariableDeclarationFragment) fieldDeclaration.fragments().get(0))
              .getInitializer()
          == null) {
        status.addWarning(
            Messages.format(
                RefactoringCoreMessages.DelegateCreator_cannot_create_field_delegate_no_initializer,
                BasicElementLabels.getJavaElementName(fField.getElementName())),
            JavaStatusContext.create(fField));
      } else {
        DelegateFieldCreator creator = new DelegateFieldCreator();
        creator.setDeclareDeprecated(fDelegateDeprecation);
        creator.setDeclaration(fieldDeclaration);
        creator.setNewElementName(getNewElementName());
        creator.setSourceRewrite(rewrite);
        creator.prepareDelegate();
        creator.createEdit();
      }
    }

    // add delegates for getter and setter methods
    // there may be getters even if the field is static final
    if (getGetter() != null && fRenameGetter)
      addMethodDelegate(getGetter(), getNewGetterName(), rewrite);
    if (getSetter() != null && fRenameSetter)
      addMethodDelegate(getSetter(), getNewSetterName(), rewrite);

    final CompilationUnitChange change = rewrite.createChange(true);
    if (change != null) {
      change.setKeepPreviewEdits(true);
      fChangeManager.manage(fField.getCompilationUnit(), change);
    }

    return status;
  }
 private Type getConstantType() throws JavaModelException {
   if (fConstantTypeCache == null) {
     IExpressionFragment fragment = getSelectedExpression();
     ITypeBinding typeBinding = guessBindingForReference(fragment.getAssociatedExpression());
     AST ast = fCuRewrite.getAST();
     typeBinding = Bindings.normalizeForDeclarationUse(typeBinding, ast);
     ImportRewrite importRewrite = fCuRewrite.getImportRewrite();
     ImportRewriteContext context =
         new ContextSensitiveImportRewriteContext(
             fCuRewrite.getRoot(), fSelectionStart, importRewrite);
     fConstantTypeCache = importRewrite.addImport(typeBinding, ast, context);
   }
   return fConstantTypeCache;
 }
  @Override
  public void run(IProgressMonitor monitor) throws CoreException {
    if (monitor == null) monitor = new NullProgressMonitor();
    try {
      monitor.beginTask("", 1); // $NON-NLS-1$
      monitor.setTaskName(CodeGenerationMessages.GenerateToStringOperation_description);

      AbstractTypeDeclaration declaration =
          (AbstractTypeDeclaration)
              ASTNodes.findDeclaration(fContext.getTypeBinding(), fRewrite.getRoot());
      ListRewrite rewriter =
          fRewrite
              .getASTRewrite()
              .getListRewrite(declaration, declaration.getBodyDeclarationsProperty());
      if (fContext.getTypeBinding() != null && rewriter != null) {

        MethodDeclaration toStringMethod = fGenerator.generateToStringMethod();

        List<BodyDeclaration> list = declaration.bodyDeclarations();
        BodyDeclaration replace = findMethodToReplace(list, toStringMethod);
        if (replace == null
            || ((Boolean)
                    toStringMethod.getProperty(AbstractToStringGenerator.OVERWRITE_METHOD_PROPERTY))
                .booleanValue()) insertMethod(toStringMethod, rewriter, replace);

        List<MethodDeclaration> helperMethods = fGenerator.generateHelperMethods();
        for (Iterator<MethodDeclaration> iterator = helperMethods.iterator();
            iterator.hasNext(); ) {
          MethodDeclaration method = iterator.next();
          replace = findMethodToReplace(list, method);
          if (replace == null
              || ((Boolean) method.getProperty(AbstractToStringGenerator.OVERWRITE_METHOD_PROPERTY))
                  .booleanValue()) {
            insertMethod(method, rewriter, replace);
          }
        }

        JavaModelUtil.applyEdit(
            (ICompilationUnit) fUnit.getJavaElement(),
            fRewrite.createChange(true).getEdit(),
            false,
            monitor);
      }

    } finally {
      monitor.done();
    }
  }
 /** {@inheritDoc} */
 public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model)
     throws CoreException {
   AST ast = cuRewrite.getRoot().getAST();
   ListRewrite listRewrite =
       cuRewrite
           .getASTRewrite()
           .getListRewrite(fBodyDeclaration, fBodyDeclaration.getModifiersProperty());
   Annotation newAnnotation = ast.newMarkerAnnotation();
   newAnnotation.setTypeName(ast.newSimpleName(fAnnotation));
   TextEditGroup group =
       createTextEditGroup(
           Messages.format(
               FixMessages.Java50Fix_AddMissingAnnotation_description,
               BasicElementLabels.getJavaElementName(fAnnotation)),
           cuRewrite);
   listRewrite.insertFirst(newAnnotation, group);
 }
Beispiel #8
0
 private void addMethodDelegate(IMethod getter, String newName, CompilationUnitRewrite rewrite)
     throws JavaModelException {
   MethodDeclaration declaration =
       ASTNodeSearchUtil.getMethodDeclarationNode(getter, rewrite.getRoot());
   DelegateCreator creator = new DelegateMethodCreator();
   creator.setDeclareDeprecated(fDelegateDeprecation);
   creator.setDeclaration(declaration);
   creator.setNewElementName(newName);
   creator.setSourceRewrite(rewrite);
   creator.prepareDelegate();
   creator.createEdit();
 }
    /** {@inheritDoc} */
    public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel positionGroups)
        throws CoreException {
      InferTypeArgumentsTCModel model = new InferTypeArgumentsTCModel();
      InferTypeArgumentsConstraintCreator creator =
          new InferTypeArgumentsConstraintCreator(model, true);

      CompilationUnit root = cuRewrite.getRoot();
      root.accept(creator);

      InferTypeArgumentsConstraintsSolver solver = new InferTypeArgumentsConstraintsSolver(model);
      InferTypeArgumentsUpdate update = solver.solveConstraints(new NullProgressMonitor());
      solver = null; // free caches

      ASTNode[] nodes =
          InferTypeArgumentsRefactoring.inferArguments(fTypes, update, model, cuRewrite);
      if (nodes.length == 0) return;

      ASTRewrite astRewrite = cuRewrite.getASTRewrite();
      for (int i = 0; i < nodes.length; i++) {
        if (nodes[i] instanceof ParameterizedType) {
          ParameterizedType type = (ParameterizedType) nodes[0];
          List args = (List) type.getStructuralProperty(ParameterizedType.TYPE_ARGUMENTS_PROPERTY);
          int j = 0;
          for (Iterator iter = args.iterator(); iter.hasNext(); ) {
            LinkedProposalPositionGroup group =
                new LinkedProposalPositionGroup("G" + i + "_" + j); // $NON-NLS-1$ //$NON-NLS-2$
            Type argType = (Type) iter.next();
            if (!positionGroups.hasLinkedPositions()) {
              group.addPosition(astRewrite.track(argType), true);
            } else {
              group.addPosition(astRewrite.track(argType), false);
            }
            positionGroups.addPositionGroup(group);
            j++;
          }
        }
      }
      positionGroups.setEndPosition(astRewrite.track(nodes[0]));
    }
 private String[] getExcludedVariableNames() {
   if (fExcludedVariableNames == null) {
     try {
       IExpressionFragment expr = getSelectedExpression();
       Collection<String> takenNames =
           new ScopeAnalyzer(fCuRewrite.getRoot())
               .getUsedVariableNames(expr.getStartPosition(), expr.getLength());
       fExcludedVariableNames = takenNames.toArray(new String[takenNames.size()]);
     } catch (JavaModelException e) {
       fExcludedVariableNames = new String[0];
     }
   }
   return fExcludedVariableNames;
 }
    /** {@inheritDoc} */
    public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model)
        throws CoreException {
      ASTRewrite rewrite = cuRewrite.getASTRewrite();

      TextEditGroup group =
          createTextEditGroup(
              FixMessages.VariableDeclarationFix_changeModifierOfUnknownToFinal_description,
              cuRewrite);

      if (fDeclaration instanceof VariableDeclarationStatement) {
        VariableDeclarationFragment[] toChange =
            (VariableDeclarationFragment[])
                fToChange.toArray(new VariableDeclarationFragment[fToChange.size()]);
        VariableDeclarationRewrite.rewriteModifiers(
            (VariableDeclarationStatement) fDeclaration,
            toChange,
            fIncludedModifiers,
            fExcludedModifiers,
            rewrite,
            group);
      } else if (fDeclaration instanceof FieldDeclaration) {
        VariableDeclarationFragment[] toChange =
            (VariableDeclarationFragment[])
                fToChange.toArray(new VariableDeclarationFragment[fToChange.size()]);
        VariableDeclarationRewrite.rewriteModifiers(
            (FieldDeclaration) fDeclaration,
            toChange,
            fIncludedModifiers,
            fExcludedModifiers,
            rewrite,
            group);
      } else if (fDeclaration instanceof SingleVariableDeclaration) {
        VariableDeclarationRewrite.rewriteModifiers(
            (SingleVariableDeclaration) fDeclaration,
            fIncludedModifiers,
            fExcludedModifiers,
            rewrite,
            group);
      } else if (fDeclaration instanceof VariableDeclarationExpression) {
        VariableDeclarationRewrite.rewriteModifiers(
            (VariableDeclarationExpression) fDeclaration,
            fIncludedModifiers,
            fExcludedModifiers,
            rewrite,
            group);
      }
    }
  private IExpressionFragment getSelectedExpression() throws JavaModelException {
    if (fSelectedExpression != null) return fSelectedExpression;

    IASTFragment selectedFragment =
        ASTFragmentFactory.createFragmentForSourceRange(
            new SourceRange(fSelectionStart, fSelectionLength), fCuRewrite.getRoot(), fCu);

    if (selectedFragment instanceof IExpressionFragment
        && !Checks.isInsideJavadoc(selectedFragment.getAssociatedNode())) {
      fSelectedExpression = (IExpressionFragment) selectedFragment;
    }

    if (fSelectedExpression != null
        && Checks.isEnumCase(fSelectedExpression.getAssociatedExpression().getParent())) {
      fSelectedExpression = null;
    }

    return fSelectedExpression;
  }
  /** {@inheritDoc} */
  @Override
  public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel positionGroups)
      throws CoreException {
    TextEditGroup group =
        createTextEditGroup(FixMessages.Java50Fix_ConvertToEnhancedForLoop_description, cuRewrite);
    ASTRewrite rewrite = cuRewrite.getASTRewrite();

    TightSourceRangeComputer rangeComputer;
    if (rewrite.getExtendedSourceRangeComputer() instanceof TightSourceRangeComputer) {
      rangeComputer = (TightSourceRangeComputer) rewrite.getExtendedSourceRangeComputer();
    } else {
      rangeComputer = new TightSourceRangeComputer();
    }
    rangeComputer.addTightSourceNode(getForStatement());
    rewrite.setTargetSourceRangeComputer(rangeComputer);

    Statement statement = convert(cuRewrite, group, positionGroups);
    rewrite.replace(getForStatement(), statement, group);
  }
  private void checkSource(SubProgressMonitor monitor, RefactoringStatus result)
      throws CoreException {
    String newCuSource = fChange.getPreviewContent(new NullProgressMonitor());
    CompilationUnit newCUNode =
        new RefactoringASTParser(ASTProvider.SHARED_AST_LEVEL)
            .parse(newCuSource, fCu, true, true, monitor);

    IProblem[] newProblems =
        RefactoringAnalyzeUtil.getIntroducedCompileProblems(newCUNode, fCuRewrite.getRoot());
    for (int i = 0; i < newProblems.length; i++) {
      IProblem problem = newProblems[i];
      if (problem.isError())
        result.addEntry(
            new RefactoringStatusEntry(
                (problem.isError() ? RefactoringStatus.ERROR : RefactoringStatus.WARNING),
                problem.getMessage(),
                new JavaStringStatusContext(newCuSource, SourceRangeFactory.create(problem))));
    }
  }
  private RefactoringStatus checkSelection(IProgressMonitor pm) throws JavaModelException {
    try {
      pm.beginTask("", 2); // $NON-NLS-1$

      IExpressionFragment selectedExpression = getSelectedExpression();

      if (selectedExpression == null) {
        String message = RefactoringCoreMessages.ExtractConstantRefactoring_select_expression;
        return CodeRefactoringUtil.checkMethodSyntaxErrors(
            fSelectionStart, fSelectionLength, fCuRewrite.getRoot(), message);
      }
      pm.worked(1);

      RefactoringStatus result = new RefactoringStatus();
      result.merge(checkExpression());
      if (result.hasFatalError()) return result;
      pm.worked(1);

      return result;
    } finally {
      pm.done();
    }
  }
  /**
   * Add occurrences
   *
   * @param manager the text change manager
   * @param pm the progress monitor
   * @param status the status
   * @throws CoreException if change creation failed
   */
  protected void addOccurrences(
      TextChangeManager manager, IProgressMonitor pm, RefactoringStatus status)
      throws CoreException /*thrown in subtype*/ {
    pm.beginTask("", fOccurrences.length); // $NON-NLS-1$
    for (int i = 0; i < fOccurrences.length; i++) {
      ICompilationUnit cu = fOccurrences[i].getCompilationUnit();
      if (cu == null) continue;

      SearchMatch[] results = fOccurrences[i].getSearchResults();

      // Split matches into declaration and non-declaration matches

      List<SearchMatch> declarationsInThisCu = new ArrayList<>();
      List<SearchMatch> referencesInThisCu = new ArrayList<>();

      for (int j = 0; j < results.length; j++) {
        if (results[j] instanceof MethodDeclarationMatch) declarationsInThisCu.add(results[j]);
        else referencesInThisCu.add(results[j]);
      }

      // First, handle the declarations
      if (declarationsInThisCu.size() > 0) {

        if (fDelegateUpdating) {
          // Update with delegates
          CompilationUnitRewrite rewrite = new CompilationUnitRewrite(cu);
          rewrite.setResolveBindings(true);

          for (Iterator<SearchMatch> iter = declarationsInThisCu.iterator(); iter.hasNext(); ) {
            SearchMatch element = iter.next();
            MethodDeclaration method =
                ASTNodeSearchUtil.getMethodDeclarationNode(
                    (IMethod) element.getElement(), rewrite.getRoot());
            DelegateCreator creator = new DelegateMethodCreator();
            creator.setDeclareDeprecated(fDelegateDeprecation);
            creator.setDeclaration(method);
            creator.setSourceRewrite(rewrite);
            creator.setNewElementName(getNewElementName());
            creator.prepareDelegate();
            creator.createEdit();
          }
          // Need to handle all delegates first as this
          // creates a completely new change object.
          TextChange changeForThisCu = rewrite.createChange(true);
          changeForThisCu.setKeepPreviewEdits(true);
          manager.manage(cu, changeForThisCu);
        }

        // Update the normal methods
        for (Iterator<SearchMatch> iter = declarationsInThisCu.iterator(); iter.hasNext(); ) {
          SearchMatch element = iter.next();
          simpleUpdate(element, cu, manager.get(cu));
        }
      }

      // Second, handle references
      if (fUpdateReferences) {
        for (Iterator<SearchMatch> iter = referencesInThisCu.iterator(); iter.hasNext(); ) {
          SearchMatch element = iter.next();
          simpleUpdate(element, cu, manager.get(cu));
        }
      }

      pm.worked(1);
      if (pm.isCanceled()) throw new OperationCanceledException();
    }
    pm.done();
  }
 public CompilationUnitChange createTextChange(IProgressMonitor pm) throws CoreException {
   createConstantDeclaration();
   replaceExpressionsWithConstant();
   return fCuRewrite.createChange(
       RefactoringCoreMessages.ExtractConstantRefactoring_change_name, true, pm);
 }
  private void createConstantDeclaration() throws CoreException {
    Type type = getConstantType();

    IExpressionFragment fragment = getSelectedExpression();
    Expression initializer =
        getSelectedExpression().createCopyTarget(fCuRewrite.getASTRewrite(), true);

    AST ast = fCuRewrite.getAST();
    VariableDeclarationFragment variableDeclarationFragment = ast.newVariableDeclarationFragment();
    variableDeclarationFragment.setName(ast.newSimpleName(fConstantName));
    variableDeclarationFragment.setInitializer(initializer);

    FieldDeclaration fieldDeclaration = ast.newFieldDeclaration(variableDeclarationFragment);
    fieldDeclaration.setType(type);
    Modifier.ModifierKeyword accessModifier = Modifier.ModifierKeyword.toKeyword(fVisibility);
    if (accessModifier != null) fieldDeclaration.modifiers().add(ast.newModifier(accessModifier));
    fieldDeclaration.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
    fieldDeclaration.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD));

    boolean createComments =
        JavaPreferencesSettings.getCodeGenerationSettings(fCu.getJavaProject()).createComments;
    if (createComments) {
      String comment =
          CodeGeneration.getFieldComment(
              fCu, getConstantTypeName(), fConstantName, StubUtility.getLineDelimiterUsed(fCu));
      if (comment != null && comment.length() > 0) {
        Javadoc doc =
            (Javadoc) fCuRewrite.getASTRewrite().createStringPlaceholder(comment, ASTNode.JAVADOC);
        fieldDeclaration.setJavadoc(doc);
      }
    }

    AbstractTypeDeclaration parent = getContainingTypeDeclarationNode();
    ListRewrite listRewrite =
        fCuRewrite.getASTRewrite().getListRewrite(parent, parent.getBodyDeclarationsProperty());
    TextEditGroup msg =
        fCuRewrite.createGroupDescription(
            RefactoringCoreMessages.ExtractConstantRefactoring_declare_constant);
    if (insertFirst()) {
      listRewrite.insertFirst(fieldDeclaration, msg);
    } else {
      listRewrite.insertAfter(fieldDeclaration, getNodeToInsertConstantDeclarationAfter(), msg);
    }

    if (fLinkedProposalModel != null) {
      ASTRewrite rewrite = fCuRewrite.getASTRewrite();
      LinkedProposalPositionGroup nameGroup = fLinkedProposalModel.getPositionGroup(KEY_NAME, true);
      nameGroup.addPosition(rewrite.track(variableDeclarationFragment.getName()), true);

      String[] nameSuggestions = guessConstantNames();
      if (nameSuggestions.length > 0 && !nameSuggestions[0].equals(fConstantName)) {
        nameGroup.addProposal(fConstantName, null, nameSuggestions.length + 1);
      }
      for (int i = 0; i < nameSuggestions.length; i++) {
        nameGroup.addProposal(nameSuggestions[i], null, nameSuggestions.length - i);
      }

      LinkedProposalPositionGroup typeGroup = fLinkedProposalModel.getPositionGroup(KEY_TYPE, true);
      typeGroup.addPosition(rewrite.track(type), true);

      ITypeBinding typeBinding = guessBindingForReference(fragment.getAssociatedExpression());
      if (typeBinding != null) {
        ITypeBinding[] relaxingTypes = ASTResolving.getNarrowingTypes(ast, typeBinding);
        for (int i = 0; i < relaxingTypes.length; i++) {
          typeGroup.addProposal(relaxingTypes[i], fCuRewrite.getCu(), relaxingTypes.length - i);
        }
      }
      boolean isInterface =
          parent.resolveBinding() != null && parent.resolveBinding().isInterface();
      ModifierCorrectionSubProcessor.installLinkedVisibilityProposals(
          fLinkedProposalModel, rewrite, fieldDeclaration.modifiers(), isInterface);
    }
  }