import lombok.experimental.ExtensionMethod; //导入依赖的package包/类
static List<Extension> getApplicableExtensionMethods(EclipseNode typeNode, Annotation ann, TypeBinding receiverType) {
	List<Extension> extensions = new ArrayList<Extension>();
	if ((typeNode != null) && (ann != null) && (receiverType != null)) {
		BlockScope blockScope = ((TypeDeclaration) typeNode.get()).initializerScope;
		EclipseNode annotationNode = typeNode.getNodeFor(ann);
		AnnotationValues<ExtensionMethod> annotation = createAnnotation(ExtensionMethod.class, annotationNode);
		boolean suppressBaseMethods = false;
		try {
			suppressBaseMethods = annotation.getInstance().suppressBaseMethods();
		} catch (AnnotationValueDecodeFail fail) {
			fail.owner.setError(fail.getMessage(), fail.idx);
		}
		for (Object extensionMethodProvider : annotation.getActualExpressions("value")) {
			if (extensionMethodProvider instanceof ClassLiteralAccess) {
				TypeBinding binding = ((ClassLiteralAccess) extensionMethodProvider).type.resolveType(blockScope);
				if (binding == null) continue;
				if (!binding.isClass() && !binding.isEnum()) continue;
				Extension e = new Extension();
				e.extensionMethods = getApplicableExtensionMethodsDefinedInProvider(typeNode, (ReferenceBinding) binding, receiverType);
				e.suppressBaseMethods = suppressBaseMethods;
				extensions.add(e);
			}
		}
	}
	return extensions;
}
 

import lombok.experimental.ExtensionMethod; //导入依赖的package包/类
@Override public void handle(AnnotationValues<ExtensionMethod> annotation, Annotation ast, EclipseNode annotationNode) {
	TypeDeclaration typeDecl = null;
	EclipseNode owner = annotationNode.up();
	if (owner.get() instanceof TypeDeclaration) typeDecl = (TypeDeclaration) owner.get();
	int modifiers = typeDecl == null ? 0 : typeDecl.modifiers;
	
	boolean notAClass = (modifiers &
			(ClassFileConstants.AccInterface | ClassFileConstants.AccAnnotation)) != 0;
	
	if (typeDecl == null || notAClass) {
		annotationNode.addError("@ExtensionMethod is legal only on classes and enums.");
		return;
	}
	
	List<Object> listenerInterfaces = annotation.getActualExpressions("value");
	if (listenerInterfaces.isEmpty()) {
		annotationNode.addWarning(String.format("@ExtensionMethod has no effect since no extension types were specified."));
		return;
	}
}
 

import lombok.experimental.ExtensionMethod; //导入依赖的package包/类
private static List<Extension> getExtensionMethods(CompletionProposalCollector completionProposalCollector) {
	List<Extension> extensions = new ArrayList<Extension>();
	ClassScope classScope = getClassScope(completionProposalCollector);
	if (classScope != null) {
		TypeDeclaration decl = classScope.referenceContext;
		TypeBinding firstParameterType = getFirstParameterType(decl, completionProposalCollector);
		for (EclipseNode typeNode = getTypeNode(decl); typeNode != null; typeNode = upToType(typeNode)) {
			Annotation ann = getAnnotation(ExtensionMethod.class, typeNode);
			extensions.addAll(0, getApplicableExtensionMethods(typeNode, ann, firstParameterType));
		}
	}
	return extensions;
}
 

import lombok.experimental.ExtensionMethod; //导入依赖的package包/类
@Override
public void handle(final AnnotationValues<ExtensionMethod> annotation, final JCAnnotation source, final JavacNode annotationNode) {
	handleExperimentalFlagUsage(annotationNode, ConfigurationKeys.EXTENSION_METHOD_FLAG_USAGE, "@ExtensionMethod");
	
	deleteAnnotationIfNeccessary(annotationNode, ExtensionMethod.class);
	JavacNode typeNode = annotationNode.up();
	boolean isClassOrEnum = isClassOrEnum(typeNode);
	
	if (!isClassOrEnum) {
		annotationNode.addError("@ExtensionMethod can only be used on a class or an enum");
		return;
	}
	
	boolean suppressBaseMethods = annotation.getInstance().suppressBaseMethods();
	
	List<Object> extensionProviders = annotation.getActualExpressions("value");
	if (extensionProviders.isEmpty()) {
		annotationNode.addError(String.format("@%s has no effect since no extension types were specified.", ExtensionMethod.class.getName()));
		return;
	}
	final List<Extension> extensions = getExtensions(annotationNode, extensionProviders);
	if (extensions.isEmpty()) return;
	
	new ExtensionMethodReplaceVisitor(annotationNode, extensions, suppressBaseMethods).replace();
	
	annotationNode.rebuild();
}