Java JdtFlags.isDefaultMethod方法代码示例

import org.eclipse.jdt.internal.corext.util.JdtFlags; //导入方法依赖的package包/类
/**
 * Returns the possible target interfaces for the migration. NOTE: One
 * difference here between this refactoring and pull up is that we can have
 * a much more complex type hierarchy due to multiple interface inheritance
 * in Java.
 * <p>
 * TODO: It should be possible to pull up a method into an interface (i.e.,
 * "Pull Up Method To Interface") that is not implemented explicitly. For
 * example, there may be a skeletal implementation class that implements all
 * the target interface's methods without explicitly declaring so.
 * Effectively skeletal?
 *
 * @param monitor
 *            A progress monitor.
 * @return The possible target interfaces for the migration.
 * @throws JavaModelException
 *             upon Java model problems.
 */
public static IType[] getCandidateDestinationInterfaces(IMethod sourcMethod,
		final Optional<IProgressMonitor> monitor) throws JavaModelException {
	try {
		monitor.ifPresent(m -> m.beginTask("Retrieving candidate types...", IProgressMonitor.UNKNOWN));

		IType[] superInterfaces = getSuperInterfaces(sourcMethod.getDeclaringType(),
				monitor.map(m -> new SubProgressMonitor(m, 1)));

		Stream<IType> candidateStream = Stream.of(superInterfaces).parallel().filter(Objects::nonNull)
				.filter(IJavaElement::exists).filter(t -> !t.isReadOnly()).filter(t -> !t.isBinary());

		Set<IType> ret = new HashSet<>();

		for (Iterator<IType> iterator = candidateStream.iterator(); iterator.hasNext();) {
			IType superInterface = iterator.next();
			IMethod[] interfaceMethods = superInterface.findMethods(sourcMethod);
			if (interfaceMethods != null)
				// the matching methods cannot already be default.
				for (IMethod method : interfaceMethods)
					if (!JdtFlags.isDefaultMethod(method))
						ret.add(superInterface);
		}

		return ret.toArray(new IType[ret.size()]);
	} finally {
		monitor.ifPresent(IProgressMonitor::done);
	}
}
 

import org.eclipse.jdt.internal.corext.util.JdtFlags; //导入方法依赖的package包/类
public static boolean isMoveMethodAvailable(final IMethod method) throws JavaModelException {
  return method.exists()
      && !method.isConstructor()
      && !method.isBinary()
      && !method.isReadOnly()
      && !JdtFlags.isStatic(method)
      && (JdtFlags.isDefaultMethod(method) || !method.getDeclaringType().isInterface());
}
 

import org.eclipse.jdt.internal.corext.util.JdtFlags; //导入方法依赖的package包/类
/**
 * Returns the extracted methods from the compilation unit except the default methods.
 *
 * @param unit the compilation unit
 * @return the extracted methods except the default method
 * @throws JavaModelException if the element does not exist
 */
protected final IMethod[] getExtractedMethods(final ICompilationUnit unit) throws JavaModelException {
	Assert.isNotNull(unit);
	final List<IJavaElement> list= new ArrayList<IJavaElement>();
	for (int index= 0; index < fMembers.length; index++) {
		if (fMembers[index] instanceof IMethod) {
			final IJavaElement element= JavaModelUtil.findInCompilationUnit(unit, fMembers[index]);
			if (element instanceof IMethod && !JdtFlags.isDefaultMethod((IMethod) element))
				list.add(element);
		}
	}
	return list.toArray(new IMethod[list.size()]);
}
 

import org.eclipse.jdt.internal.corext.util.JdtFlags; //导入方法依赖的package包/类
/**
 * Creates the necessary changes to create the delegate method with the
 * original method body.
 *
 * @param document
 *            the buffer containing the source of the source compilation
 *            unit
 * @param declaration
 *            the method declaration to use as source
 * @param rewrite
 *            the ast rewrite to use for the copy of the method body
 * @param rewrites
 *            the compilation unit rewrites
 * @param adjustments
 *            the map of elements to visibility adjustments
 * @param status
 *            the refactoring status
 * @param monitor
 *            the progress monitor to display progress
 * @throws CoreException
 *             if an error occurs
 */
protected void createMethodCopy(IDocument document, MethodDeclaration declaration, ASTRewrite rewrite, Map<ICompilationUnit, CompilationUnitRewrite> rewrites, Map<IMember, IncomingMemberVisibilityAdjustment> adjustments, RefactoringStatus status, IProgressMonitor monitor) throws CoreException {
	Assert.isNotNull(document);
	Assert.isNotNull(declaration);
	Assert.isNotNull(rewrite);
	Assert.isNotNull(rewrites);
	Assert.isNotNull(adjustments);
	Assert.isNotNull(status);
	Assert.isNotNull(monitor);
	final CompilationUnitRewrite rewriter= getCompilationUnitRewrite(rewrites, getTargetType().getCompilationUnit());
	try {
		rewrite.set(declaration, MethodDeclaration.NAME_PROPERTY, rewrite.getAST().newSimpleName(fMethodName), null);
		boolean same= false;
		final IMethodBinding binding= declaration.resolveBinding();
		if (binding != null) {
			final ITypeBinding declaring= binding.getDeclaringClass();
			if (declaring != null && Bindings.equals(declaring.getPackage(), fTarget.getType().getPackage()))
				same= true;
			final Modifier.ModifierKeyword keyword= same ? null : Modifier.ModifierKeyword.PUBLIC_KEYWORD;
			ModifierRewrite modifierRewrite= ModifierRewrite.create(rewrite, declaration);
			if (JdtFlags.isDefaultMethod(binding) && getTargetType().isClass()) {
				// Remove 'default' modifier and add 'public' visibility
				modifierRewrite.setVisibility(Modifier.PUBLIC, null);
				modifierRewrite.setModifiers(Modifier.NONE, Modifier.DEFAULT, null);
			} else if (!JdtFlags.isDefaultMethod(binding) && getTargetType().isInterface()) {
				// Remove visibility modifiers and add 'default'
				modifierRewrite.setModifiers(Modifier.DEFAULT, Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE, null);
			} else if (MemberVisibilityAdjustor.hasLowerVisibility(binding.getModifiers(), same ? Modifier.NONE : keyword == null ? Modifier.NONE : keyword.toFlagValue())
					&& MemberVisibilityAdjustor.needsVisibilityAdjustments(fMethod, keyword, adjustments)) {
				final MemberVisibilityAdjustor.IncomingMemberVisibilityAdjustment adjustment= new MemberVisibilityAdjustor.IncomingMemberVisibilityAdjustment(fMethod, keyword, RefactoringStatus.createStatus(RefactoringStatus.WARNING, Messages.format(RefactoringCoreMessages.MemberVisibilityAdjustor_change_visibility_method_warning, new String[] { MemberVisibilityAdjustor.getLabel(fMethod), MemberVisibilityAdjustor.getLabel(keyword) }), JavaStatusContext.create(fMethod), null, RefactoringStatusEntry.NO_CODE, null));
				modifierRewrite.setVisibility(keyword == null ? Modifier.NONE : keyword.toFlagValue(), null);
				adjustment.setNeedsRewriting(false);
				adjustments.put(fMethod, adjustment);
			}
		}
		for (IExtendedModifier modifier : (List<IExtendedModifier>) declaration.modifiers()) {
			if (modifier.isAnnotation()) {
				Annotation annotation= (Annotation) modifier;
				ITypeBinding typeBinding= annotation.resolveTypeBinding();
				if (typeBinding != null && typeBinding.getQualifiedName().equals("java.lang.Override")) { //$NON-NLS-1$
					rewrite.remove(annotation, null);
				}
			}
		}
		createMethodArguments(rewrites, rewrite, declaration, adjustments, status);
		createMethodTypeParameters(rewrite, declaration, status);
		createMethodComment(rewrite, declaration);
		createMethodBody(rewriter, rewrite, declaration);
	} finally {
		if (fMethod.getCompilationUnit().equals(getTargetType().getCompilationUnit()))
			rewriter.clearImportRewrites();
	}
}
 

import org.eclipse.jdt.internal.corext.util.JdtFlags; //导入方法依赖的package包/类
public static boolean isMoveMethodAvailable(final IMethod method) throws JavaModelException {
	return method.exists() && !method.isConstructor() && !method.isBinary() && !method.isReadOnly()
			&& !JdtFlags.isStatic(method) && (JdtFlags.isDefaultMethod(method) || !method.getDeclaringType().isInterface());
}