aboutsummaryrefslogtreecommitdiff
path: root/src/eclipseAgent/lombok
diff options
context:
space:
mode:
Diffstat (limited to 'src/eclipseAgent/lombok')
-rw-r--r--src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java27
-rw-r--r--src/eclipseAgent/lombok/eclipse/agent/PatchDelegate.java254
-rw-r--r--src/eclipseAgent/lombok/eclipse/agent/PatchDelegatePortal.java32
-rw-r--r--src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java4
-rw-r--r--src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodPortal.java115
-rw-r--r--src/eclipseAgent/lombok/eclipse/agent/PatchVal.java29
-rwxr-xr-xsrc/eclipseAgent/lombok/launch/PatchFixesHider.java111
7 files changed, 252 insertions, 320 deletions
diff --git a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
index 488d6eee..ce26c892 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
+++ b/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());
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchDelegate.java b/src/eclipseAgent/lombok/eclipse/agent/PatchDelegate.java
index 99367a22..d7b17598 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchDelegate.java
+++ b/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 {
- DeltaProcessor deltaProcessor = JavaModelManager.getJavaModelManager().getDeltaProcessor();
- deltaProcessor.fire(new JavaElementDelta(compilationUnit), ElementChangedEvent.POST_CHANGE);
- } catch (NoClassDefFoundError e) {
- javaModelManagerAvailable = false;
- }
- }
+ public static Object[] addGeneratedDelegateMethods(Object[] returnValue, Object javaElement) {
+ if (Symbols.hasSymbol("lombok.skipdelegates")) return returnValue;
+ if (!eclipseAvailable) return returnValue;
+
+ return EclipseOnlyMethods.addGeneratedDelegateMethodsToChildren(returnValue, javaElement);
}
- private static CompilationUnit getCompilationUnit(Object iCompilationUnit) {
- if (iCompilationUnit instanceof CompilationUnit) {
- CompilationUnit compilationUnit = (CompilationUnit) iCompilationUnit;
- return compilationUnit.originalFromClone();
+ public static class EclipseOnlyMethods {
+ private static void cleanupDelegateMethods(CompilationUnitDeclaration cud) {
+ CompilationUnit compilationUnit = getCompilationUnit(cud);
+ if (compilationUnit != null) {
+ EclipseAugments.CompilationUnit_delegateMethods.clear(compilationUnit);
+ }
}
- 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);
+ 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));
}
- return new DelegateSourceMethod(parent, new String(method.selector), parameterTypes, method);
}
- private DelegateSourceMethod(JavaElement parent, String name, String[] parameterTypes, MethodDeclaration md) {
- super(parent, name, parameterTypes);
- sourceMethodInfo = new DelegateSourceMethodInfo(this, 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;
}
- @Override public Object getElementInfo() throws JavaModelException {
- return sourceMethodInfo;
+ 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);
+ }
}
- /**
- * Disable refactoring for delegate methods
- */
- @Override public boolean isReadOnly() {
- return true;
+ private static CompilationUnit getCompilationUnit(Object iCompilationUnit) {
+ if (iCompilationUnit instanceof CompilationUnit) {
+ CompilationUnit compilationUnit = (CompilationUnit) iCompilationUnit;
+ return compilationUnit.originalFromClone();
+ }
+ return null;
}
- /**
- * This is required to prevent duplicate entries in the outline
- */
- @Override public boolean equals(Object o) {
- return this == o;
+ private static CompilationUnit getCompilationUnit(CompilationUnitDeclaration cud) {
+ return getCompilationUnit(cud.compilationResult.compilationUnit);
}
- 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);
+ }
+ return new DelegateSourceMethod(parent, new String(method.selector), parameterTypes, method);
+ }
+
+ private DelegateSourceMethod(JavaElement parent, String name, String[] parameterTypes, MethodDeclaration md) {
+ super(parent, name, parameterTypes);
+ sourceMethodInfo = new DelegateSourceMethodInfo(this, md);
+ }
+
+ @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);
}
- 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);
}
}
- }
-
- 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 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;
}
- 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;
+
+ 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
}
- } catch (JavaModelException e) {
- // Ignore
}
+ return null;
}
- return null;
}
private static final class Reflection {
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchDelegatePortal.java b/src/eclipseAgent/lombok/eclipse/agent/PatchDelegatePortal.java
index 3d8c86c9..01e4bb18 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchDelegatePortal.java
+++ b/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_;
}
}
}
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
index 5f229955..1f2f67ec 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
+++ b/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;
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodPortal.java b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodPortal.java
deleted file mode 100644
index 82df71f6..00000000
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodPortal.java
+++ /dev/null
@@ -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_;
- }
- }
-}
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchVal.java b/src/eclipseAgent/lombok/eclipse/agent/PatchVal.java
index f22e78a8..9663f364 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchVal.java
+++ b/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;
diff --git a/src/eclipseAgent/lombok/launch/PatchFixesHider.java b/src/eclipseAgent/lombok/launch/PatchFixesHider.java
index e2d266c5..02df3f5f 100755
--- a/src/eclipseAgent/lombok/launch/PatchFixesHider.java
+++ b/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 boolean handleValForLocalDeclaration(Object local, Object scope) {
+ return (Boolean) Util.invokeMethod(HANDLE_VAL_FOR_LOCAL_DECLARATION, local, 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 handleValForForEach(Object forEach, Object scope) {
+ return (Boolean) Util.invokeMethod(HANDLE_VAL_FOR_FOR_EACH, forEach, scope);
}
- public static boolean handleValForLocalDeclaration(LocalDeclaration local, BlockScope scope) {
- return (Boolean) Util.invokeMethod(HANDLE_VAL_FOR_LOCAL_DECLARATION, local, 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 boolean handleValForForEach(ForeachStatement forEach, BlockScope scope) {
- return (Boolean) Util.invokeMethod(HANDLE_VAL_FOR_FOR_EACH, forEach, scope);
+ 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);
}
}