org.eclipse.jdt.core.dom.ASTRequestor#org.eclipse.jdt.core.IMember源码实例Demo

@Override
public boolean canEnable() throws JavaModelException {
	if (!super.canEnable() || fJavaElements.length == 0)
		return false;

	for (int i= 0; i < fJavaElements.length; i++) {
		if (fJavaElements[i] instanceof IMember) {
			IMember member= (IMember) fJavaElements[i];
			// we can copy some binary members, but not all
			if (member.isBinary() && member.getSourceRange() == null)
				return false;
		}
	}

	return true;
}
 

public static IMember[] getPushDownMembers(final IType type) throws JavaModelException {
	final List<IMember> list= new ArrayList<IMember>(3);
	if (type.exists()) {
		IMember[] members= type.getFields();
		for (int index= 0; index < members.length; index++) {
			if (isPushDownAvailable(members[index]))
				list.add(members[index]);
		}
		members= type.getMethods();
		for (int index= 0; index < members.length; index++) {
			if (isPushDownAvailable(members[index]))
				list.add(members[index]);
		}
	}
	return list.toArray(new IMember[list.size()]);
}
 

public static boolean isMoveAvailable(final IResource[] resources, final IJavaElement[] elements) throws JavaModelException {
	if (elements != null) {
		for (int index= 0; index < elements.length; index++) {
			IJavaElement element= elements[index];
			if (element == null || !element.exists())
				return false;
			if ((element instanceof IType) && ((IType) element).isLocal())
				return false;
			if ((element instanceof IPackageDeclaration))
				return false;
			if (element instanceof IField && JdtFlags.isEnum((IMember) element))
				return false;
		}
	}
	return ReorgPolicyFactory.createMovePolicy(resources, elements).canEnable();
}
 

private void addMethodStubForAbstractMethod(final IMethod sourceMethod, final CompilationUnit declaringCuNode, final AbstractTypeDeclaration typeToCreateStubIn, final ICompilationUnit newCu, final CompilationUnitRewrite rewriter, final Map<IMember, IncomingMemberVisibilityAdjustment> adjustments, final IProgressMonitor monitor, final RefactoringStatus status) throws CoreException {
	final MethodDeclaration methodToCreateStubFor= ASTNodeSearchUtil.getMethodDeclarationNode(sourceMethod, declaringCuNode);
	final AST ast= rewriter.getRoot().getAST();
	final MethodDeclaration newMethod= ast.newMethodDeclaration();
	newMethod.setBody(createMethodStub(methodToCreateStubFor, ast));
	newMethod.setConstructor(false);
	copyExtraDimensions(methodToCreateStubFor, newMethod);
	newMethod.modifiers().addAll(ASTNodeFactory.newModifiers(ast, getModifiersWithUpdatedVisibility(sourceMethod, JdtFlags.clearFlag(Modifier.NATIVE | Modifier.ABSTRACT, methodToCreateStubFor.getModifiers()), adjustments, new SubProgressMonitor(monitor, 1), false, status)));
	newMethod.setName(((SimpleName) ASTNode.copySubtree(ast, methodToCreateStubFor.getName())));
	final TypeVariableMaplet[] mapping= TypeVariableUtil.composeMappings(TypeVariableUtil.subTypeToSuperType(getDeclaringType(), getDestinationType()), TypeVariableUtil.superTypeToInheritedType(getDestinationType(), ((IType) typeToCreateStubIn.resolveBinding().getJavaElement())));
	copyReturnType(rewriter.getASTRewrite(), getDeclaringType().getCompilationUnit(), methodToCreateStubFor, newMethod, mapping);
	copyParameters(rewriter.getASTRewrite(), getDeclaringType().getCompilationUnit(), methodToCreateStubFor, newMethod, mapping);
	copyThrownExceptions(methodToCreateStubFor, newMethod);
	newMethod.setJavadoc(createJavadocForStub(typeToCreateStubIn.getName().getIdentifier(), methodToCreateStubFor, newMethod, newCu, rewriter.getASTRewrite()));
	ImportRewriteContext context= new ContextSensitiveImportRewriteContext(typeToCreateStubIn, rewriter.getImportRewrite());
	ImportRewriteUtil.addImports(rewriter, context, newMethod, new HashMap<Name, String>(), new HashMap<Name, String>(), false);
	rewriter.getASTRewrite().getListRewrite(typeToCreateStubIn, typeToCreateStubIn.getBodyDeclarationsProperty()).insertAt(newMethod, ASTNodes.getInsertionIndex(newMethod, typeToCreateStubIn.bodyDeclarations()), rewriter.createCategorizedGroupDescription(RefactoringCoreMessages.PullUpRefactoring_add_method_stub, SET_PULL_UP));
}
 

private static IMember[] getSelectedMembers(final IStructuredSelection selection) {
	if (selection.isEmpty())
		return null;
	if (selection.size() == 1) {
		try {
			final IType type= RefactoringAvailabilityTester.getSingleSelectedType(selection);
			if (type != null)
				return new IType[] {type};
		} catch (JavaModelException exception) {
			JavaPlugin.log(exception);
		}
	}
	for (final Iterator<?> iterator= selection.iterator(); iterator.hasNext();) {
		if (!(iterator.next() instanceof IMember))
			return null;
	}
	final Set<IMember> set= new HashSet<IMember>();
	@SuppressWarnings("unchecked")
	List<IMember> selectionList= (List<IMember>) (List<?>) Arrays.asList(selection.toArray());
	set.addAll(selectionList);
	return set.toArray(new IMember[set.size()]);
}
 

/**
 * Creates a new search scope with all compilation units possibly referencing
 * <code>javaElement</code>.
 *
 * @param javaElement
 *            the java element
 * @param considerVisibility
 *            consider visibility of javaElement iff <code>true</code>
 * @param sourceReferencesOnly
 *            consider references in source only (no references in binary)
 * @return the search scope
 * @throws JavaModelException
 *             if an error occurs
 */
public static IJavaSearchScope create(IJavaElement javaElement, boolean considerVisibility, boolean sourceReferencesOnly) throws JavaModelException {
	if (considerVisibility & javaElement instanceof IMember) {
		IMember member = (IMember) javaElement;
		if (JdtFlags.isPrivate(member)) {
			if (member.getCompilationUnit() != null) {
				return SearchEngine.createJavaSearchScope(new IJavaElement[] { member.getCompilationUnit() });
			} else {
				return SearchEngine.createJavaSearchScope(new IJavaElement[] { member });
			}
		}
		// Removed code that does some optimizations regarding package visible members. The problem is that
		// there can be a package fragment with the same name in a different source folder or project. So we
		// have to treat package visible members like public or protected members.
	}

	IJavaProject javaProject = javaElement.getJavaProject();
	return SearchEngine.createJavaSearchScope(getAllScopeElements(javaProject, sourceReferencesOnly), false);
}
 

@Override
public boolean canEnable() throws JavaModelException {
	if (!super.canEnable() || fJavaElements.length == 0) {
		return false;
	}

	for (int i= 0; i < fJavaElements.length; i++) {
		if (fJavaElements[i] instanceof IMember) {
			IMember member= (IMember) fJavaElements[i];
			// we can copy some binary members, but not all
			if (member.isBinary() && member.getSourceRange() == null) {
				return false;
			}
		}
	}

	return true;
}
 

public static CallHierarchyViewPart openView(IMember[] input, IWorkbenchWindow window) {
  	if (input.length == 0) {
	MessageDialog.openInformation(window.getShell(), CallHierarchyMessages.CallHierarchyUI_selectionDialog_title,
			CallHierarchyMessages.CallHierarchyUI_open_operation_unavialable);
	return null;
}
      IWorkbenchPage page= window.getActivePage();
try {
	CallHierarchyViewPart viewPart= getDefault().findLRUCallHierarchyViewPart(page); //find the first view which is not pinned
	String secondaryId= null;
	if (viewPart == null) {
		if (page.findViewReference(CallHierarchyViewPart.ID_CALL_HIERARCHY) != null) //all the current views are pinned, open a new instance
			secondaryId= String.valueOf(++getDefault().fViewCount);
	} else
		secondaryId= viewPart.getViewSite().getSecondaryId();
	viewPart= (CallHierarchyViewPart)page.showView(CallHierarchyViewPart.ID_CALL_HIERARCHY, secondaryId, IWorkbenchPage.VIEW_ACTIVATE);
	viewPart.setInputElements(input);
	return viewPart;
      } catch (CoreException e) {
          ExceptionHandler.handle(e, window.getShell(),
              CallHierarchyMessages.CallHierarchyUI_error_open_view, e.getMessage());
      }
      return null;
  }
 

protected void updateUIElementEnablement() {
	final IMember[] checked= getCheckedMembers();
	IMember[] extractable;
	try {
		extractable= getExtractableMembers();
	} catch (JavaModelException exception) {
		extractable= new IMember[0];
		JavaPlugin.log(exception);
	}
	final boolean enabled= containsMethods(checked);
	fDeclarePublicCheckbox.setEnabled(enabled);
	fDeclareAbstractCheckbox.setEnabled(enabled);
	fGenerateAnnotationsCheckbox.setEnabled(enabled);
	fGenerateCommentsCheckbox.setEnabled(enabled);
	fInstanceofCheckbox.setEnabled(fReplaceAllCheckbox.getSelection());
	fSelectAllButton.setEnabled(checked.length < extractable.length);
	fDeselectAllButton.setEnabled(checked.length > 0);
}
 

public static boolean isMoveAvailable(final IResource[] resources, final IJavaElement[] elements) throws JavaModelException {
	if (elements != null) {
		for (int index = 0; index < elements.length; index++) {
			IJavaElement element = elements[index];
			if (element == null || !element.exists()) {
				return false;
			}
			if ((element instanceof IType) && ((IType) element).isLocal()) {
				return false;
			}
			if ((element instanceof IPackageDeclaration)) {
				return false;
			}
			if (element instanceof IField && JdtFlags.isEnum((IMember) element)) {
				return false;
			}
		}
	}
	return ReorgPolicyFactory.createMovePolicy(resources, elements).canEnable();
}
 

/**
 * Appends the styled label for a type parameter.
 *
 * @param typeParameter the element to render
 * @param flags the rendering flags. Flags with names starting with 'T_' are considered.
 */
public void appendTypeParameterLabel(ITypeParameter typeParameter, long flags) {
	try {
		appendTypeParameterWithBounds(typeParameter, flags);

		// post qualification
		if (getFlag(flags, JavaElementLabels.TP_POST_QUALIFIED)) {
			fBuffer.append(JavaElementLabels.CONCAT_STRING);
			IMember declaringMember= typeParameter.getDeclaringMember();
			appendElementLabel(declaringMember, JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.M_FULLY_QUALIFIED | JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS));
		}

	} catch (JavaModelException e) {
		JavaPlugin.log(e); // NotExistsException will not reach this point
	}
}
 

@Override
public boolean filters(JavaElementMatch match) {
	Object element= match.getElement();
	if (element instanceof IMember) {
		try {
			return ! JdtFlags.isStatic((IMember) element);
		} catch (JavaModelException e) {
			JavaPlugin.log(e);
		}
	}
	return false;
}
 

@Override
public void run(IStructuredSelection selection) {
	try {
		IMember member= getMember(selection);
		if (member == null || !ActionUtil.isEditable(getShell(), member))
			return;
		ISourceRange range= member.getNameRange();
		RefactoringExecutionStarter.startChangeTypeRefactoring(member.getCompilationUnit(), getShell(), range.getOffset(), range.getLength());
	} catch (CoreException e) {
		ExceptionHandler.handle(e, RefactoringMessages.ChangeTypeAction_dialog_title, RefactoringMessages.ChangeTypeAction_exception);
	}
}
 

private RefactoringStatus checkIfDeclaredIn(final IMember element, final IType type) throws JavaModelException {
	if (element instanceof IMethod)
		return checkIfMethodDeclaredIn((IMethod) element, type);
	else if (element instanceof IField)
		return checkIfFieldDeclaredIn((IField) element, type);
	else if (element instanceof IType)
		return checkIfTypeDeclaredIn((IType) element, type);
	Assert.isTrue(false);
	return null;
}
 

private static IMember[] convertToMemberArray(Object[] obj) {
	if (obj == null)
		return null;
	Set<Object> memberSet= new HashSet<Object>();
	memberSet.addAll(Arrays.asList(obj));
	return memberSet.toArray(new IMember[memberSet.size()]);
}
 

protected void copyToDestination(IJavaElement element, CompilationUnitRewrite targetRewriter, CompilationUnit sourceCuNode, CompilationUnit targetCuNode) throws CoreException {
	final ASTRewrite rewrite= targetRewriter.getASTRewrite();
	switch (element.getElementType()) {
		case IJavaElement.FIELD:
			copyMemberToDestination((IMember) element, targetRewriter, sourceCuNode, targetCuNode, createNewFieldDeclarationNode(((IField) element), rewrite, sourceCuNode));
			break;
		case IJavaElement.IMPORT_CONTAINER:
			copyImportsToDestination((IImportContainer) element, rewrite, sourceCuNode, targetCuNode);
			break;
		case IJavaElement.IMPORT_DECLARATION:
			copyImportToDestination((IImportDeclaration) element, rewrite, sourceCuNode, targetCuNode);
			break;
		case IJavaElement.INITIALIZER:
			copyInitializerToDestination((IInitializer) element, targetRewriter, sourceCuNode, targetCuNode);
			break;
		case IJavaElement.METHOD:
			copyMethodToDestination((IMethod) element, targetRewriter, sourceCuNode, targetCuNode);
			break;
		case IJavaElement.PACKAGE_DECLARATION:
			copyPackageDeclarationToDestination((IPackageDeclaration) element, rewrite, sourceCuNode, targetCuNode);
			break;
		case IJavaElement.TYPE:
			copyTypeToDestination((IType) element, targetRewriter, sourceCuNode, targetCuNode);
			break;

		default:
			Assert.isTrue(false);
	}
}
 

/**
 * {@inheritDoc}
 */
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor monitor) throws CoreException, OperationCanceledException {
	try {
		monitor.beginTask(RefactoringCoreMessages.PushDownRefactoring_checking, 1);
		RefactoringStatus status= new RefactoringStatus();
		status.merge(checkPossibleSubclasses(new SubProgressMonitor(monitor, 1)));
		if (status.hasFatalError())
			return status;
		status.merge(checkDeclaringType(new SubProgressMonitor(monitor, 1)));
		if (status.hasFatalError())
			return status;
		status.merge(checkIfMembersExist());
		if (status.hasFatalError())
			return status;
		fMemberInfos= createInfosForAllPushableFieldsAndMethods(getDeclaringType());
		List<IMember> list= Arrays.asList(fMembersToMove);
		for (int offset= 0; offset < fMemberInfos.length; offset++) {
			MemberActionInfo info= fMemberInfos[offset];
			if (list.contains(info.getMember()))
				info.setAction(MemberActionInfo.PUSH_DOWN_ACTION);
		}
		return status;
	} finally {
		monitor.done();
	}
}
 

@Override
public IEditorPart open(URI uri, IMember member, boolean select) {
	if (member != null) {
		URI memberURI = new TypeURIHelper().getFullURI(member);
		String identifier = memberURI.fragment();
		// we decode the qualified name into the uri using query, such that it can be read out in #findEObjectByURI again
		URI uriWithQuery = uri.appendQuery(identifier);
		return super.open(uriWithQuery, select);
	}
	return open(uri, select);
}
 

private MemberActionInfo[] asMemberActionInfos() {
	final List<IMember> toPullUp= Arrays.asList(fProcessor.getMembersToMove());
	final IMember[] members= fProcessor.getPullableMembersOfDeclaringType();
	final MemberActionInfo[] result= new MemberActionInfo[members.length];
	for (int i= 0; i < members.length; i++) {
		final IMember member= members[i];
		if (toPullUp.contains(member))
			result[i]= new MemberActionInfo(member, PULL_UP_ACTION);
		else
			result[i]= new MemberActionInfo(member, MemberActionInfo.NO_ACTION);
	}
	return result;
}
 

public Object getNewElement() throws CoreException {
	IMember member= fTypeParameter.getDeclaringMember();
	if (member instanceof IType) {
		IType type= (IType) member;
		return type.getTypeParameter(getNewElementName());
	} else if (member instanceof IMethod) {
		IMethod method= (IMethod) member;
		return method.getTypeParameter(getNewElementName());
	} else {
		JavaPlugin.logErrorMessage("Unexpected sub-type of IMember: " + member.getClass().getName()); //$NON-NLS-1$
		Assert.isTrue(false);
	}
	return null;
}
 

public static boolean isAbstract(IMember member) throws JavaModelException{
	int flags= member.getFlags();
	if (!member.isBinary() && isInterfaceOrAnnotationMethod(member)) {
		return !Flags.isStatic(flags) && !Flags.isDefaultMethod(flags);
	}
	return Flags.isAbstract(flags);
}
 

/**
 * {@code true} if the element is deprecated. Otherwise, {@code false}.
 */
public static boolean isDeprecated(IJavaElement element) throws JavaModelException {
	Assert.isNotNull(element, "element");
	if (element instanceof ITypeRoot) {
		return Flags.isDeprecated(((ITypeRoot) element).findPrimaryType().getFlags());
	} else if (element instanceof IMember) {
		return Flags.isDeprecated(((IMember) element).getFlags());
	}
	return false;
}
 

/**
 * Check whether anyone accesses the members of the moved type from the
 * outside. Those may need to have their visibility adjusted.
 * @param member the member
 * @param monitor the progress monitor to use
 * @throws JavaModelException if an error occurs
 */
private void adjustMemberVisibility(final IMember member, final IProgressMonitor monitor) throws JavaModelException {

	if (member instanceof IType) {
		// recursively check accessibility of member type's members
		final IJavaElement[] typeMembers= ((IType) member).getChildren();
		for (int i= 0; i < typeMembers.length; i++) {
			if (! (typeMembers[i] instanceof IInitializer))
				adjustMemberVisibility((IMember) typeMembers[i], monitor);
		}
	}

	if (member.equals(fReferenced) || Modifier.isPublic(member.getFlags()))
		return;

	final SearchResultGroup[] references= findReferences(member, monitor);
	for (int i= 0; i < references.length; i++) {
		final SearchMatch[] searchResults= references[i].getSearchResults();
		for (int k= 0; k < searchResults.length; k++) {
			final IJavaElement referenceToMember= (IJavaElement) searchResults[k].getElement();
			if (fAdjustments.get(member) == null && referenceToMember instanceof IMember && !isInsideMovedMember(referenceToMember)) {
				// check whether the member is still visible from the
				// destination. As we are moving a type, the destination is
				// a package or another type.
				adjustIncomingVisibility(fReferencing, member, new SubProgressMonitor(monitor, 1));
			}
		}
	}
}
 

private Reader getContentReader(IMember member, IProgressMonitor monitor) throws JavaModelException {
    Reader contentReader = JavadocContentAccess.getContentReader(member, true);
    if (contentReader != null) {
        return contentReader;
    }

    if (member.getOpenable().getBuffer() == null) { // only if no source available
        String s = member.getAttachedJavadoc(monitor);
        if (s != null) {
            return new StringReader(s);
        }
    }
    return null;
}
 

private static Map<IType, IMember[]> createTypeToMemberArrayMapping(final IMember[] members) {
	final Map<IType, HashSet<IMember>> typeToMemberSet= createTypeToMemberSetMapping(members);

	final Map<IType, IMember[]> typeToMemberArray= new HashMap<IType, IMember[]>();
	for (final Iterator<IType> iter= typeToMemberSet.keySet().iterator(); iter.hasNext();) {
		final IType type= iter.next();
		final Set<IMember> memberSet= typeToMemberSet.get(type);
		final IMember[] memberArray= memberSet.toArray(new IMember[memberSet.size()]);
		typeToMemberArray.put(type, memberArray);
	}
	return typeToMemberArray;
}
 

public static boolean isFinal(IMember member) throws JavaModelException{
	if (isInterfaceOrAnnotationField(member)) {
		return true;
	}
	if (isAnonymousType(member)) {
		return true;
	}
	if (isEnumConstant(member) || isEnumTypeFinal(member)) {
		return true;
	}
	return Flags.isFinal(member.getFlags());
}
 

private RefactoringStatus checkAbstractMembersInDestinationClasses(IMember[] membersToPushDown, IType[] destinationClassesForAbstract) throws JavaModelException {
	RefactoringStatus result= new RefactoringStatus();
	IMember[] abstractMembersToPushDown= getAbstractMembers(membersToPushDown);
	for (int index= 0; index < destinationClassesForAbstract.length; index++) {
		result.merge(MemberCheckUtil.checkMembersInDestinationType(abstractMembersToPushDown, destinationClassesForAbstract[index]));
	}
	return result;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void run(final IStructuredSelection selection) {
	try {
		final IMember[] members= getSelectedMembers(selection);
		if (RefactoringAvailabilityTester.isExtractSupertypeAvailable(members) && ActionUtil.isEditable(getShell(), members[0]))
			RefactoringExecutionStarter.startExtractSupertypeRefactoring(members, getShell());
	} catch (final JavaModelException exception) {
		ExceptionHandler.handle(exception, RefactoringMessages.OpenRefactoringWizardAction_refactoring, RefactoringMessages.OpenRefactoringWizardAction_exception);
	}
}
 

public static boolean isMoveStaticMembersAvailable(final IMember[] members) throws JavaModelException {
	if (members == null)
		return false;
	if (members.length == 0)
		return false;
	if (!isMoveStaticAvailable(members))
		return false;
	if (!isCommonDeclaringType(members))
		return false;
	return true;
}
 

public static void startExtractSupertypeRefactoring(final IMember[] members, final Shell shell) throws JavaModelException {
	if (!RefactoringAvailabilityTester.isExtractSupertypeAvailable(members))
		return;
	IJavaProject project= null;
	if (members != null && members.length > 0)
		project= members[0].getJavaProject();
	ExtractSupertypeProcessor processor= new ExtractSupertypeProcessor(members, JavaPreferencesSettings.getCodeGenerationSettings(project));
	Refactoring refactoring= new ProcessorBasedRefactoring(processor);
	ExtractSupertypeWizard wizard= new ExtractSupertypeWizard(processor, refactoring);
	new RefactoringStarter().activate(wizard, shell, RefactoringMessages.OpenRefactoringWizardAction_refactoring, RefactoringSaveHelper.SAVE_REFACTORING);
}