import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
private RefactoringStatus checkAccessedTypes(IMethod sourceMethod, final Optional<IProgressMonitor> monitor,
		final ITypeHierarchy hierarchy) throws JavaModelException {
	final RefactoringStatus result = new RefactoringStatus();
	final IType[] accessedTypes = getTypesReferencedInMovedMembers(sourceMethod, monitor);
	final IType destination = getDestinationInterface(sourceMethod).get();
	final List<IMember> pulledUpList = Arrays.asList(sourceMethod);
	for (IType type : accessedTypes) {
		if (!type.exists())
			continue;

		if (!canBeAccessedFrom(sourceMethod, type, destination, hierarchy) && !pulledUpList.contains(type)) {
			final String message = org.eclipse.jdt.internal.corext.util.Messages.format(
					PreconditionFailure.TypeNotAccessible.getMessage(),
					new String[] { JavaElementLabels.getTextLabel(type, JavaElementLabels.ALL_FULLY_QUALIFIED),
							JavaElementLabels.getTextLabel(destination, JavaElementLabels.ALL_FULLY_QUALIFIED) });
			result.addEntry(RefactoringStatus.ERROR, message, JavaStatusContext.create(type),
					MigrateSkeletalImplementationToInterfaceRefactoringDescriptor.REFACTORING_ID,
					PreconditionFailure.TypeNotAccessible.ordinal(), sourceMethod);
			this.getUnmigratableMethods().add(sourceMethod);
		}
	}
	monitor.ifPresent(IProgressMonitor::done);
	return result;
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
private List<Initializer> getInitializes(Object parent) throws JavaModelException {
  List<Initializer> result = new ArrayList<>();
  Set<Object> objects = childrens.get(parent);
  if (objects == null) {
    return result;
  }

  for (Object object : objects) {
    if (object instanceof IInitializer) {
      IInitializer initializer = (IInitializer) object;
      Initializer init = DtoFactory.newDto(Initializer.class);
      init.setElementName(initializer.getElementName());
      init.setHandleIdentifier(initializer.getHandleIdentifier());
      init.setFlags(initializer.getFlags());
      init.setLabel(
          JavaElementLabels.getElementLabel(initializer, JavaElementLabels.ALL_DEFAULT));
      result.add(init);
    }
  }
  return result;
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
private List<Method> getMethods(Object parent) throws JavaModelException {
  List<Method> result = new ArrayList<>();
  Set<Object> objects = childrens.get(parent);
  if (objects == null) {
    return result;
  }

  for (Object object : objects) {
    if (object instanceof IMethod) {
      IMethod method = (IMethod) object;
      Method met = DtoFactory.newDto(Method.class);
      met.setHandleIdentifier(method.getHandleIdentifier());
      met.setFlags(method.getFlags());
      met.setElementName(method.getElementName());
      met.setLabel(JavaElementLabels.getElementLabel(method, JavaElementLabels.ALL_DEFAULT));
      result.add(met);
    }
  }

  return result;
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
private List<Field> getFields(Object parent) throws JavaModelException {
  List<Field> result = new ArrayList<>();
  Set<Object> objects = childrens.get(parent);
  if (objects == null) {
    return result;
  }

  for (Object object : objects) {
    if (object instanceof IField) {
      IField iField = (IField) object;
      Field field = DtoFactory.newDto(Field.class);
      field.setElementName(iField.getElementName());
      field.setHandleIdentifier(iField.getHandleIdentifier());
      field.setFlags(iField.getFlags());
      field.setLabel(JavaElementLabels.getElementLabel(iField, JavaElementLabels.ALL_DEFAULT));
      result.add(field);
    }
  }
  return result;
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
private String getMethodParametersAsString(IMethod method) throws JavaModelException {
  ILocalVariable[] parameters = method.getParameters();

  int paramsLength = parameters.length;
  int index = 0;

  StringBuffer buffer = new StringBuffer();

  for (ILocalVariable parameter : parameters) {
    JavaElementLabels.getLocalVariableLabel(
        parameter, JavaElementLabels.F_PRE_TYPE_SIGNATURE, buffer);
    index++;

    if (index < paramsLength) {
      buffer.append(", ");
    }
  }

  return buffer.toString();
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
StyledString createAnonymousTypeLabel(CompletionProposal proposal) {
  char[] declaringTypeSignature = proposal.getDeclarationSignature();
  declaringTypeSignature = Signature.getTypeErasure(declaringTypeSignature);

  StyledString buffer = new StyledString();
  buffer.append(Signature.getSignatureSimpleName(declaringTypeSignature));
  buffer.append('(');
  appendUnboundedParameterList(buffer, proposal);
  buffer.append(')');
  buffer.append("  "); // $NON-NLS-1$
  buffer.append(JavaTextMessages.ResultCollector_anonymous_type);

  if (proposal.getRequiredProposals() != null) {
    char[] signatureQualifier = Signature.getSignatureQualifier(declaringTypeSignature);
    if (signatureQualifier.length > 0) {
      buffer.append(JavaElementLabels.CONCAT_STRING, StyledString.QUALIFIER_STYLER);
      buffer.append(signatureQualifier, StyledString.QUALIFIER_STYLER);
    }
  }

  return Strings.markJavaElementLabelLTR(buffer);
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
public String getOldMethodSignature() throws JavaModelException {
  StringBuffer buff = new StringBuffer();

  int flags = getMethod().getFlags();
  buff.append(getVisibilityString(flags));
  if (Flags.isStatic(flags)) {
    buff.append("static "); // $NON-NLS-1$
  } else if (Flags.isDefaultMethod(flags)) {
    buff.append("default "); // $NON-NLS-1$
  }
  if (!getMethod().isConstructor()) buff.append(fReturnTypeInfo.getOldTypeName()).append(' ');

  buff.append(
      JavaElementLabels.getElementLabel(
          fMethod.getParent(), JavaElementLabels.ALL_FULLY_QUALIFIED));
  buff.append('.');
  buff.append(fMethod.getElementName())
      .append(Signature.C_PARAM_START)
      .append(getOldMethodParameters())
      .append(Signature.C_PARAM_END);

  buff.append(getOldMethodThrows());

  return BasicElementLabels.getJavaCodeString(buff.toString());
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
public RefactoringStatus checkNewElementName(String newName) throws JavaModelException {
  RefactoringStatus result = Checks.checkFieldName(newName, fCu);
  if (!Checks.startsWithLowerCase(newName))
    if (fIsComposite) {
      final String nameOfParent =
          JavaElementLabels.getElementLabel(
              fLocalVariable.getParent(), JavaElementLabels.ALL_DEFAULT);
      final String nameOfType =
          JavaElementLabels.getElementLabel(
              fLocalVariable.getAncestor(IJavaElement.TYPE), JavaElementLabels.ALL_DEFAULT);
      result.addWarning(
          Messages.format(
              RefactoringCoreMessages.RenameTempRefactoring_lowercase2,
              new String[] {
                BasicElementLabels.getJavaElementName(newName), nameOfParent, nameOfType
              }));
    } else {
      result.addWarning(RefactoringCoreMessages.RenameTempRefactoring_lowercase);
    }
  return result;
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
public static RefactoringStatus checkIfOverridesAnother(IMethod method, ITypeHierarchy hierarchy)
    throws JavaModelException {
  IMethod overrides = MethodChecks.overridesAnotherMethod(method, hierarchy);
  if (overrides == null) return null;

  RefactoringStatusContext context = JavaStatusContext.create(overrides);
  String message =
      Messages.format(
          RefactoringCoreMessages.MethodChecks_overrides,
          new String[] {
            JavaElementUtil.createMethodSignature(overrides),
            JavaElementLabels.getElementLabel(
                overrides.getDeclaringType(), JavaElementLabels.ALL_FULLY_QUALIFIED)
          });
  return RefactoringStatus.createStatus(
      RefactoringStatus.FATAL,
      message,
      context,
      Corext.getPluginId(),
      RefactoringStatusCodes.OVERRIDES_ANOTHER_METHOD,
      overrides);
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
public static RefactoringStatus checkIfComesFromInterface(
    IMethod method, ITypeHierarchy hierarchy, IProgressMonitor monitor)
    throws JavaModelException {
  IMethod inInterface = MethodChecks.isDeclaredInInterface(method, hierarchy, monitor);

  if (inInterface == null) return null;

  RefactoringStatusContext context = JavaStatusContext.create(inInterface);
  String message =
      Messages.format(
          RefactoringCoreMessages.MethodChecks_implements,
          new String[] {
            JavaElementUtil.createMethodSignature(inInterface),
            JavaElementLabels.getElementLabel(
                inInterface.getDeclaringType(), JavaElementLabels.ALL_FULLY_QUALIFIED)
          });
  return RefactoringStatus.createStatus(
      RefactoringStatus.FATAL,
      message,
      context,
      Corext.getPluginId(),
      RefactoringStatusCodes.METHOD_DECLARED_IN_INTERFACE,
      inInterface);
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
  IType primary = (IType) fType.getPrimaryElement();
  if (primary == null || !primary.exists()) {
    String qualifiedTypeName =
        JavaElementLabels.getElementLabel(fType, JavaElementLabels.F_FULLY_QUALIFIED);
    String message =
        Messages.format(
            RefactoringCoreMessages.RenameTypeRefactoring_does_not_exist,
            new String[] {
              BasicElementLabels.getJavaElementName(qualifiedTypeName),
              BasicElementLabels.getFileName(fType.getCompilationUnit())
            });
    return RefactoringStatus.createFatalErrorStatus(message);
  }
  fType = primary;
  return Checks.checkIfCuBroken(fType);
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
private void analyzeImportedTypes(IType[] types, RefactoringStatus result, IImportDeclaration imp)
    throws CoreException {
  for (int i = 0; i < types.length; i++) {
    // could this be a problem (same package imports)?
    if (JdtFlags.isPublic(types[i]) && types[i].getElementName().equals(getNewElementName())) {
      String msg =
          Messages.format(
              RefactoringCoreMessages.RenameTypeRefactoring_name_conflict1,
              new Object[] {
                JavaElementLabels.getElementLabel(
                    types[i], JavaElementLabels.ALL_FULLY_QUALIFIED),
                BasicElementLabels.getPathLabel(getCompilationUnit(imp).getPath(), false)
              });
      result.addError(msg, JavaStatusContext.create(imp));
    }
  }
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
private RefactoringStatus checkPackageName(String newName) throws CoreException {
  RefactoringStatus status = new RefactoringStatus();
  IPackageFragmentRoot[] roots = fPackage.getJavaProject().getPackageFragmentRoots();
  Set<String> topLevelTypeNames = getTopLevelTypeNames();
  for (int i = 0; i < roots.length; i++) {
    IPackageFragmentRoot root = roots[i];
    if (!isPackageNameOkInRoot(newName, root)) {
      String rootLabel = JavaElementLabels.getElementLabel(root, JavaElementLabels.ALL_DEFAULT);
      String newPackageName = BasicElementLabels.getJavaElementName(getNewElementName());
      String message =
          Messages.format(
              RefactoringCoreMessages.RenamePackageRefactoring_aleady_exists,
              new Object[] {newPackageName, rootLabel});
      status.merge(RefactoringStatus.createWarningStatus(message));
      status.merge(checkTypeNameConflicts(root, newName, topLevelTypeNames));
    }
  }
  return status;
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
/**
 * Creates a fatal error status telling that the input element does not exist.
 *
 * @param element the input element, or <code>null</code>
 * @param name the name of the refactoring
 * @param id the id of the refactoring
 * @return the refactoring status
 */
public static RefactoringStatus createInputFatalStatus(
    final Object element, final String name, final String id) {
  Assert.isNotNull(name);
  Assert.isNotNull(id);
  if (element != null)
    return RefactoringStatus.createFatalErrorStatus(
        Messages.format(
            RefactoringCoreMessages.InitializableRefactoring_input_not_exists,
            new String[] {
              JavaElementLabels.getTextLabel(element, JavaElementLabels.ALL_FULLY_QUALIFIED),
              name,
              id
            }));
  else
    return RefactoringStatus.createFatalErrorStatus(
        Messages.format(
            RefactoringCoreMessages.InitializableRefactoring_inputs_do_not_exist,
            new String[] {name, id}));
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
/**
 * Creates a warning status telling that the input element does not exist.
 *
 * @param element the input element, or <code>null</code>
 * @param name the name of the refactoring
 * @param id the id of the refactoring
 * @return the refactoring status
 */
public static RefactoringStatus createInputWarningStatus(
    final Object element, final String name, final String id) {
  Assert.isNotNull(name);
  Assert.isNotNull(id);
  if (element != null)
    return RefactoringStatus.createWarningStatus(
        Messages.format(
            RefactoringCoreMessages.InitializableRefactoring_input_not_exists,
            new String[] {
              JavaElementLabels.getTextLabel(element, JavaElementLabels.ALL_FULLY_QUALIFIED),
              name,
              id
            }));
  else
    return RefactoringStatus.createWarningStatus(
        Messages.format(
            RefactoringCoreMessages.InitializableRefactoring_inputs_do_not_exist,
            new String[] {name, id}));
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public RefactoringStatus isValid(IProgressMonitor monitor)
    throws CoreException, OperationCanceledException {
  if (fSelection instanceof IJavaElement) {
    final IJavaElement element = (IJavaElement) fSelection;
    if (!Checks.isAvailable(element))
      RefactoringStatus.createFatalErrorStatus(
          Messages.format(
              RefactoringCoreMessages.RenameResourceChange_does_not_exist,
              JavaElementLabels.getTextLabel(fSelection, JavaElementLabels.ALL_DEFAULT)));
  } else if (fSelection instanceof IResource) {
    final IResource resource = (IResource) fSelection;
    if (!resource.exists())
      RefactoringStatus.createFatalErrorStatus(
          Messages.format(
              RefactoringCoreMessages.RenameResourceChange_does_not_exist,
              JavaElementLabels.getTextLabel(fSelection, JavaElementLabels.ALL_DEFAULT)));
  }
  return new RefactoringStatus();
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
private void confirmPackageFragmentRootOverwritting(
    IConfirmQuery skipQuery, IConfirmQuery overwriteQuery) {
  List<IPackageFragmentRoot> toNotOverwrite = new ArrayList<IPackageFragmentRoot>(1);
  for (int i = 0; i < fRoots.length; i++) {
    IPackageFragmentRoot root = fRoots[i];
    if (canOverwrite(root)) {
      if (root.getResource() instanceof IContainer) {
        if (!skip(
            JavaElementLabels.getElementLabel(root, JavaElementLabels.ALL_DEFAULT), skipQuery))
          toNotOverwrite.add(root);
      } else {
        if (!overwrite(root.getResource(), overwriteQuery)) toNotOverwrite.add(root);
      }
    }
  }
  IPackageFragmentRoot[] roots =
      toNotOverwrite.toArray(new IPackageFragmentRoot[toNotOverwrite.size()]);
  fRoots = ArrayTypeConverter.toPackageFragmentRootArray(ReorgUtils.setMinus(fRoots, roots));
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
@Override
protected boolean isValidPrefix(String prefix) {
  if (super.isValidPrefix(prefix)) return true;

  String word = TextProcessor.deprocess(getDisplayString());
  if (fProposal.getKind() == CompletionProposal.CONSTRUCTOR_INVOCATION) {
    int start =
        word.indexOf(JavaElementLabels.CONCAT_STRING) + JavaElementLabels.CONCAT_STRING.length();
    word = word.substring(start);
    return isPrefix(prefix, word) || isPrefix(prefix, new String(fProposal.getName()));
  }

  if (isInJavadoc()) {
    int idx = word.indexOf("{@link "); // $NON-NLS-1$
    if (idx == 0) {
      word = word.substring(7);
    } else {
      idx = word.indexOf("{@value "); // $NON-NLS-1$
      if (idx == 0) {
        word = word.substring(8);
      }
    }
  }
  return isPrefix(prefix, word);
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
public static String getMethodSignature(String name, ITypeBinding[] params, boolean isVarArgs) {
  StringBuffer buf = new StringBuffer();
  buf.append(name).append('(');
  for (int i = 0; i < params.length; i++) {
    if (i > 0) {
      buf.append(JavaElementLabels.COMMA_STRING);
    }
    if (isVarArgs && i == params.length - 1) {
      buf.append(getTypeSignature(params[i].getElementType()));
      buf.append("..."); // $NON-NLS-1$
    } else {
      buf.append(getTypeSignature(params[i]));
    }
  }
  buf.append(')');
  return BasicElementLabels.getJavaElementName(buf.toString());
}
 

import org.eclipse.jdt.ui.JavaElementLabels; //导入依赖的package包/类
public static ASTRewriteCorrectionProposal createCastProposal(
    IInvocationContext context,
    ITypeBinding castTypeBinding,
    Expression nodeToCast,
    int relevance) {
  ICompilationUnit cu = context.getCompilationUnit();

  String label;
  String castType =
      BindingLabelProvider.getBindingLabel(castTypeBinding, JavaElementLabels.ALL_DEFAULT);
  if (nodeToCast.getNodeType() == ASTNode.CAST_EXPRESSION) {
    label =
        Messages.format(
            CorrectionMessages.TypeMismatchSubProcessor_changecast_description, castType);
  } else {
    label =
        Messages.format(
            CorrectionMessages.TypeMismatchSubProcessor_addcast_description, castType);
  }
  return new CastCorrectionProposal(label, cu, nodeToCast, castTypeBinding, relevance);
}