Merge pull request #2742 from Rawi01/ecj-fixes

Fix compilation using ecj

src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2020 The Project Lombok Authors.
+ * Copyright (C) 2009-2021 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -697,13 +697,13 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$Delegate", "handleDelegateForType", "boolean", "java.lang.Object"))
 				.build());
 		
-		sm.addScript(ScriptBuilder.setSymbolDuringMethodCall()
+		sm.addScriptIfWitness(OSGI_TYPES, ScriptBuilder.setSymbolDuringMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.SelectionRequestor", "acceptSourceMethod"))
 				.callToWrap(new Hook("org.eclipse.jdt.core.IType", "getMethods", "org.eclipse.jdt.core.IMethod[]"))
 				.symbol("lombok.skipdelegates")
 				.build());
 		
-		sm.addScript(ScriptBuilder.addField()
+		sm.addScriptIfWitness(OSGI_TYPES, ScriptBuilder.addField()
 				.fieldName("$delegateMethods")
 				.fieldType("Ljava/util/Map;")
 				.setPublic()
@@ -711,10 +711,10 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.targetClass("org.eclipse.jdt.internal.core.CompilationUnit")
 				.build());
 		
-		sm.addScript(ScriptBuilder.wrapReturnValue()
+		sm.addScriptIfWitness(OSGI_TYPES, ScriptBuilder.wrapReturnValue()
 				.target(new MethodTarget("org.eclipse.jdt.internal.core.SourceTypeElementInfo", "getChildren", "org.eclipse.jdt.core.IJavaElement[]"))
 				.request(StackRequest.RETURN_VALUE, StackRequest.THIS)
-				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$Delegate", "getChildren", "java.lang.Object[]", "java.lang.Object", "java.lang.Object"))
+				.wrapMethod(new Hook("lombok.launch.PatchFixesHider$Delegate", "addGeneratedDelegateMethods", "java.lang.Object[]", "java.lang.Object", "java.lang.Object"))
 				.build());
 	}
 	
@@ -772,11 +772,12 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 		final String EXPRESSION_SIG = "org.eclipse.jdt.internal.compiler.ast.Expression";
 		final String BLOCKSCOPE_SIG = "org.eclipse.jdt.internal.compiler.lookup.BlockScope";
 		final String TYPEBINDING_SIG = "org.eclipse.jdt.internal.compiler.lookup.TypeBinding";
+		final String OBJECT_SIG = "java.lang.Object";
 		
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget(LOCALDECLARATION_SIG, "resolve", "void", BLOCKSCOPE_SIG))
 				.request(StackRequest.THIS, StackRequest.PARAM1)
-				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$Val", "handleValForLocalDeclaration", "boolean", LOCALDECLARATION_SIG, BLOCKSCOPE_SIG))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$Val", "handleValForLocalDeclaration", "boolean", OBJECT_SIG, OBJECT_SIG))
 				.build());
 		
 		sm.addScript(ScriptBuilder.replaceMethodCall()
@@ -784,18 +785,20 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.methodToReplace(new Hook(EXPRESSION_SIG, "resolveType", TYPEBINDING_SIG, BLOCKSCOPE_SIG))
 				.requestExtra(StackRequest.THIS)
 				.replacementMethod(new Hook("lombok.launch.PatchFixesHider$Val", "skipResolveInitializerIfAlreadyCalled2", TYPEBINDING_SIG, EXPRESSION_SIG, BLOCKSCOPE_SIG, LOCALDECLARATION_SIG))
+				.transplant()
 				.build());
 		
 		sm.addScript(ScriptBuilder.replaceMethodCall()
 				.target(new MethodTarget(FOREACHSTATEMENT_SIG, "resolve", "void", BLOCKSCOPE_SIG))
 				.methodToReplace(new Hook(EXPRESSION_SIG, "resolveType", TYPEBINDING_SIG, BLOCKSCOPE_SIG))
 				.replacementMethod(new Hook("lombok.launch.PatchFixesHider$Val", "skipResolveInitializerIfAlreadyCalled", TYPEBINDING_SIG, EXPRESSION_SIG, BLOCKSCOPE_SIG))
+				.transplant()
 				.build());
 		
 		sm.addScript(ScriptBuilder.exitEarly()
 				.target(new MethodTarget(FOREACHSTATEMENT_SIG, "resolve", "void", BLOCKSCOPE_SIG))
 				.request(StackRequest.THIS, StackRequest.PARAM1)
-				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$Val", "handleValForForEach", "boolean", FOREACHSTATEMENT_SIG, BLOCKSCOPE_SIG))
+				.decisionMethod(new Hook("lombok.launch.PatchFixesHider$Val", "handleValForForEach", "boolean", OBJECT_SIG, OBJECT_SIG))
 				.build());
 	}
 	
@@ -843,33 +846,33 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 			.request(StackRequest.RETURN_VALUE)
 			.request(StackRequest.THIS)
 			.request(StackRequest.PARAM1)
-			.wrapMethod(new Hook(PATCH_EXTENSIONMETHOD, "resolveType", OBJECT_SIG, OBJECT_SIG, MESSAGE_SEND_SIG, BLOCK_SCOPE_SIG))
+			.wrapMethod(new Hook(PATCH_EXTENSIONMETHOD, "resolveType", OBJECT_SIG, OBJECT_SIG, OBJECT_SIG, OBJECT_SIG))
 			.cast()
 			.build());
 		
 		sm.addScript(replaceMethodCall()
 			.target(new MethodTarget(MESSAGE_SEND_SIG, "resolveType", TYPE_BINDING_SIG, BLOCK_SCOPE_SIG))
 			.methodToReplace(new Hook(PROBLEM_REPORTER_SIG, "errorNoMethodFor", "void", MESSAGE_SEND_SIG, TYPE_BINDING_SIG, TYPE_BINDINGS_SIG))
-			.replacementMethod(new Hook(PATCH_EXTENSIONMETHOD, "errorNoMethodFor", "void", PROBLEM_REPORTER_SIG, MESSAGE_SEND_SIG, TYPE_BINDING_SIG, TYPE_BINDINGS_SIG))
+			.replacementMethod(new Hook(PATCH_EXTENSIONMETHOD, "errorNoMethodFor", "void", OBJECT_SIG, OBJECT_SIG, OBJECT_SIG, OBJECT_SIG))
 			.build());
 		
 		sm.addScript(replaceMethodCall()
 			.target(new MethodTarget(MESSAGE_SEND_SIG, "resolveType", TYPE_BINDING_SIG, BLOCK_SCOPE_SIG))
 			.methodToReplace(new Hook(PROBLEM_REPORTER_SIG, "invalidMethod", "void", MESSAGE_SEND_SIG, METHOD_BINDING_SIG))
-			.replacementMethod(new Hook(PATCH_EXTENSIONMETHOD, "invalidMethod", "void", PROBLEM_REPORTER_SIG, MESSAGE_SEND_SIG, METHOD_BINDING_SIG))
+			.replacementMethod(new Hook(PATCH_EXTENSIONMETHOD, "invalidMethod", "void", OBJECT_SIG, OBJECT_SIG, OBJECT_SIG))
 			.build());
 		
 		// Since eclipse mars; they added a param.
 		sm.addScript(replaceMethodCall()
 			.target(new MethodTarget(MESSAGE_SEND_SIG, "resolveType", TYPE_BINDING_SIG, BLOCK_SCOPE_SIG))
 			.methodToReplace(new Hook(PROBLEM_REPORTER_SIG, "invalidMethod", "void", MESSAGE_SEND_SIG, METHOD_BINDING_SIG, SCOPE_SIG))
-			.replacementMethod(new Hook(PATCH_EXTENSIONMETHOD, "invalidMethod", "void", PROBLEM_REPORTER_SIG, MESSAGE_SEND_SIG, METHOD_BINDING_SIG, SCOPE_SIG))
+			.replacementMethod(new Hook(PATCH_EXTENSIONMETHOD, "invalidMethod", "void", OBJECT_SIG, OBJECT_SIG, OBJECT_SIG, OBJECT_SIG))
 			.build());
 		
 		sm.addScript(replaceMethodCall()
 			.target(new MethodTarget(MESSAGE_SEND_SIG, "resolveType", TYPE_BINDING_SIG, BLOCK_SCOPE_SIG))
 			.methodToReplace(new Hook(PROBLEM_REPORTER_SIG, "nonStaticAccessToStaticMethod", "void", AST_NODE, METHOD_BINDING_SIG))
-			.replacementMethod(new Hook(PATCH_EXTENSIONMETHOD, "nonStaticAccessToStaticMethod", "void", PROBLEM_REPORTER_SIG, AST_NODE, METHOD_BINDING_SIG, MESSAGE_SEND_SIG))
+			.replacementMethod(new Hook(PATCH_EXTENSIONMETHOD, "nonStaticAccessToStaticMethod", "void", OBJECT_SIG, OBJECT_SIG, OBJECT_SIG, OBJECT_SIG))
 			.requestExtra(StackRequest.THIS)
 			.build());
 		

src/eclipseAgent/lombok/eclipse/agent/PatchDelegate.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2020 The Project Lombok Authors.
+ * Copyright (C) 2010-2021 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -148,7 +148,9 @@ public class PatchDelegate {
 		
 		CompilationUnitDeclaration cud = scope.compilationUnitScope().referenceContext;
 		if (scope == scope.compilationUnitScope().topLevelTypes[0].scope) {
-			cleanupDelegateMethods(cud);
+			if (eclipseAvailable) {
+				EclipseOnlyMethods.cleanupDelegateMethods(cud);
+			}
 		}
 		
 		if (!hasDelegateMarkedFieldsOrMethods(scope.referenceContext)) return false;
@@ -195,8 +197,8 @@ public class PatchDelegate {
 				}
 			} finally {
 				stack.remove(stack.size() - 1);
-				if (stack.isEmpty()) {
-					notifyDelegateMethodsAdded(cud);
+				if (stack.isEmpty() && eclipseAvailable) {
+					EclipseOnlyMethods.notifyDelegateMethodsAdded(cud);
 				}
 			}
 		}
@@ -204,16 +206,6 @@ public class PatchDelegate {
 		return false;
 	}
 	
-	public static IJavaElement[] getChildren(IJavaElement[] returnValue, SourceTypeElementInfo javaElement) {
-		if (Symbols.hasSymbol("lombok.skipdelegates")) return returnValue;
-		
-		List<SourceMethod> delegateMethods = getDelegateMethods((SourceType) javaElement.getHandle());
-		if (delegateMethods != null) {
-			return concat(returnValue, delegateMethods.toArray(new IJavaElement[0]), IJavaElement.class);
-		}
-		return returnValue;
-	}
-	
 	/**
 	 * Returns a string containing the signature of a method that appears (erased) at least twice in the list.
 	 * If no duplicates are present, {@code null} is returned.
@@ -459,11 +451,7 @@ public class PatchDelegate {
 	
 	private static void generateDelegateMethods(EclipseNode typeNode, List<BindingTuple> methods, DelegateReceiver delegateReceiver) {
 		CompilationUnitDeclaration top = (CompilationUnitDeclaration) typeNode.top().get();
-		
-		String qualifiedName = new String(CharOperation.concatWith(getQualifiedInnerName(typeNode.up(), typeNode.getName().toCharArray()), '$'));
-		SourceType sourceType = getSourceType(top, qualifiedName);
-		List<SourceMethod> delegateSourceMethods = getDelegateMethods(sourceType);
-		
+		List<MethodDeclaration> addedMethods = new ArrayList<MethodDeclaration>();
 		for (BindingTuple pair : methods) {
 			EclipseNode annNode = typeNode.getAst().get(pair.responsible);
 			MethodDeclaration method = createDelegateMethod(pair.fieldName, typeNode, pair, top.compilationResult, annNode, delegateReceiver);
@@ -471,12 +459,12 @@ public class PatchDelegate {
 				SetGeneratedByVisitor visitor = new SetGeneratedByVisitor(annNode.get());
 				method.traverse(visitor, ((TypeDeclaration)typeNode.get()).scope);
 				injectMethod(typeNode, method);
-				
-				if (delegateSourceMethods != null) {
-					delegateSourceMethods.add(DelegateSourceMethod.forMethodDeclaration(sourceType, method));
-				}
+				addedMethods.add(method);
 			}
 		}
+		if (eclipseAvailable) {
+			EclipseOnlyMethods.collectGeneratedDelegateMethods(top, typeNode, addedMethods);
+		}
 	}
 	
 	public static void checkConflictOfTypeVarNames(BindingTuple binding, EclipseNode typeNode) throws CantMakeDelegates {
@@ -722,127 +710,159 @@ public class PatchDelegate {
 		return method;
 	}
 	
-	private static void cleanupDelegateMethods(CompilationUnitDeclaration cud) {
-		CompilationUnit compilationUnit = getCompilationUnit(cud);
-		if (compilationUnit != null) {
-			EclipseAugments.CompilationUnit_delegateMethods.clear(compilationUnit);
+	private static boolean eclipseAvailable = true;
+	static {
+		try {
+			CompilationUnit.class.getName();
+		} catch (Throwable t) {
+			eclipseAvailable = false;
 		}
 	}
 	
-	private static boolean javaModelManagerAvailable = true;
-	private static void notifyDelegateMethodsAdded(CompilationUnitDeclaration cud) {
-		CompilationUnit compilationUnit = getCompilationUnit(cud);
-		if (compilationUnit != null && javaModelManagerAvailable) {
-			try {
+	public static Object[] addGeneratedDelegateMethods(Object[] returnValue, Object javaElement) {
+		if (Symbols.hasSymbol("lombok.skipdelegates")) return returnValue;
+		if (!eclipseAvailable) return returnValue;
+		
+		return EclipseOnlyMethods.addGeneratedDelegateMethodsToChildren(returnValue, javaElement);
+	}
+	
+	public static class EclipseOnlyMethods {
+		private static void cleanupDelegateMethods(CompilationUnitDeclaration cud) {
+			CompilationUnit compilationUnit = getCompilationUnit(cud);
+			if (compilationUnit != null) {
+				EclipseAugments.CompilationUnit_delegateMethods.clear(compilationUnit);
+			}
+		}
+
+		public static void collectGeneratedDelegateMethods(CompilationUnitDeclaration top, EclipseNode typeNode, List<MethodDeclaration> addedMethods) {
+			String qualifiedName = new String(CharOperation.concatWith(getQualifiedInnerName(typeNode.up(), typeNode.getName().toCharArray()), '$'));
+			SourceType sourceType = getSourceType(top, qualifiedName);
+			List<SourceMethod> generatedMethods = getGeneratedMethods(sourceType);
+			if (generatedMethods == null) return;
+			
+			for (MethodDeclaration md : addedMethods) {
+				generatedMethods.add(DelegateSourceMethod.forMethodDeclaration(sourceType, md));
+			}
+		}
+		
+		public static Object[] addGeneratedDelegateMethodsToChildren(Object[] returnValue, Object javaElement) {
+			List<SourceMethod> delegateMethods = getGeneratedMethods((SourceType) ((SourceTypeElementInfo) javaElement).getHandle());
+			if (delegateMethods != null) {
+				return concat((IJavaElement[]) returnValue, delegateMethods.toArray(new IJavaElement[0]), IJavaElement.class);
+			}
+			return returnValue;
+		}
+		
+		private static void notifyDelegateMethodsAdded(CompilationUnitDeclaration cud) {
+			CompilationUnit compilationUnit = getCompilationUnit(cud);
+			if (compilationUnit != null) {
 				DeltaProcessor deltaProcessor = JavaModelManager.getJavaModelManager().getDeltaProcessor();
 				deltaProcessor.fire(new JavaElementDelta(compilationUnit), ElementChangedEvent.POST_CHANGE);
-			} catch (NoClassDefFoundError e) {
-				javaModelManagerAvailable = false;
 			}
 		}
-	}
-	
-	private static CompilationUnit getCompilationUnit(Object iCompilationUnit) {
-		if (iCompilationUnit instanceof CompilationUnit) {
-			CompilationUnit compilationUnit = (CompilationUnit) iCompilationUnit;
-			return compilationUnit.originalFromClone();
-		}
-		return null;
-	}
-	
-	private static CompilationUnit getCompilationUnit(CompilationUnitDeclaration cud) {
-		return getCompilationUnit(cud.compilationResult.compilationUnit);
-	}
-	
-	private static final class DelegateSourceMethod extends SourceMethod {
-		private DelegateSourceMethodInfo sourceMethodInfo;
-
-		private static DelegateSourceMethod forMethodDeclaration(JavaElement parent, MethodDeclaration method) {
-			Argument[] arguments = method.arguments != null ? method.arguments : new Argument[0];
-			String[] parameterTypes = new String[arguments.length];
-			for (int i = 0; i < arguments.length; i++) {
-				parameterTypes[i] = Signature.createTypeSignature(CharOperation.concatWith(arguments[i].type.getParameterizedTypeName(), '.'), false);
+		
+		private static CompilationUnit getCompilationUnit(Object iCompilationUnit) {
+			if (iCompilationUnit instanceof CompilationUnit) {
+				CompilationUnit compilationUnit = (CompilationUnit) iCompilationUnit;
+				return compilationUnit.originalFromClone();
 			}
-			return new DelegateSourceMethod(parent, new String(method.selector), parameterTypes, method);
+			return null;
 		}
 		
-		private DelegateSourceMethod(JavaElement parent, String name, String[] parameterTypes, MethodDeclaration md) {
-			super(parent, name, parameterTypes);
-			sourceMethodInfo = new DelegateSourceMethodInfo(this, md);
+		private static CompilationUnit getCompilationUnit(CompilationUnitDeclaration cud) {
+			return getCompilationUnit(cud.compilationResult.compilationUnit);
 		}
 		
-		@Override public Object getElementInfo() throws JavaModelException {
-			return sourceMethodInfo;
-		}
-		
-		/**
-		 * Disable refactoring for delegate methods
-		 */
-		@Override public boolean isReadOnly() {
-			return true;
-		}
-		
-		/**
-		 * This is required to prevent duplicate entries in the outline
-		 */
-		@Override public boolean equals(Object o) {
-			return this == o;
-		}
-		
-		public static final class DelegateSourceMethodInfo extends SourceMethodInfo {
-			DelegateSourceMethodInfo(DelegateSourceMethod delegateSourceMethod, MethodDeclaration md) {
-				int pS = md.sourceStart;
-				int pE = md.sourceEnd;
-				
-				Argument[] methodArguments = md.arguments != null ? md.arguments : new Argument[0];
-				char[][] argumentNames = new char[methodArguments.length][];
-				arguments = new ILocalVariable[methodArguments.length];
-				for (int i = 0; i < methodArguments.length; i++) {
-					Argument argument = methodArguments[i];
-					argumentNames[i] = argument.name;
-					arguments[i] = new LocalVariable(delegateSourceMethod, new String(argument.name), pS, pE, pS, pS, delegateSourceMethod.getParameterTypes()[i], argument.annotations, argument.modifiers, true);
+		private static final class DelegateSourceMethod extends SourceMethod {
+			private DelegateSourceMethodInfo sourceMethodInfo;
+	
+			private static DelegateSourceMethod forMethodDeclaration(JavaElement parent, MethodDeclaration method) {
+				Argument[] arguments = method.arguments != null ? method.arguments : new Argument[0];
+				String[] parameterTypes = new String[arguments.length];
+				for (int i = 0; i < arguments.length; i++) {
+					parameterTypes[i] = Signature.createTypeSignature(CharOperation.concatWith(arguments[i].type.getParameterizedTypeName(), '.'), false);
 				}
-				setArgumentNames(argumentNames);
-				
-				setSourceRangeStart(pS);
-				setSourceRangeEnd(pE);
-				setNameSourceStart(pS);
-				setNameSourceEnd(pE);
-				
-				setExceptionTypeNames(CharOperation.NO_CHAR_CHAR);
-				setReturnType(md.returnType == null ? new char[]{'v', 'o','i', 'd'} : CharOperation.concatWith(md.returnType.getParameterizedTypeName(), '.'));
-				setFlags(md.modifiers);
+				return new DelegateSourceMethod(parent, new String(method.selector), parameterTypes, method);
 			}
-		}
-	}
-	
-	private static List<SourceMethod> getDelegateMethods(SourceType sourceType) {
-		if (sourceType != null) {
-			CompilationUnit compilationUnit = getCompilationUnit(sourceType.getCompilationUnit());
-			if (compilationUnit != null) {
-				ConcurrentMap<String, List<SourceMethod>> map = EclipseAugments.CompilationUnit_delegateMethods.setIfAbsent(compilationUnit, new ConcurrentHashMap<String, List<SourceMethod>>());
-				List<SourceMethod> newList = new ArrayList<SourceMethod>();
-				List<SourceMethod> oldList = map.putIfAbsent(sourceType.getTypeQualifiedName(), newList);
-				return oldList != null ? oldList : newList;
+			
+			private DelegateSourceMethod(JavaElement parent, String name, String[] parameterTypes, MethodDeclaration md) {
+				super(parent, name, parameterTypes);
+				sourceMethodInfo = new DelegateSourceMethodInfo(this, md);
 			}
-		}
-		return null;
-	}
-	
-	private static SourceType getSourceType(CompilationUnitDeclaration cud, String typeName) {
-		CompilationUnit compilationUnit = getCompilationUnit(cud);
-		if (compilationUnit != null) {
-			try {
-				for (IType type : compilationUnit.getAllTypes()) {
-					if (type instanceof SourceType && type.getTypeQualifiedName().equals(typeName)) {
-						return (SourceType) type;
+			
+			@Override public Object getElementInfo() throws JavaModelException {
+				return sourceMethodInfo;
+			}
+			
+			/**
+			 * Disable refactoring for delegate methods
+			 */
+			@Override public boolean isReadOnly() {
+				return true;
+			}
+			
+			/**
+			 * This is required to prevent duplicate entries in the outline
+			 */
+			@Override public boolean equals(Object o) {
+				return this == o;
+			}
+			
+			public static final class DelegateSourceMethodInfo extends SourceMethodInfo {
+				DelegateSourceMethodInfo(DelegateSourceMethod delegateSourceMethod, MethodDeclaration md) {
+					int pS = md.sourceStart;
+					int pE = md.sourceEnd;
+					
+					Argument[] methodArguments = md.arguments != null ? md.arguments : new Argument[0];
+					char[][] argumentNames = new char[methodArguments.length][];
+					arguments = new ILocalVariable[methodArguments.length];
+					for (int i = 0; i < methodArguments.length; i++) {
+						Argument argument = methodArguments[i];
+						argumentNames[i] = argument.name;
+						arguments[i] = new LocalVariable(delegateSourceMethod, new String(argument.name), pS, pE, pS, pS, delegateSourceMethod.getParameterTypes()[i], argument.annotations, argument.modifiers, true);
 					}
+					setArgumentNames(argumentNames);
+					
+					setSourceRangeStart(pS);
+					setSourceRangeEnd(pE);
+					setNameSourceStart(pS);
+					setNameSourceEnd(pE);
+					
+					setExceptionTypeNames(CharOperation.NO_CHAR_CHAR);
+					setReturnType(md.returnType == null ? new char[]{'v', 'o','i', 'd'} : CharOperation.concatWith(md.returnType.getParameterizedTypeName(), '.'));
+					setFlags(md.modifiers);
 				}
-			} catch (JavaModelException e) {
-				// Ignore
 			}
 		}
-		return null;
+		
+		private static List<SourceMethod> getGeneratedMethods(SourceType sourceType) {
+			if (sourceType != null) {
+				CompilationUnit compilationUnit = getCompilationUnit(sourceType.getCompilationUnit());
+				if (compilationUnit != null) {
+					ConcurrentMap<String, List<SourceMethod>> map = EclipseAugments.CompilationUnit_delegateMethods.setIfAbsent(compilationUnit, new ConcurrentHashMap<String, List<SourceMethod>>());
+					List<SourceMethod> newList = new ArrayList<SourceMethod>();
+					List<SourceMethod> oldList = map.putIfAbsent(sourceType.getTypeQualifiedName(), newList);
+					return oldList != null ? oldList : newList;
+				}
+			}
+			return null;
+		}
+		
+		private static SourceType getSourceType(CompilationUnitDeclaration cud, String typeName) {
+			CompilationUnit compilationUnit = getCompilationUnit(cud);
+			if (compilationUnit != null) {
+				try {
+					for (IType type : compilationUnit.getAllTypes()) {
+						if (type instanceof SourceType && type.getTypeQualifiedName().equals(typeName)) {
+							return (SourceType) type;
+						}
+					}
+				} catch (JavaModelException e) {
+					// Ignore
+				}
+			}
+			return null;
+		}
 	}
 	
 	private static final class Reflection {

src/eclipseAgent/lombok/eclipse/agent/PatchDelegatePortal.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2020 The Project Lombok Authors.
+ * Copyright (C) 2012-2021 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -31,34 +31,44 @@ public class PatchDelegatePortal {
 	static final String SOURCE_TYPE_ELEMENT_INFO = "org.eclipse.jdt.internal.core.SourceTypeElementInfo";
 	
 	public static boolean handleDelegateForType(Object classScope) {
-		Boolean v = (Boolean) Permit.invokeSneaky(Reflection.problem, Reflection.handleDelegateForType, null, classScope);
+		Boolean v = (Boolean) Permit.invokeSneaky(Reflection.problemHandleDelegate, Reflection.handleDelegateForType, null, classScope);
 		if (v == null) return false;
 		return v.booleanValue();
 	}
 	
-	public static Object[] getChildren(Object returnValue, Object javaElement) {
-		return (Object[]) Permit.invokeSneaky(Reflection.problem, Reflection.getChildren, null, returnValue, javaElement);
+	public static Object[] addGeneratedDelegateMethods(Object returnValue, Object javaElement) {
+		return (Object[]) Permit.invokeSneaky(Reflection.problemAddGeneratedDelegateMethods, Reflection.addGeneratedDelegateMethods, null, returnValue, javaElement);
 	}
 	
 	private static final class Reflection {
 		public static final Method handleDelegateForType;
-		public static final Method getChildren;
-		public static final Throwable problem;
+		public static final Method addGeneratedDelegateMethods;
+		public static final Throwable problemHandleDelegate;
+		public static final Throwable problemAddGeneratedDelegateMethods;
 		
 		static {
 			Method m = null, n = null;
-			Throwable problem_ = null;
+			Throwable problemHandleDelegate_ = null;
+			Throwable problemAddGeneratedDelegateMethods_ = null;
 			try {
 				m = Permit.getMethod(PatchDelegate.class, "handleDelegateForType", Class.forName(CLASS_SCOPE));
-				n = Permit.getMethod(PatchDelegate.class, "getChildren", Class.forName(I_JAVA_ELEMENT_ARRAY), Class.forName(SOURCE_TYPE_ELEMENT_INFO));
 			} catch (Throwable t) {
 				// That's problematic, but as long as no local classes are used we don't actually need it.
 				// Better fail on local classes than crash altogether.
-				problem_ = t;
+				problemHandleDelegate_ = t;
 			}
 			handleDelegateForType = m;
-			getChildren = n;
-			problem = problem_;
+			problemHandleDelegate = problemHandleDelegate_;
+			
+			try {
+				n = Permit.getMethod(PatchDelegate.class, "addGeneratedDelegateMethods", Object[].class, Object.class);
+			} catch (Throwable t) {
+				// That's problematic, but as long as no local classes are used we don't actually need it.
+				// Better fail on local classes than crash altogether.
+				problemAddGeneratedDelegateMethods_ = t;
+			}
+			addGeneratedDelegateMethods = n;
+			problemAddGeneratedDelegateMethods = problemAddGeneratedDelegateMethods_;
 		}
 	}
 }

src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2020 The Project Lombok Authors.
+ * Copyright (C) 2012-2021 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -246,7 +246,7 @@ public class PatchExtensionMethod {
 		MessageSend_postponedErrors.set(messageSend, new PostponedNonStaticAccessToStaticMethodError(problemReporter, location, method));
 	}
 	
-	public static Object resolveType(Object resolvedType, MessageSend methodCall, BlockScope scope) {
+	public static TypeBinding resolveType(TypeBinding resolvedType, MessageSend methodCall, BlockScope scope) {
 		List<Extension> extensions = new ArrayList<Extension>();
 		TypeDeclaration decl = scope.classScope().referenceContext;
 		

src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodPortal.java

@@ -1,115 +0,0 @@
-package lombok.eclipse.agent;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import lombok.Lombok;
-
-public class PatchExtensionMethodPortal {
-	private static final String TYPE_BINDING = "org.eclipse.jdt.internal.compiler.lookup.TypeBinding";
-	private static final String TYPE_BINDING_ARRAY = "[Lorg.eclipse.jdt.internal.compiler.lookup.TypeBinding;";
-	private static final String MESSAGE_SEND = "org.eclipse.jdt.internal.compiler.ast.MessageSend";
-	private static final String BLOCK_SCOPE = "org.eclipse.jdt.internal.compiler.lookup.BlockScope";
-	private static final String METHOD_BINDING = "org.eclipse.jdt.internal.compiler.lookup.MethodBinding";
-	private static final String PROBLEM_REPORTER = "org.eclipse.jdt.internal.compiler.problem.ProblemReporter";
-
-	public static Object resolveType(Object resolvedType, Object methodCall, Object scope) {
-		try {
-			return Reflection.resolveType.invoke(null, resolvedType, methodCall, scope);
-		} catch (NoClassDefFoundError e) {
-			//ignore, we don't have access to the correct ECJ classes, so lombok can't possibly
-			//do anything useful here.
-			return resolvedType;
-		} catch (IllegalAccessException e) {
-			throw Lombok.sneakyThrow(e);
-		} catch (InvocationTargetException e) {
-			throw Lombok.sneakyThrow(e);
-		} catch (NullPointerException e) {
-			if (!"false".equals(System.getProperty("lombok.debug.reflection", "false"))) {
-				e.initCause(Reflection.problem);
-				throw e;
-			}
-			//ignore, we don't have access to the correct ECJ classes, so lombok can't possibly
-			//do anything useful here.
-			return resolvedType;
-		}
-	}
-
-	public static void errorNoMethodFor(Object problemReporter, Object messageSend, Object recType, Object params) {
-		try {
-			Reflection.errorNoMethodFor.invoke(null, problemReporter, messageSend, recType, params);
-		} catch (NoClassDefFoundError e) {
-			//ignore, we don't have access to the correct ECJ classes, so lombok can't possibly
-			//do anything useful here.
-		} catch (IllegalAccessException e) {
-			throw Lombok.sneakyThrow(e);
-		} catch (InvocationTargetException e) {
-			throw Lombok.sneakyThrow(e.getCause());
-		} catch (NullPointerException e) {
-			if (!"false".equals(System.getProperty("lombok.debug.reflection", "false"))) {
-				e.initCause(Reflection.problem);
-				throw e;
-			}
-			//ignore, we don't have access to the correct ECJ classes, so lombok can't possibly
-			//do anything useful here.
-		}
-	}
-	
-	public static void invalidMethod(Object problemReporter, Object messageSend, Object method) {
-		try {
-			Reflection.invalidMethod.invoke(null, problemReporter, messageSend, method);
-		} catch (NoClassDefFoundError e) {
-			//ignore, we don't have access to the correct ECJ classes, so lombok can't possibly
-			//do anything useful here.
-		} catch (IllegalAccessException e) {
-			handleReflectionDebug(e);
-			throw Lombok.sneakyThrow(e);
-		} catch (InvocationTargetException e) {
-			handleReflectionDebug(e.getCause());
-			throw Lombok.sneakyThrow(e.getCause());
-		} catch (NullPointerException e) {
-			handleReflectionDebug(e);
-			//ignore, we don't have access to the correct ECJ classes, so lombok can't possibly
-			//do anything useful here.
-		}
-	}
-	
-	public static boolean isDebugReflection() {
-		return !"false".equals(System.getProperty("lombok.debug.reflection", "false"));
-	}
-	
-	public static void handleReflectionDebug(Throwable t) {
-		if (!isDebugReflection()) return;
-		
-		System.err.println("** LOMBOK REFLECTION exception: " + t.getClass() + ": " + (t.getMessage() == null ? "(no message)" : t.getMessage()));
-		t.printStackTrace(System.err);
-		if (Reflection.problem != null) {
-			System.err.println("*** ADDITIONALLY, exception occurred setting up reflection: ");
-			Reflection.problem.printStackTrace(System.err);
-		}
-	}
-	
-	private static final class Reflection {
-		public static final Method resolveType, errorNoMethodFor, invalidMethod;
-		public static final Throwable problem;
-		
-		static {
-			Method m = null, n = null, o = null;
-			Throwable problem_ = null;
-			try {
-				m = PatchExtensionMethod.class.getMethod("resolveType", Object.class, Class.forName(MESSAGE_SEND), Class.forName(BLOCK_SCOPE));
-				n = PatchExtensionMethod.class.getMethod("errorNoMethodFor", Class.forName(PROBLEM_REPORTER),
-						Class.forName(MESSAGE_SEND), Class.forName(TYPE_BINDING), Class.forName(TYPE_BINDING_ARRAY));
-				o = PatchExtensionMethod.class.getMethod("invalidMethod", Class.forName(PROBLEM_REPORTER), Class.forName(MESSAGE_SEND), Class.forName(METHOD_BINDING));
-			} catch (Throwable t) {
-				// That's problematic, but as long as no local classes are used we don't actually need it.
-				// Better fail on local classes than crash altogether.
-				problem_ = t;
-			}
-			resolveType = m;
-			errorNoMethodFor = n;
-			invalidMethod = o;
-			problem = problem_;
-		}
-	}
-}

src/eclipseAgent/lombok/eclipse/agent/PatchVal.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2019 The Project Lombok Authors.
+ * Copyright (C) 2010-2021 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -68,32 +68,7 @@ public class PatchVal {
 	// This is half of the work for 'val' support - the other half is in PatchValEclipse. This half is enough for ecj.
 	// Creates a copy of the 'initialization' field on a LocalDeclaration if the type of the LocalDeclaration is 'val', because the completion parser will null this out,
 	// which in turn stops us from inferring the intended type for 'val x = 5;'. We look at the copy.
-	// Also patches local declaration to not call .resolveType() on the initializer expression if we've already done so (calling it twice causes weird errors),
-	// and patches .resolve() on LocalDeclaration itself to just-in-time replace the 'val' vartype with the right one.
-	
-	public static TypeBinding skipResolveInitializerIfAlreadyCalled(Expression expr, BlockScope scope) {
-		if (expr.resolvedType != null) return expr.resolvedType;
-		try {
-			return expr.resolveType(scope);
-		} catch (NullPointerException e) {
-			return null;
-		} catch (ArrayIndexOutOfBoundsException e) {
-			// This will occur internally due to for example 'val x = mth("X");', where mth takes 2 arguments.
-			return null;
-		}
-	}
-	
-	public static TypeBinding skipResolveInitializerIfAlreadyCalled2(Expression expr, BlockScope scope, LocalDeclaration decl) {
-		if (decl != null && LocalDeclaration.class.equals(decl.getClass()) && expr.resolvedType != null) return expr.resolvedType;
-		try {
-			return expr.resolveType(scope);
-		} catch (NullPointerException e) {
-			return null;
-		} catch (ArrayIndexOutOfBoundsException e) {
-			// This will occur internally due to for example 'val x = mth("X");', where mth takes 2 arguments.
-			return null;
-		}
-	}
+	// Also patches .resolve() on LocalDeclaration itself to just-in-time replace the 'val' vartype with the right one.
 	
 	public static boolean matches(String key, char[] array) {
 		if (array == null || key.length() != array.length) return false;

src/eclipseAgent/lombok/launch/PatchFixesHider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2019 The Project Lombok Authors.
+ * Copyright (C) 2010-2021 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -43,20 +43,14 @@ import org.eclipse.jdt.core.dom.MethodDeclaration;
 import org.eclipse.jdt.core.dom.SimpleName;
 import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.search.SearchMatch;
-import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.Expression;
 import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
-import org.eclipse.jdt.internal.compiler.ast.ForeachStatement;
 import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
-import org.eclipse.jdt.internal.compiler.ast.MessageSend;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
-import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
-import org.eclipse.jdt.internal.compiler.lookup.Scope;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
-import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
 import org.eclipse.jdt.internal.core.SourceField;
 import org.eclipse.jdt.internal.core.dom.rewrite.NodeRewriteEvent;
 import org.eclipse.jdt.internal.core.dom.rewrite.RewriteEvent;
@@ -116,6 +110,15 @@ final class PatchFixesHider {
 			}
 		}
 		
+		public static Method findMethod(Class<?> type, String name, String... parameterTypes) {
+			for (Method m : type.getDeclaredMethods()) {
+				if (name.equals(m.getName()) && sameTypes(m.getParameterTypes(), parameterTypes)) {
+					return m;
+				}
+			}
+			throw sneakyThrow(new NoSuchMethodException(type.getName() + "::" + name));
+		}
+		
 		public static Method findMethodAnyArgs(Class<?> type, String name) {
 			for (Method m : type.getDeclaredMethods()) if (name.equals(m.getName())) return m;
 			throw sneakyThrow(new NoSuchMethodException(type.getName() + "::" + name));
@@ -141,6 +144,14 @@ final class PatchFixesHider {
 		private static <T extends Throwable> void sneakyThrow0(Throwable t) throws T {
 			throw (T)t;
 		}
+		
+		private static boolean sameTypes(Class<?>[] types, String[] typeNames) {
+			if (types.length != typeNames.length) return false;
+			for (int i = 0; i < types.length; i++) {
+				if (!types[i].getName().equals(typeNames[i])) return false;
+			}
+			return true;
+		}
 	}
 	
 	/** Contains patch fixes that are dependent on lombok internals. */
@@ -193,7 +204,6 @@ final class PatchFixesHider {
 		}
 		
 		public static void transform(Object parser, Object ast) throws IOException {
-			Main.prependClassLoader(parser.getClass().getClassLoader());
 			init(parser.getClass().getClassLoader());
 			Util.invokeMethod(TRANSFORM, parser, ast);
 		}
@@ -207,20 +217,20 @@ final class PatchFixesHider {
 	/** Contains patch code to support {@code @Delegate} */
 	public static final class Delegate {
 		private static final Method HANDLE_DELEGATE_FOR_TYPE;
-		private static final Method GET_CHILDREN;
+		private static final Method ADD_GENERATED_DELEGATE_METHODS;
 		
 		static {
 			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchDelegatePortal");
 			HANDLE_DELEGATE_FOR_TYPE = Util.findMethod(shadowed, "handleDelegateForType", Object.class);
-			GET_CHILDREN = Util.findMethod(shadowed, "getChildren", Object.class, Object.class);
+			ADD_GENERATED_DELEGATE_METHODS = Util.findMethod(shadowed, "addGeneratedDelegateMethods", Object.class, Object.class);
 		}
 		
 		public static boolean handleDelegateForType(Object classScope) {
 			return (Boolean) Util.invokeMethod(HANDLE_DELEGATE_FOR_TYPE, classScope);
 		}
 		
-		public static Object[] getChildren(Object returnValue, Object javaElement) {
-			return (Object[]) Util.invokeMethod(GET_CHILDREN, returnValue, javaElement);
+		public static Object[] addGeneratedDelegateMethods(Object returnValue, Object javaElement) {
+			return (Object[]) Util.invokeMethod(ADD_GENERATED_DELEGATE_METHODS, returnValue, javaElement);
 		}
 	}
 	
@@ -258,38 +268,67 @@ final class PatchFixesHider {
 	
 	/** Contains patch code to support {@code val} (eclipse and ecj) */
 	public static final class Val {
-		private static final Method SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED;
-		private static final Method SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED2;
+		private static final String BLOCK_SCOPE_SIG = "org.eclipse.jdt.internal.compiler.lookup.BlockScope";
+		private static final String LOCAL_DECLARATION_SIG = "org.eclipse.jdt.internal.compiler.ast.LocalDeclaration";
+		private static final String FOREACH_STATEMENT_SIG = "org.eclipse.jdt.internal.compiler.ast.ForeachStatement";
+		
 		private static final Method HANDLE_VAL_FOR_LOCAL_DECLARATION;
 		private static final Method HANDLE_VAL_FOR_FOR_EACH;
 		
 		static {
 			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchVal");
-			SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED = Util.findMethod(shadowed, "skipResolveInitializerIfAlreadyCalled", Expression.class, BlockScope.class);
-			SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED2 = Util.findMethod(shadowed, "skipResolveInitializerIfAlreadyCalled2", Expression.class, BlockScope.class, LocalDeclaration.class);
-			HANDLE_VAL_FOR_LOCAL_DECLARATION = Util.findMethod(shadowed, "handleValForLocalDeclaration", LocalDeclaration.class, BlockScope.class);
-			HANDLE_VAL_FOR_FOR_EACH = Util.findMethod(shadowed, "handleValForForEach", ForeachStatement.class, BlockScope.class);
+			HANDLE_VAL_FOR_LOCAL_DECLARATION = Util.findMethod(shadowed, "handleValForLocalDeclaration", LOCAL_DECLARATION_SIG, BLOCK_SCOPE_SIG);
+			HANDLE_VAL_FOR_FOR_EACH = Util.findMethod(shadowed, "handleValForForEach", FOREACH_STATEMENT_SIG, BLOCK_SCOPE_SIG);
 		}
 		
-		public static TypeBinding skipResolveInitializerIfAlreadyCalled(Expression expr, BlockScope scope) {
-			return (TypeBinding) Util.invokeMethod(SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED, expr, scope);
-		}
-		
-		public static TypeBinding skipResolveInitializerIfAlreadyCalled2(Expression expr, BlockScope scope, LocalDeclaration decl) {
-			return (TypeBinding) Util.invokeMethod(SKIP_RESOLVE_INITIALIZER_IF_ALREADY_CALLED2, expr, scope, decl);
-		}
-		
-		public static boolean handleValForLocalDeclaration(LocalDeclaration local, BlockScope scope) {
+		public static boolean handleValForLocalDeclaration(Object local, Object scope) {
 			return (Boolean) Util.invokeMethod(HANDLE_VAL_FOR_LOCAL_DECLARATION, local, scope);
 		}
 		
-		public static boolean handleValForForEach(ForeachStatement forEach, BlockScope scope) {
+		public static boolean handleValForForEach(Object forEach, Object scope) {
 			return (Boolean) Util.invokeMethod(HANDLE_VAL_FOR_FOR_EACH, forEach, scope);
 		}
+		
+		/** 
+		 * Patches local declaration to not call .resolveType() on the initializer expression if we've already done so (calling it twice causes weird errors) 
+		 * This and the next method must be transplanted so that the return type is loaded in the correct class loader
+		 */
+		public static TypeBinding skipResolveInitializerIfAlreadyCalled(Expression expr, BlockScope scope) {
+			if (expr.resolvedType != null) return expr.resolvedType;
+			try {
+				return expr.resolveType(scope);
+			} catch (NullPointerException e) {
+				return null;
+			} catch (ArrayIndexOutOfBoundsException e) {
+				// This will occur internally due to for example 'val x = mth("X");', where mth takes 2 arguments.
+				return null;
+			}
+		}
+		
+		public static TypeBinding skipResolveInitializerIfAlreadyCalled2(Expression expr, BlockScope scope, LocalDeclaration decl) {
+			if (decl != null && LocalDeclaration.class.equals(decl.getClass()) && expr.resolvedType != null) return expr.resolvedType;
+			try {
+				return expr.resolveType(scope);
+			} catch (NullPointerException e) {
+				return null;
+			} catch (ArrayIndexOutOfBoundsException e) {
+				// This will occur internally due to for example 'val x = mth("X");', where mth takes 2 arguments.
+				return null;
+			}
+		}
 	}
 	
 	/** Contains patch code to support {@code @ExtensionMethod} */
 	public static final class ExtensionMethod {
+		private static final String MESSAGE_SEND_SIG = "org.eclipse.jdt.internal.compiler.ast.MessageSend";
+		private static final String TYPE_BINDING_SIG = "org.eclipse.jdt.internal.compiler.lookup.TypeBinding";
+		private static final String SCOPE_SIG = "org.eclipse.jdt.internal.compiler.lookup.Scope";
+		private static final String BLOCK_SCOPE_SIG = "org.eclipse.jdt.internal.compiler.lookup.BlockScope";
+		private static final String TYPE_BINDINGS_SIG = "[Lorg.eclipse.jdt.internal.compiler.lookup.TypeBinding;";
+		private static final String PROBLEM_REPORTER_SIG = "org.eclipse.jdt.internal.compiler.problem.ProblemReporter";
+		private static final String METHOD_BINDING_SIG = "org.eclipse.jdt.internal.compiler.lookup.MethodBinding";
+		private static final String AST_NODE_SIG = "org.eclipse.jdt.internal.compiler.ast.ASTNode";
+		
 		private static final Method RESOLVE_TYPE;
 		private static final Method ERROR_NO_METHOD_FOR;
 		private static final Method INVALID_METHOD, INVALID_METHOD2;
@@ -297,30 +336,30 @@ final class PatchFixesHider {
 		
 		static {
 			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchExtensionMethod");
-			RESOLVE_TYPE = Util.findMethod(shadowed, "resolveType", Object.class, MessageSend.class, BlockScope.class);
-			ERROR_NO_METHOD_FOR = Util.findMethod(shadowed, "errorNoMethodFor", ProblemReporter.class, MessageSend.class, TypeBinding.class, TypeBinding[].class);
-			INVALID_METHOD = Util.findMethod(shadowed, "invalidMethod", ProblemReporter.class, MessageSend.class, MethodBinding.class);
-			INVALID_METHOD2 = Util.findMethod(shadowed, "invalidMethod", ProblemReporter.class, MessageSend.class, MethodBinding.class, Scope.class);
-			NON_STATIC_ACCESS_TO_STATIC_METHOD = Util.findMethod(shadowed, "nonStaticAccessToStaticMethod", ProblemReporter.class, ASTNode.class, MethodBinding.class, MessageSend.class);
+			RESOLVE_TYPE = Util.findMethod(shadowed, "resolveType", TYPE_BINDING_SIG, MESSAGE_SEND_SIG, BLOCK_SCOPE_SIG);
+			ERROR_NO_METHOD_FOR = Util.findMethod(shadowed, "errorNoMethodFor", PROBLEM_REPORTER_SIG, MESSAGE_SEND_SIG, TYPE_BINDING_SIG, TYPE_BINDINGS_SIG);
+			INVALID_METHOD = Util.findMethod(shadowed, "invalidMethod", PROBLEM_REPORTER_SIG, MESSAGE_SEND_SIG, METHOD_BINDING_SIG);
+			INVALID_METHOD2 = Util.findMethod(shadowed, "invalidMethod", PROBLEM_REPORTER_SIG, MESSAGE_SEND_SIG, METHOD_BINDING_SIG, SCOPE_SIG);
+			NON_STATIC_ACCESS_TO_STATIC_METHOD = Util.findMethod(shadowed, "nonStaticAccessToStaticMethod", PROBLEM_REPORTER_SIG, AST_NODE_SIG, METHOD_BINDING_SIG, MESSAGE_SEND_SIG);
 		}
 		
-		public static Object resolveType(Object resolvedType, MessageSend methodCall, BlockScope scope) {
+		public static Object resolveType(Object resolvedType, Object methodCall, Object scope) {
 			return Util.invokeMethod(RESOLVE_TYPE, resolvedType, methodCall, scope);
 		}
 		
-		public static void errorNoMethodFor(ProblemReporter problemReporter, MessageSend messageSend, TypeBinding recType, TypeBinding[] params) {
+		public static void errorNoMethodFor(Object problemReporter, Object messageSend, Object recType, Object params) {
 			Util.invokeMethod(ERROR_NO_METHOD_FOR, problemReporter, messageSend, recType, params);
 		}
 		
-		public static void invalidMethod(ProblemReporter problemReporter, MessageSend messageSend, MethodBinding method) {
+		public static void invalidMethod(Object problemReporter, Object messageSend, Object method) {
 			Util.invokeMethod(INVALID_METHOD, problemReporter, messageSend, method);
 		}
 		
-		public static void invalidMethod(ProblemReporter problemReporter, MessageSend messageSend, MethodBinding method, Scope scope) {
+		public static void invalidMethod(Object problemReporter, Object messageSend, Object method, Object scope) {
 			Util.invokeMethod(INVALID_METHOD2, problemReporter, messageSend, method, scope);
 		}
 		
-		public static void nonStaticAccessToStaticMethod(ProblemReporter problemReporter, ASTNode location, MethodBinding method, MessageSend messageSend) {
+		public static void nonStaticAccessToStaticMethod(Object problemReporter, Object location, Object method, Object messageSend) {
 			Util.invokeMethod(NON_STATIC_ACCESS_TO_STATIC_METHOD, problemReporter, location, method, messageSend);
 		}
 	}

src/launch/lombok/launch/Main.java

@@ -36,7 +36,7 @@ class Main {
 	
 	static synchronized void prependClassLoader(ClassLoader loader) {
 		getShadowClassLoader();
-		classLoader.prepend(loader);
+		classLoader.prependParent(loader);
 	}
 	
 	public static void main(String[] args) throws Throwable {

src/launch/lombok/launch/ShadowClassLoader.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2018 The Project Lombok Authors.
+ * Copyright (C) 2014-2021 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -38,6 +38,7 @@ import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -102,14 +103,12 @@ class ShadowClassLoader extends ClassLoader {
 	private final List<String> parentExclusion = new ArrayList<String>();
 	private final List<String> highlanders = new ArrayList<String>();
 	
-	private final List<ClassLoader> prependedLoaders = new ArrayList<ClassLoader>();
+	private final Set<ClassLoader> prependedParentLoaders = Collections.newSetFromMap(new IdentityHashMap<ClassLoader, Boolean>());
 	
-	public void prepend(ClassLoader loader) {
+	public void prependParent(ClassLoader loader) {
 		if (loader == null) return;
-		for (ClassLoader cl : prependedLoaders) {
-			if (cl == loader) return;
-		}
-		prependedLoaders.add(loader);
+		if (loader == getParent()) return;
+		prependedParentLoaders.add(loader);
 	}
 	
 	/**
@@ -539,23 +538,25 @@ class ShadowClassLoader extends ClassLoader {
 		}
 		
 		String fileNameOfClass = name.replace(".", "/") + ".class";
-		for (ClassLoader pre : prependedLoaders) {
-			try {
-				URL res = pre.getResource(fileNameOfClass);
-				if (res == null) continue;
-				return urlToDefineClass(name, res, resolve);
-			} catch (Exception e) {
-				continue;
-			}
-		}
-		
 		URL res = getResource_(fileNameOfClass, true);
 		if (res == null) {
-			if (!exclusionListMatch(fileNameOfClass)) try {
-				return super.loadClass(name, resolve);
-			} catch (ClassNotFoundException cnfe) {
-				res = getResource_("secondaryLoading.SCL." + sclSuffix + "/" + name.replace(".", "/") + ".SCL." + sclSuffix, true);
-				if (res == null) throw cnfe;
+			if (!exclusionListMatch(fileNameOfClass)) {
+				try {
+					// First search in the prepended classloaders, the class might be their already
+					for (ClassLoader pre : prependedParentLoaders) {
+						try {
+							Class<?> loadClass = pre.loadClass(name);
+							if (loadClass != null) return loadClass;
+						} catch (Throwable e) {
+							continue;
+						}
+					}
+					
+					return super.loadClass(name, resolve);
+				} catch (ClassNotFoundException cnfe) {
+					res = getResource_("secondaryLoading.SCL." + sclSuffix + "/" + name.replace(".", "/") + ".SCL." + sclSuffix, true);
+					if (res == null) throw cnfe;
+				}
 			}
 		}
 		if (res == null) throw new ClassNotFoundException(name);