예제 #1
0
  /**
   * Returns the tool tip text for the given element.
   *
   * @param element the element
   * @return the tooltip for the element
   */
  String getToolTipText(Object element) {
    String result;
    if (!(element instanceof IResource)) {
      result =
          JavaElementLabels.getTextLabel(element, AppearanceAwareLabelProvider.DEFAULT_TEXTFLAGS);
    } else {
      IPath path = ((IResource) element).getFullPath();
      if (path.isRoot()) {
        result = getConfigurationElement().getAttribute("name"); // $NON-NLS-1$
      } else {
        result = path.makeRelative().toString();
      }
    }

    if (fWorkingSetFilterActionGroup == null
        || fWorkingSetFilterActionGroup.getWorkingSet() == null) return result;

    IWorkingSet ws = fWorkingSetFilterActionGroup.getWorkingSet();
    String wsstr =
        Messages.format(
            JavaBrowsingMessages.JavaBrowsingPart_toolTip,
            new String[] {BasicElementLabels.getWorkingSetLabel(ws)});
    if (result.length() == 0) return wsstr;
    return Messages.format(
        JavaBrowsingMessages.JavaBrowsingPart_toolTip2,
        new String[] {result, BasicElementLabels.getWorkingSetLabel(ws)});
  }
  public ExclusionInclusionEntryDialog(
      Shell parent,
      boolean isExclusion,
      String patternToEdit,
      List existingPatterns,
      CPListElement entryToEdit) {
    super(parent);
    fIsExclusion = isExclusion;
    fExistingPatterns = existingPatterns;
    String title, message;
    if (isExclusion) {
      if (patternToEdit == null) {
        title = NewWizardMessages.ExclusionInclusionEntryDialog_exclude_add_title;
      } else {
        title = NewWizardMessages.ExclusionInclusionEntryDialog_exclude_edit_title;
      }
      message =
          Messages.format(
              NewWizardMessages.ExclusionInclusionEntryDialog_exclude_pattern_label,
              BasicElementLabels.getPathLabel(entryToEdit.getPath(), false));
    } else {
      if (patternToEdit == null) {
        title = NewWizardMessages.ExclusionInclusionEntryDialog_include_add_title;
      } else {
        title = NewWizardMessages.ExclusionInclusionEntryDialog_include_edit_title;
      }
      message =
          Messages.format(
              NewWizardMessages.ExclusionInclusionEntryDialog_include_pattern_label,
              BasicElementLabels.getPathLabel(entryToEdit.getPath(), false));
    }
    setTitle(title);
    if (patternToEdit != null) {
      fExistingPatterns.remove(patternToEdit);
    }

    IWorkspaceRoot root = entryToEdit.getJavaProject().getProject().getWorkspace().getRoot();
    IResource res = root.findMember(entryToEdit.getPath());
    if (res instanceof IContainer) {
      fCurrSourceFolder = (IContainer) res;
    }

    fExclusionPatternStatus = new StatusInfo();

    ExclusionPatternAdapter adapter = new ExclusionPatternAdapter();
    fExclusionPatternDialog = new StringButtonDialogField(adapter);
    fExclusionPatternDialog.setLabelText(message);
    fExclusionPatternDialog.setButtonLabel(
        NewWizardMessages.ExclusionInclusionEntryDialog_pattern_button);
    fExclusionPatternDialog.setDialogFieldListener(adapter);
    fExclusionPatternDialog.enableButton(fCurrSourceFolder != null);

    if (patternToEdit == null) {
      fExclusionPatternDialog.setText(""); // $NON-NLS-1$
    } else {
      fExclusionPatternDialog.setText(patternToEdit.toString());
    }
  }
예제 #3
0
 /**
  * Overridden by subclasses.
  *
  * @return return the refactoring descriptor for this refactoring
  */
 protected RenameJavaElementDescriptor createRefactoringDescriptor() {
   String project = null;
   IJavaProject javaProject = fField.getJavaProject();
   if (javaProject != null) project = javaProject.getElementName();
   int flags =
       JavaRefactoringDescriptor.JAR_MIGRATION
           | JavaRefactoringDescriptor.JAR_REFACTORING
           | RefactoringDescriptor.STRUCTURAL_CHANGE;
   try {
     if (!Flags.isPrivate(fField.getFlags())) flags |= RefactoringDescriptor.MULTI_CHANGE;
   } catch (JavaModelException exception) {
     JavaPlugin.log(exception);
   }
   final IType declaring = fField.getDeclaringType();
   try {
     if (declaring.isAnonymous() || declaring.isLocal())
       flags |= JavaRefactoringDescriptor.JAR_SOURCE_ATTACHMENT;
   } catch (JavaModelException exception) {
     JavaPlugin.log(exception);
   }
   final String description =
       Messages.format(
           RefactoringCoreMessages.RenameFieldRefactoring_descriptor_description_short,
           BasicElementLabels.getJavaElementName(fField.getElementName()));
   final String header =
       Messages.format(
           RefactoringCoreMessages.RenameFieldProcessor_descriptor_description,
           new String[] {
             BasicElementLabels.getJavaElementName(fField.getElementName()),
             JavaElementLabels.getElementLabel(
                 fField.getParent(), JavaElementLabels.ALL_FULLY_QUALIFIED),
             getNewElementName()
           });
   final JDTRefactoringDescriptorComment comment =
       new JDTRefactoringDescriptorComment(project, this, header);
   if (fRenameGetter)
     comment.addSetting(RefactoringCoreMessages.RenameFieldRefactoring_setting_rename_getter);
   if (fRenameSetter)
     comment.addSetting(RefactoringCoreMessages.RenameFieldRefactoring_setting_rename_settter);
   final RenameJavaElementDescriptor descriptor =
       RefactoringSignatureDescriptorFactory.createRenameJavaElementDescriptor(
           IJavaRefactorings.RENAME_FIELD);
   descriptor.setProject(project);
   descriptor.setDescription(description);
   descriptor.setComment(comment.asString());
   descriptor.setFlags(flags);
   descriptor.setJavaElement(fField);
   descriptor.setNewName(getNewElementName());
   descriptor.setUpdateReferences(fUpdateReferences);
   descriptor.setUpdateTextualOccurrences(fUpdateTextualMatches);
   descriptor.setRenameGetters(fRenameGetter);
   descriptor.setRenameSetters(fRenameSetter);
   descriptor.setKeepOriginal(fDelegateUpdating);
   descriptor.setDeprecateDelegate(fDelegateDeprecation);
   return descriptor;
 }
 public String getResultLabel(int nMatches) {
   if (nMatches == 1) {
     return Messages.format(
         fSingularLabel, new Object[] {fName, BasicElementLabels.getFileName(fElement)});
   } else {
     return Messages.format(
         fPluralLabel,
         new Object[] {fName, new Integer(nMatches), BasicElementLabels.getFileName(fElement)});
   }
 }
예제 #5
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 void replaceAccessor(NLSSubstitution substitution, TextChange change) {
   AccessorClassReference accessorClassRef = substitution.getAccessorClassReference();
   if (accessorClassRef != null) {
     Region region = accessorClassRef.getRegion();
     int len = accessorClassRef.getName().length();
     String[] args = {
       BasicElementLabels.getJavaElementName(accessorClassRef.getName()),
       BasicElementLabels.getJavaElementName(substitution.getUpdatedAccessor())
     };
     TextChangeCompatibility.addTextEdit(
         change,
         Messages.format(NLSMessages.NLSSourceModifier_replace_accessor, args),
         new ReplaceEdit(region.getOffset(), len, substitution.getUpdatedAccessor())); //
   }
 }
    public String getText(Object element) {
      if (element instanceof File) {
        return BasicElementLabels.getResourceName(((File) element).getName());
      }

      return super.getText(element);
    }
 @Override
 public String getName() {
   return Messages.format(
       RefactoringCoreMessages.MoveCompilationUnitChange_name,
       new String[] {
         BasicElementLabels.getFileName(getCu()), getPackageName(getDestinationPackage())
       });
 }
 /**
  * This method performs checks on the constant name which are quick enough to be performed every
  * time the ui input component contents are changed.
  *
  * @return return the resulting status
  * @throws JavaModelException thrown when the operation could not be executed
  */
 public RefactoringStatus checkConstantNameOnChange() throws JavaModelException {
   if (Arrays.asList(getExcludedVariableNames()).contains(fConstantName))
     return RefactoringStatus.createErrorStatus(
         Messages.format(
             RefactoringCoreMessages.ExtractConstantRefactoring_another_variable,
             BasicElementLabels.getJavaElementName(getConstantName())));
   return Checks.checkConstantName(fConstantName, fCu);
 }
 private static String getAddClasspathLabel(
     IClasspathEntry entry, IPackageFragmentRoot root, IJavaProject project) {
   switch (entry.getEntryKind()) {
     case IClasspathEntry.CPE_LIBRARY:
       if (root.isArchive()) {
         String[] args = {
           JavaElementLabels.getElementLabel(
               root, JavaElementLabels.REFERENCED_ROOT_POST_QUALIFIED),
           BasicElementLabels.getJavaElementName(project.getElementName())
         };
         return Messages.format(
             CorrectionMessages.ReorgCorrectionsSubProcessor_addcp_archive_description, args);
       } else {
         String[] args = {
           JavaElementLabels.getElementLabel(
               root, JavaElementLabels.REFERENCED_ROOT_POST_QUALIFIED),
           BasicElementLabels.getJavaElementName(project.getElementName())
         };
         return Messages.format(
             CorrectionMessages.ReorgCorrectionsSubProcessor_addcp_classfolder_description, args);
       }
     case IClasspathEntry.CPE_VARIABLE:
       {
         String[] args = {
           JavaElementLabels.getElementLabel(root, 0),
           BasicElementLabels.getJavaElementName(project.getElementName())
         };
         return Messages.format(
             CorrectionMessages.ReorgCorrectionsSubProcessor_addcp_variable_description, args);
       }
     case IClasspathEntry.CPE_CONTAINER:
       try {
         String[] args = {
           JavaElementLabels.getContainerEntryLabel(entry.getPath(), root.getJavaProject()),
           BasicElementLabels.getJavaElementName(project.getElementName())
         };
         return Messages.format(
             CorrectionMessages.ReorgCorrectionsSubProcessor_addcp_library_description, args);
       } catch (JavaModelException e) {
         // ignore
       }
       break;
   }
   return null;
 }
예제 #11
0
  private static void addReferenceShadowedError(
      ICompilationUnit cu, SearchMatch newMatch, String newElementName, RefactoringStatus result) {
    // Found a new match with no corresponding old match.
    // -> The new match is a reference which was pointing to another element,
    // but that other element has been shadowed

    // TODO: should not have to filter declarations:
    if (newMatch instanceof MethodDeclarationMatch || newMatch instanceof FieldDeclarationMatch)
      return;
    ISourceRange range = getOldSourceRange(newMatch);
    RefactoringStatusContext context = JavaStatusContext.create(cu, range);
    String message =
        Messages.format(
            RefactoringCoreMessages.RenameAnalyzeUtil_reference_shadowed,
            new String[] {
              BasicElementLabels.getFileName(cu),
              BasicElementLabels.getJavaElementName(newElementName)
            });
    result.addError(message, context);
  }
예제 #12
0
 private RefactoringStatus checkEnclosingHierarchy() {
   IType current = fField.getDeclaringType();
   if (Checks.isTopLevel(current)) return null;
   RefactoringStatus result = new RefactoringStatus();
   while (current != null) {
     IField otherField = current.getField(getNewElementName());
     if (otherField.exists()) {
       String msg =
           Messages.format(
               RefactoringCoreMessages.RenameFieldRefactoring_hiding2,
               new String[] {
                 BasicElementLabels.getJavaElementName(getNewElementName()),
                 BasicElementLabels.getJavaElementName(current.getFullyQualifiedName('.')),
                 BasicElementLabels.getJavaElementName(otherField.getElementName())
               });
       result.addWarning(msg, JavaStatusContext.create(otherField));
     }
     current = current.getDeclaringType();
   }
   return result;
 }
예제 #13
0
 private RefactoringStatus checkNestedHierarchy(IType type) throws CoreException {
   IType[] nestedTypes = type.getTypes();
   if (nestedTypes == null) return null;
   RefactoringStatus result = new RefactoringStatus();
   for (int i = 0; i < nestedTypes.length; i++) {
     IField otherField = nestedTypes[i].getField(getNewElementName());
     if (otherField.exists()) {
       String msg =
           Messages.format(
               RefactoringCoreMessages.RenameFieldRefactoring_hiding,
               new String[] {
                 BasicElementLabels.getJavaElementName(fField.getElementName()),
                 BasicElementLabels.getJavaElementName(getNewElementName()),
                 BasicElementLabels.getJavaElementName(nestedTypes[i].getFullyQualifiedName('.'))
               });
       result.addWarning(msg, JavaStatusContext.create(otherField));
     }
     result.merge(checkNestedHierarchy(nestedTypes[i]));
   }
   return result;
 }
예제 #14
0
  public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
    IField primary = (IField) fField.getPrimaryElement();
    if (primary == null || !primary.exists()) {
      String message =
          Messages.format(
              RefactoringCoreMessages.RenameFieldRefactoring_deleted,
              BasicElementLabels.getFileName(fField.getCompilationUnit()));
      return RefactoringStatus.createFatalErrorStatus(message);
    }
    fField = primary;

    return Checks.checkIfCuBroken(fField);
  }
예제 #15
0
  private static void addShadowsError(
      ICompilationUnit cu, SearchMatch oldMatch, RefactoringStatus result) {
    // Old match not found in new matches -> reference has been shadowed

    // TODO: should not have to filter declarations:
    if (oldMatch instanceof MethodDeclarationMatch || oldMatch instanceof FieldDeclarationMatch)
      return;
    ISourceRange range = new SourceRange(oldMatch.getOffset(), oldMatch.getLength());
    RefactoringStatusContext context = JavaStatusContext.create(cu, range);
    String message =
        Messages.format(
            RefactoringCoreMessages.RenameAnalyzeUtil_shadows, BasicElementLabels.getFileName(cu));
    result.addError(message, context);
  }
예제 #16
0
  public RefactoringStatus checkNewElementName(String newName) throws CoreException {
    Assert.isNotNull(newName, "new name"); // $NON-NLS-1$
    RefactoringStatus result = Checks.checkFieldName(newName, fField);

    if (isInstanceField(fField) && (!Checks.startsWithLowerCase(newName)))
      result.addWarning(
          fIsComposite
              ? Messages.format(
                  RefactoringCoreMessages.RenameFieldRefactoring_should_start_lowercase2,
                  new String[] {
                    BasicElementLabels.getJavaElementName(newName), getDeclaringTypeLabel()
                  })
              : RefactoringCoreMessages.RenameFieldRefactoring_should_start_lowercase);

    if (Checks.isAlreadyNamed(fField, newName))
      result.addError(
          fIsComposite
              ? Messages.format(
                  RefactoringCoreMessages.RenameFieldRefactoring_another_name2,
                  new String[] {
                    BasicElementLabels.getJavaElementName(newName), getDeclaringTypeLabel()
                  })
              : RefactoringCoreMessages.RenameFieldRefactoring_another_name,
          JavaStatusContext.create(fField));

    if (fField.getDeclaringType().getField(newName).exists())
      result.addError(
          fIsComposite
              ? Messages.format(
                  RefactoringCoreMessages.RenameFieldRefactoring_field_already_defined2,
                  new String[] {
                    BasicElementLabels.getJavaElementName(newName), getDeclaringTypeLabel()
                  })
              : RefactoringCoreMessages.RenameFieldRefactoring_field_already_defined,
          JavaStatusContext.create(fField.getDeclaringType().getField(newName)));
    return result;
  }
예제 #17
0
  public static Java50Fix createRawTypeReferenceFix(
      CompilationUnit compilationUnit, IProblemLocation problem) {
    List operations = new ArrayList();
    SimpleType node =
        createRawTypeReferenceOperations(
            compilationUnit, new IProblemLocation[] {problem}, operations);
    if (operations.size() == 0) return null;

    return new Java50Fix(
        Messages.format(
            FixMessages.Java50Fix_AddTypeArguments_description,
            BasicElementLabels.getJavaElementName(node.getName().getFullyQualifiedName())),
        compilationUnit,
        (CompilationUnitRewriteOperation[])
            operations.toArray(new CompilationUnitRewriteOperation[operations.size()]));
  }
  private void deleteAccessor(NLSSubstitution substitution, TextChange change, ICompilationUnit cu)
      throws CoreException {
    AccessorClassReference accessorClassRef = substitution.getAccessorClassReference();
    if (accessorClassRef != null) {
      Region region = accessorClassRef.getRegion();
      String[] args = {
        substitution.getValueNonEmpty(),
        BasicElementLabels.getJavaElementName(substitution.getKey())
      };
      String label = Messages.format(NLSMessages.NLSSourceModifier_remove_accessor, args);
      String replaceString = '\"' + unwindEscapeChars(substitution.getValueNonEmpty()) + '\"';
      TextChangeCompatibility.addTextEdit(
          change, label, new ReplaceEdit(region.getOffset(), region.getLength(), replaceString));
      if (fIsEclipseNLS && substitution.getState() != NLSSubstitution.INTERNALIZED) {

        Region position = substitution.getNLSElement().getPosition();
        int lineStart = getLineStart(cu.getBuffer(), position.getOffset());
        int lineEnd = getLineEnd(cu.getBuffer(), position.getOffset());
        String cuLine = cu.getBuffer().getText(lineStart, lineEnd - lineStart);
        StringBuffer buf = new StringBuffer(cuLine);
        buf.replace(
            region.getOffset() - lineStart,
            region.getOffset() + region.getLength() - lineStart,
            replaceString);
        try {
          NLSLine[] allLines = NLSScanner.scan(buf.toString());

          NLSLine nlsLine = allLines[0];
          NLSElement element =
              findElement(
                  nlsLine,
                  position.getOffset() - lineStart - accessorClassRef.getName().length() - 1);
          if (element == null || element.hasTag()) return;

          NLSElement[] elements = nlsLine.getElements();
          int indexInElementList = Arrays.asList(elements).indexOf(element);
          String editText =
              ' ' + NLSElement.createTagText(indexInElementList + 1); // tags are 1-based
          TextChangeCompatibility.addTextEdit(change, label, new InsertEdit(lineEnd, editText));

        } catch (InvalidInputException e) {
        } catch (BadLocationException e) {
        }
      }
    }
  }
예제 #19
0
 /** {@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);
 }
예제 #20
0
  private SearchResultGroup[] getReferences(IProgressMonitor pm, RefactoringStatus status)
      throws CoreException {
    String binaryRefsDescription =
        Messages.format(
            RefactoringCoreMessages.ReferencesInBinaryContext_ref_in_binaries_description,
            BasicElementLabels.getJavaElementName(getCurrentElementName()));
    ReferencesInBinaryContext binaryRefs = new ReferencesInBinaryContext(binaryRefsDescription);

    SearchResultGroup[] result =
        RefactoringSearchEngine.search(
            createSearchPattern(),
            createRefactoringScope(),
            new CuCollectingSearchRequestor(binaryRefs),
            pm,
            status);
    binaryRefs.addErrorIfNecessary(status);

    return result;
  }
  private void replaceKey(NLSSubstitution substitution, TextChange change) {
    Region region = substitution.getNLSElement().getPosition();
    String[] args = {
      substitution.getInitialKey(), BasicElementLabels.getJavaElementName(substitution.getKey())
    };

    ReplaceEdit replaceEdit;
    if (fIsEclipseNLS)
      replaceEdit = new ReplaceEdit(region.getOffset(), region.getLength(), substitution.getKey());
    else
      replaceEdit =
          new ReplaceEdit(
              region.getOffset(),
              region.getLength(),
              '\"' + unwindEscapeChars(substitution.getKey()) + '\"'); //

    TextChangeCompatibility.addTextEdit(
        change, Messages.format(NLSMessages.NLSSourceModifier_replace_key, args), replaceEdit);
  }
  private void addAccessor(NLSSubstitution sub, TextChange change, String accessorName) {
    if (sub.getState() == NLSSubstitution.EXTERNALIZED) {
      NLSElement element = sub.getNLSElement();
      Region position = element.getPosition();
      String[] args = {sub.getValueNonEmpty(), BasicElementLabels.getJavaElementName(sub.getKey())};
      String text = Messages.format(NLSMessages.NLSSourceModifier_externalize, args);

      String resourceGetter = createResourceGetter(sub.getKey(), accessorName);

      TextEdit edit = new ReplaceEdit(position.getOffset(), position.getLength(), resourceGetter);
      if (fIsEclipseNLS && element.getTagPosition() != null) {
        MultiTextEdit multiEdit = new MultiTextEdit();
        multiEdit.addChild(edit);
        Region tagPosition = element.getTagPosition();
        multiEdit.addChild(new DeleteEdit(tagPosition.getOffset(), tagPosition.getLength()));
        edit = multiEdit;
      }
      TextChangeCompatibility.addTextEdit(change, text, edit);
    }
  }
예제 #23
0
  private RefactoringStatus checkNewAccessor(IMethod existingAccessor, String newAccessorName)
      throws CoreException {
    RefactoringStatus result = new RefactoringStatus();
    IMethod accessor =
        JavaModelUtil.findMethod(
            newAccessorName,
            existingAccessor.getParameterTypes(),
            false,
            fField.getDeclaringType());
    if (accessor == null || !accessor.exists()) return null;

    String message =
        Messages.format(
            RefactoringCoreMessages.RenameFieldRefactoring_already_exists,
            new String[] {
              JavaElementUtil.createMethodSignature(accessor),
              BasicElementLabels.getJavaElementName(
                  fField.getDeclaringType().getFullyQualifiedName('.'))
            });
    result.addError(message, JavaStatusContext.create(accessor));
    return result;
  }
예제 #24
0
    private void addUpdateReferenceComponent(Composite result) {
      final JavaMoveProcessor processor = getJavaMoveProcessor();
      if (!processor.canUpdateJavaReferences()) return;

      String text;
      int resources = getResources().length;
      int javaElements = getJavaElements().length;
      if (resources == 0 && javaElements == 1) {
        text =
            Messages.format(
                ReorgMessages.JdtMoveAction_update_references_singular,
                JavaElementLabels.getElementLabel(getJavaElements()[0], LABEL_FLAGS));
      } else if (resources == 1 && javaElements == 0) {
        text =
            Messages.format(
                ReorgMessages.JdtMoveAction_update_references_singular,
                BasicElementLabels.getResourceName(getResources()[0]));
      } else {
        text =
            Messages.format(
                ReorgMessages.JdtMoveAction_update_references_plural,
                String.valueOf(resources + javaElements));
      }

      fReferenceCheckbox = new Button(result, SWT.CHECK);
      fReferenceCheckbox.setText(text);
      fReferenceCheckbox.setSelection(processor.getUpdateReferences());

      fReferenceCheckbox.addSelectionListener(
          new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
              processor.setUpdateReferences(((Button) e.widget).getSelection());
              updateUIStatus();
            }
          });
    }
 @Override
 public String getText(Object element) {
   return BasicElementLabels.getFilePattern((String) element);
 }
  private ExtractConstantDescriptor createRefactoringDescriptor() {
    final Map<String, String> arguments = new HashMap<>();
    String project = null;
    IJavaProject javaProject = fCu.getJavaProject();
    if (javaProject != null) project = javaProject.getElementName();
    int flags =
        JavaRefactoringDescriptor.JAR_REFACTORING | JavaRefactoringDescriptor.JAR_SOURCE_ATTACHMENT;
    if (JdtFlags.getVisibilityCode(fVisibility) != Modifier.PRIVATE)
      flags |= RefactoringDescriptor.STRUCTURAL_CHANGE;

    final String expression = ASTNodes.asString(fSelectedExpression.getAssociatedExpression());
    final String description =
        Messages.format(
            RefactoringCoreMessages.ExtractConstantRefactoring_descriptor_description_short,
            BasicElementLabels.getJavaElementName(fConstantName));
    final String header =
        Messages.format(
            RefactoringCoreMessages.ExtractConstantRefactoring_descriptor_description,
            new String[] {
              BasicElementLabels.getJavaElementName(fConstantName),
              BasicElementLabels.getJavaCodeString(expression)
            });
    final JDTRefactoringDescriptorComment comment =
        new JDTRefactoringDescriptorComment(project, this, header);
    comment.addSetting(
        Messages.format(
            RefactoringCoreMessages.ExtractConstantRefactoring_constant_name_pattern,
            BasicElementLabels.getJavaElementName(fConstantName)));
    comment.addSetting(
        Messages.format(
            RefactoringCoreMessages.ExtractConstantRefactoring_constant_expression_pattern,
            BasicElementLabels.getJavaCodeString(expression)));
    String visibility = fVisibility;
    if ("".equals(visibility)) // $NON-NLS-1$
    visibility = RefactoringCoreMessages.ExtractConstantRefactoring_default_visibility;
    comment.addSetting(
        Messages.format(
            RefactoringCoreMessages.ExtractConstantRefactoring_visibility_pattern, visibility));
    if (fReplaceAllOccurrences)
      comment.addSetting(RefactoringCoreMessages.ExtractConstantRefactoring_replace_occurrences);
    if (fQualifyReferencesWithDeclaringClassName)
      comment.addSetting(RefactoringCoreMessages.ExtractConstantRefactoring_qualify_references);
    arguments.put(
        JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT,
        JavaRefactoringDescriptorUtil.elementToHandle(project, fCu));
    arguments.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_NAME, fConstantName);
    arguments.put(
        JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION,
        new Integer(fSelectionStart).toString()
            + " "
            + new Integer(fSelectionLength).toString()); // $NON-NLS-1$
    arguments.put(ATTRIBUTE_REPLACE, Boolean.valueOf(fReplaceAllOccurrences).toString());
    arguments.put(
        ATTRIBUTE_QUALIFY, Boolean.valueOf(fQualifyReferencesWithDeclaringClassName).toString());
    arguments.put(
        ATTRIBUTE_VISIBILITY, new Integer(JdtFlags.getVisibilityCode(fVisibility)).toString());

    ExtractConstantDescriptor descriptor =
        RefactoringSignatureDescriptorFactory.createExtractConstantDescriptor(
            project, description, comment.asString(), arguments, flags);
    return descriptor;
  }
  public static Change create(
      ICompilationUnit cu,
      NLSSubstitution[] subs,
      String substitutionPattern,
      IPackageFragment accessorPackage,
      String accessorClassName,
      boolean isEclipseNLS)
      throws CoreException {

    NLSSourceModifier sourceModification = new NLSSourceModifier(substitutionPattern, isEclipseNLS);

    String message =
        Messages.format(
            NLSMessages.NLSSourceModifier_change_description, BasicElementLabels.getFileName(cu));

    TextChange change = new CompilationUnitChange(message, cu);
    MultiTextEdit multiTextEdit = new MultiTextEdit();
    change.setEdit(multiTextEdit);

    accessorClassName =
        sourceModification.createImportForAccessor(
            multiTextEdit, accessorClassName, accessorPackage, cu);

    for (int i = 0; i < subs.length; i++) {
      NLSSubstitution substitution = subs[i];
      int newState = substitution.getState();
      if (substitution.hasStateChanged()) {
        if (newState == NLSSubstitution.EXTERNALIZED) {
          if (substitution.getInitialState() == NLSSubstitution.INTERNALIZED) {
            sourceModification.addNLS(substitution, change, accessorClassName);
          } else if (substitution.getInitialState() == NLSSubstitution.IGNORED) {
            sourceModification.addAccessor(substitution, change, accessorClassName);
          }
        } else if (newState == NLSSubstitution.INTERNALIZED) {
          if (substitution.getInitialState() == NLSSubstitution.IGNORED) {
            sourceModification.deleteTag(substitution, change);
            if (substitution.isValueRename()) {
              sourceModification.replaceValue(substitution, change);
            }
          } else if (substitution.getInitialState() == NLSSubstitution.EXTERNALIZED) {
            sourceModification.deleteAccessor(substitution, change, cu);
            if (!isEclipseNLS) sourceModification.deleteTag(substitution, change);
          }
        } else if (newState == NLSSubstitution.IGNORED) {
          if (substitution.getInitialState() == NLSSubstitution.INTERNALIZED) {
            sourceModification.addNLS(substitution, change, accessorClassName);
            if (substitution.isValueRename()) {
              sourceModification.replaceValue(substitution, change);
            }
          } else {
            if (substitution.getInitialState() == NLSSubstitution.EXTERNALIZED) {
              sourceModification.deleteAccessor(substitution, change, cu);
            }
          }
        }
      } else {
        if (newState == NLSSubstitution.EXTERNALIZED) {
          if (substitution.isKeyRename()) {
            sourceModification.replaceKey(substitution, change);
          }
          if (substitution.isAccessorRename()) {
            sourceModification.replaceAccessor(substitution, change);
          }
        } else {
          if (substitution.isValueRename()) {
            sourceModification.replaceValue(substitution, change);
          }
        }
      }
    }

    return change;
  }
    public void update(Observable o, Object arg) {

      final IWorkspace workspace = JavaPlugin.getWorkspace();

      final String name = fNameGroup.getName();
      // check whether the project name field is empty
      if (name.length() == 0) {
        setErrorMessage(null);
        setMessage(NewWizardMessages.NewJavaProjectWizardPageOne_Message_enterProjectName);
        setPageComplete(false);
        return;
      }

      // check whether the project name is valid
      final IStatus nameStatus = workspace.validateName(name, IResource.PROJECT);
      if (!nameStatus.isOK()) {
        setErrorMessage(nameStatus.getMessage());
        setPageComplete(false);
        return;
      }

      // check whether project already exists
      final IProject handle = workspace.getRoot().getProject(name);
      if (handle.exists()) {
        setErrorMessage(NewWizardMessages.NewJavaProjectWizardPageOne_Message_projectAlreadyExists);
        setPageComplete(false);
        return;
      }

      // check whether package name is valid
      final String packageName = fNameGroup.getPackageName();
      if (packageName.length() == 0) {
        setErrorMessage(null);
        setMessage("Enter a top level package name.");
        setPageComplete(false);
        return;
      }
      if (JavaConventions.validatePackageName(
                  packageName, JavaCore.VERSION_1_3, JavaCore.VERSION_1_3)
              .getSeverity()
          == IStatus.ERROR) {
        setErrorMessage(null);
        setMessage("The entered top level package name is not valid.");
        setPageComplete(false);
        return;
      }

      IPath projectLocation = ResourcesPlugin.getWorkspace().getRoot().getLocation().append(name);
      if (projectLocation.toFile().exists()) {
        try {
          // correct casing
          String canonicalPath = projectLocation.toFile().getCanonicalPath();
          projectLocation = new Path(canonicalPath);
        } catch (IOException e) {
          JavaPlugin.log(e);
        }

        String existingName = projectLocation.lastSegment();
        if (!existingName.equals(fNameGroup.getName())) {
          setErrorMessage(
              Messages.format(
                  NewWizardMessages
                      .NewJavaProjectWizardPageOne_Message_invalidProjectNameForWorkspaceRoot,
                  BasicElementLabels.getResourceName(existingName)));
          setPageComplete(false);
          return;
        }

        setErrorMessage("A project at specified location already exists.");
        setPageComplete(false);
        return;
      }

      final String location = fLocationGroup.getLocation().toOSString();

      // check whether location is empty
      if (location.length() == 0) {
        setErrorMessage(null);
        setMessage(NewWizardMessages.NewJavaProjectWizardPageOne_Message_enterLocation);
        setPageComplete(false);
        return;
      }

      // check whether the location is a syntactically correct path
      if (!Path.EMPTY.isValidPath(location)) {
        setErrorMessage(NewWizardMessages.NewJavaProjectWizardPageOne_Message_invalidDirectory);
        setPageComplete(false);
        return;
      }

      IPath projectPath = Path.fromOSString(location);

      if (fLocationGroup.isWorkspaceRadioSelected())
        projectPath = projectPath.append(fNameGroup.getName());

      if (projectPath.toFile().exists()) { // create from existing source
        if (Platform.getLocation().isPrefixOf(projectPath)) { // create
          // from
          // existing
          // source
          // in
          // workspace
          if (!Platform.getLocation().equals(projectPath.removeLastSegments(1))) {
            setErrorMessage(
                NewRooWizardMessages.NewRooProjectWizardPageOne_Message_notOnWorkspaceRoot);
            setPageComplete(false);
            return;
          }

          if (!projectPath.toFile().exists()) {
            setErrorMessage(
                NewRooWizardMessages.NewRooProjectWizardPageOne_notExisingProjectOnWorkspaceRoot);
            setPageComplete(false);
            return;
          }
        }
      } else if (!fLocationGroup.isWorkspaceRadioSelected()) { // create at
        // non
        // existing
        // external
        // location
        if (!canCreate(projectPath.toFile())) {
          setErrorMessage(
              NewWizardMessages.NewJavaProjectWizardPageOne_Message_cannotCreateAtExternalLocation);
          setPageComplete(false);
          return;
        }

        // If we do not place the contents in the workspace validate the
        // location.
        final IStatus locationStatus = workspace.validateProjectLocation(handle, projectPath);
        if (!locationStatus.isOK()) {
          setErrorMessage(locationStatus.getMessage());
          setPageComplete(false);
          return;
        }
      }

      if (firstValidation) {
        firstValidation = false;
        if (RooCoreActivator.getDefault().getInstallManager().getDefaultRooInstall() == null) {
          setErrorMessage("No Roo installation configured in workspace preferences.");
          setPageComplete(false);
          return;
        }
      } else {
        IRooInstall install = null;
        if (useDefaultRooInstall()) {
          install = RooCoreActivator.getDefault().getInstallManager().getDefaultRooInstall();
        } else {
          String installName = getRooInstallName();
          if (installName != null) {
            install = RooCoreActivator.getDefault().getInstallManager().getRooInstall(installName);
          }
        }
        if (install == null) {
          setErrorMessage("No Roo installation configured in workspace preferences.");
          setPageComplete(false);
          return;
        } else {
          installError = install.validate();
          if (installError != null && !installError.isOK()) {
            setErrorMessage(installError.getMessage());
            setPageComplete(false);
            return;
          }
        }
      }

      setPageComplete(true);
      setErrorMessage(null);
      setMessage(null);
    }
 @Override
 public void endVisit(CompilationUnit node) {
   RefactoringStatus status = getStatus();
   superCall:
   {
     if (status.hasFatalError()) break superCall;
     if (!hasSelectedNodes()) {
       ASTNode coveringNode = getLastCoveringNode();
       if (coveringNode instanceof Block
           && coveringNode.getParent() instanceof MethodDeclaration) {
         MethodDeclaration methodDecl = (MethodDeclaration) coveringNode.getParent();
         Message[] messages = ASTNodes.getMessages(methodDecl, ASTNodes.NODE_ONLY);
         if (messages.length > 0) {
           status.addFatalError(
               Messages.format(
                   RefactoringCoreMessages.ExtractMethodAnalyzer_compile_errors,
                   BasicElementLabels.getJavaElementName(methodDecl.getName().getIdentifier())),
               JavaStatusContext.create(fCUnit, methodDecl));
           break superCall;
         }
       }
       status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_invalid_selection);
       break superCall;
     }
     fEnclosingBodyDeclaration =
         (BodyDeclaration) ASTNodes.getParent(getFirstSelectedNode(), BodyDeclaration.class);
     if (fEnclosingBodyDeclaration == null
         || (fEnclosingBodyDeclaration.getNodeType() != ASTNode.METHOD_DECLARATION
             && fEnclosingBodyDeclaration.getNodeType() != ASTNode.FIELD_DECLARATION
             && fEnclosingBodyDeclaration.getNodeType() != ASTNode.INITIALIZER)) {
       status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_invalid_selection);
       break superCall;
     } else if (ASTNodes.getEnclosingType(fEnclosingBodyDeclaration) == null) {
       status.addFatalError(
           RefactoringCoreMessages.ExtractMethodAnalyzer_compile_errors_no_parent_binding);
       break superCall;
     } else if (fEnclosingBodyDeclaration.getNodeType() == ASTNode.METHOD_DECLARATION) {
       fEnclosingMethodBinding = ((MethodDeclaration) fEnclosingBodyDeclaration).resolveBinding();
     }
     if (!isSingleExpressionOrStatementSet()) {
       status.addFatalError(
           RefactoringCoreMessages.ExtractMethodAnalyzer_single_expression_or_set);
       break superCall;
     }
     if (isExpressionSelected()) {
       ASTNode expression = getFirstSelectedNode();
       if (expression instanceof Name) {
         Name name = (Name) expression;
         if (name.resolveBinding() instanceof ITypeBinding) {
           status.addFatalError(
               RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_type_reference);
           break superCall;
         }
         if (name.resolveBinding() instanceof IMethodBinding) {
           status.addFatalError(
               RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_method_name_reference);
           break superCall;
         }
         if (name.resolveBinding() instanceof IVariableBinding) {
           StructuralPropertyDescriptor locationInParent = name.getLocationInParent();
           if (locationInParent == QualifiedName.NAME_PROPERTY
               || (locationInParent == FieldAccess.NAME_PROPERTY
                   && !(((FieldAccess) name.getParent()).getExpression()
                       instanceof ThisExpression))) {
             status.addFatalError(
                 RefactoringCoreMessages
                     .ExtractMethodAnalyzer_cannot_extract_part_of_qualified_name);
             break superCall;
           }
         }
         if (name.isSimpleName() && ((SimpleName) name).isDeclaration()) {
           status.addFatalError(
               RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_name_in_declaration);
           break superCall;
         }
       }
       fForceStatic =
           ASTNodes.getParent(expression, ASTNode.SUPER_CONSTRUCTOR_INVOCATION) != null
               || ASTNodes.getParent(expression, ASTNode.CONSTRUCTOR_INVOCATION) != null;
     }
     status.merge(LocalTypeAnalyzer.perform(fEnclosingBodyDeclaration, getSelection()));
     computeLastStatementSelected();
   }
   super.endVisit(node);
 }
  private void collectProposals(
      IJavaProject project, String name, Collection<DefaultClasspathFixProposal> proposals)
      throws CoreException {
    int idx = name.lastIndexOf('.');
    char[] packageName =
        idx != -1 ? name.substring(0, idx).toCharArray() : null; // no package provided
    char[] typeName = name.substring(idx + 1).toCharArray();

    if (typeName.length == 1 && typeName[0] == '*') {
      typeName = null;
    }

    IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
    ArrayList<TypeNameMatch> res = new ArrayList<TypeNameMatch>();
    TypeNameMatchCollector requestor = new TypeNameMatchCollector(res);
    int matchMode = SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE;
    new SearchEngine()
        .searchAllTypeNames(
            packageName,
            matchMode,
            typeName,
            matchMode,
            IJavaSearchConstants.TYPE,
            scope,
            requestor,
            IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
            null);

    if (res.isEmpty()) {
      return;
    }
    HashSet<Object> addedClaspaths = new HashSet<Object>();
    for (int i = 0; i < res.size(); i++) {
      TypeNameMatch curr = res.get(i);
      IType type = curr.getType();
      if (type != null) {
        IPackageFragmentRoot root =
            (IPackageFragmentRoot) type.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
        try {
          IClasspathEntry entry = root.getRawClasspathEntry();
          if (entry == null) {
            continue;
          }
          IJavaProject other = root.getJavaProject();
          int entryKind = entry.getEntryKind();
          if ((entry.isExported() || entryKind == IClasspathEntry.CPE_SOURCE)
              && addedClaspaths.add(other)) {
            IClasspathEntry newEntry = JavaCore.newProjectEntry(other.getPath());
            Change change = ClasspathFixProposal.newAddClasspathChange(project, newEntry);
            if (change != null) {
              String[] args = {
                BasicElementLabels.getResourceName(other.getElementName()),
                BasicElementLabels.getResourceName(project.getElementName())
              };
              String label =
                  Messages.format(
                      CorrectionMessages.ReorgCorrectionsSubProcessor_addcp_project_description,
                      args);
              String desc = label;
              DefaultClasspathFixProposal proposal =
                  new DefaultClasspathFixProposal(
                      label, change, desc, IProposalRelevance.ADD_PROJECT_TO_BUILDPATH);
              proposals.add(proposal);
            }
          }
          if (entryKind == IClasspathEntry.CPE_CONTAINER) {
            IPath entryPath = entry.getPath();
            if (isNonProjectSpecificContainer(entryPath)) {
              addLibraryProposal(project, root, entry, addedClaspaths, proposals);
            } else {
              try {
                IClasspathContainer classpathContainer =
                    JavaCore.getClasspathContainer(entryPath, root.getJavaProject());
                if (classpathContainer != null) {
                  IClasspathEntry entryInContainer =
                      JavaModelUtil.findEntryInContainer(classpathContainer, root.getPath());
                  if (entryInContainer != null) {
                    addLibraryProposal(project, root, entryInContainer, addedClaspaths, proposals);
                  }
                }
              } catch (CoreException e) {
                // ignore
              }
            }
          } else if ((entryKind == IClasspathEntry.CPE_LIBRARY
              || entryKind == IClasspathEntry.CPE_VARIABLE)) {
            addLibraryProposal(project, root, entry, addedClaspaths, proposals);
          }
        } catch (JavaModelException e) {
          // ignore
        }
      }
    }
  }