aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/core/lombok/eclipse/Eclipse.java140
-rw-r--r--src/core/lombok/eclipse/handlers/HandleVal.java53
-rw-r--r--src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java45
-rw-r--r--src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java92
4 files changed, 327 insertions, 3 deletions
diff --git a/src/core/lombok/eclipse/Eclipse.java b/src/core/lombok/eclipse/Eclipse.java
index c70660f4..ac8505af 100644
--- a/src/core/lombok/eclipse/Eclipse.java
+++ b/src/core/lombok/eclipse/Eclipse.java
@@ -25,6 +25,7 @@ import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
@@ -62,7 +63,13 @@ import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
+import org.eclipse.jdt.internal.compiler.lookup.CaptureBinding;
+import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
+import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
+import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
import org.osgi.framework.Bundle;
public class Eclipse {
@@ -156,7 +163,6 @@ public class Eclipse {
return result;
}
-
/**
* You can't share TypeParameter objects or bad things happen; for example, one 'T' resolves differently
* from another 'T', even for the same T in a single class file. Unfortunately the TypeParameter type hierarchy
@@ -292,6 +298,138 @@ public class Eclipse {
return ref;
}
+ private static long pos(ASTNode node) {
+ return ((long) node.sourceStart << 32) | (node.sourceEnd & 0xFFFFFFFFL);
+ }
+
+ public static long[] poss(ASTNode node, int repeat) {
+ long p = ((long) node.sourceStart << 32) | (node.sourceEnd & 0xFFFFFFFFL);
+ long[] out = new long[repeat];
+ Arrays.fill(out, p);
+ return out;
+ }
+
+ public static TypeReference makeType(TypeBinding binding, ASTNode pos, boolean allowCompound) {
+ // Primitives
+ switch (binding.id) {
+ case TypeIds.T_int:
+ return new SingleTypeReference(TypeConstants.INT, pos(pos));
+ case TypeIds.T_long:
+ return new SingleTypeReference(TypeConstants.LONG, pos(pos));
+ case TypeIds.T_short:
+ return new SingleTypeReference(TypeConstants.SHORT, pos(pos));
+ case TypeIds.T_byte:
+ return new SingleTypeReference(TypeConstants.BYTE, pos(pos));
+ case TypeIds.T_double:
+ return new SingleTypeReference(TypeConstants.DOUBLE, pos(pos));
+ case TypeIds.T_float:
+ return new SingleTypeReference(TypeConstants.FLOAT, pos(pos));
+ case TypeIds.T_boolean:
+ return new SingleTypeReference(TypeConstants.BOOLEAN, pos(pos));
+ case TypeIds.T_void:
+ return new SingleTypeReference(TypeConstants.VOID, pos(pos));
+ case TypeIds.T_char:
+ return new SingleTypeReference(TypeConstants.CHAR, pos(pos));
+ case TypeIds.T_null:
+ return null;
+ }
+
+ if (binding.isAnonymousType()) {
+ ReferenceBinding ref = (ReferenceBinding)binding;
+ ReferenceBinding[] supers = ref.superInterfaces();
+ if (supers == null || supers.length == 0) supers = new ReferenceBinding[] {ref.superclass()};
+ if (supers[0] == null) return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
+ return makeType(supers[0], pos, false);
+ }
+
+ if (binding instanceof CaptureBinding) {
+ return makeType(((CaptureBinding)binding).wildcard, pos, allowCompound);
+ }
+
+ if (binding.isUnboundWildcard()) {
+ if (!allowCompound) {
+ return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
+ } else {
+ Wildcard out = new Wildcard(Wildcard.UNBOUND);
+ out.sourceStart = pos.sourceStart;
+ out.sourceEnd = pos.sourceEnd;
+ return out;
+ }
+ }
+
+ if (binding.isWildcard()) {
+ WildcardBinding wildcard = (WildcardBinding) binding;
+ if (wildcard.boundKind == Wildcard.EXTENDS) {
+ if (!allowCompound) {
+ return makeType(wildcard.bound, pos, false);
+ } else {
+ Wildcard out = new Wildcard(Wildcard.EXTENDS);
+ out.bound = makeType(wildcard.bound, pos, false);
+ out.sourceStart = pos.sourceStart;
+ out.sourceEnd = pos.sourceEnd;
+ return out;
+ }
+ } else if (allowCompound && wildcard.boundKind == Wildcard.SUPER) {
+ Wildcard out = new Wildcard(Wildcard.SUPER);
+ out.bound = makeType(wildcard.bound, pos, false);
+ out.sourceStart = pos.sourceStart;
+ out.sourceEnd = pos.sourceEnd;
+ return out;
+ } else {
+ return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
+ }
+ }
+
+ char[][] parts;
+
+ if (binding.isLocalType() || binding.isTypeVariable()) {
+ parts = new char[][] { binding.shortReadableName() };
+ } else {
+ String[] pkg = new String(binding.qualifiedPackageName()).split("\\.");
+ String[] name = new String(binding.qualifiedSourceName()).split("\\.");
+ parts = new char[pkg.length + name.length][];
+ int ptr;
+ for (ptr = 0; ptr < pkg.length; ptr++) parts[ptr] = pkg[ptr].toCharArray();
+ for (; ptr < pkg.length + name.length; ptr++) parts[ptr] = name[ptr - pkg.length].toCharArray();
+ }
+
+ TypeReference[] params = new TypeReference[0];
+
+ if (binding instanceof ParameterizedTypeBinding) {
+ ParameterizedTypeBinding paramized = (ParameterizedTypeBinding) binding;
+ if (paramized.arguments != null) {
+ params = new TypeReference[paramized.arguments.length];
+ for (int i = 0; i < params.length; i++) {
+ params[i] = makeType(paramized.arguments[i], pos, true);
+ }
+ }
+ }
+
+ int dims = binding.dimensions();
+
+ if (params.length > 0) {
+ if (parts.length > 1) {
+ TypeReference[][] typeArguments = new TypeReference[parts.length][];
+ typeArguments[typeArguments.length - 1] = params;
+ return new ParameterizedQualifiedTypeReference(parts, typeArguments, dims, poss(pos, parts.length));
+ }
+ return new ParameterizedSingleTypeReference(parts[0], params, dims, pos(pos));
+ }
+
+ if (dims > 0) {
+ if (parts.length > 1) {
+ return new ArrayQualifiedTypeReference(parts, dims, poss(pos, parts.length));
+ }
+ return new ArrayTypeReference(parts[0], dims, pos(pos));
+ }
+
+ if (parts.length > 1) {
+ return new QualifiedTypeReference(parts, poss(pos, parts.length));
+ }
+ return new SingleTypeReference(parts[0], pos(pos));
+
+ }
+
public static Annotation[] copyAnnotations(Annotation[] annotations, ASTNode source) {
return copyAnnotations(annotations, null, source);
}
diff --git a/src/core/lombok/eclipse/handlers/HandleVal.java b/src/core/lombok/eclipse/handlers/HandleVal.java
new file mode 100644
index 00000000..6fa39b10
--- /dev/null
+++ b/src/core/lombok/eclipse/handlers/HandleVal.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2009-2010 Reinier Zwitserloot, Roel Spilker and Robbert Jan Grootjans.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package lombok.eclipse.handlers;
+
+import lombok.eclipse.EclipseASTAdapter;
+import lombok.eclipse.EclipseASTVisitor;
+import lombok.eclipse.EclipseNode;
+
+import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer;
+import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
+import org.mangosdk.spi.ProviderFor;
+
+/*
+ * This class just handles 2 basic error cases. The real meat of eclipse 'val' support is in {@code EclipsePatcher}'s {@code patchHandleVal} method.
+ */
+@ProviderFor(EclipseASTVisitor.class)
+public class HandleVal extends EclipseASTAdapter {
+ @Override public void visitLocal(EclipseNode localNode, LocalDeclaration local) {
+ if (local.type instanceof SingleTypeReference) {
+ char[] token = ((SingleTypeReference)local.type).token;
+ if (token == null || token.length != 3) return;
+ else if (token[0] != 'v' || token[1] != 'a' || token[2] != 'l') return;
+
+ if (local.initialization == null) {
+ localNode.addError("'val' on a local variable requires an initializer expression");
+ }
+
+ if (local.initialization instanceof ArrayInitializer) {
+ localNode.addError("'val' is not compatible with array initializer expressions. Use the full form (new int[] { ... } instead of just { ... })");
+ }
+ }
+ }
+}
diff --git a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
index 2ac24a48..e962ecbf 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
@@ -69,6 +69,8 @@ public class EclipsePatcher extends Agent {
patchPostCompileHookEcj(sm);
}
+ patchEcjTransformers(sm);
+
if (reloadExistingClasses) sm.reloadClasses(instrumentation);
}
@@ -253,4 +255,47 @@ public class EclipsePatcher extends Agent {
.wrapMethod(new Hook("lombok.eclipse.TransformEclipseAST", "transform_swapped", "void", CUD_SIG, PARSER_SIG))
.request(StackRequest.THIS, StackRequest.RETURN_VALUE).build());
}
+
+ private static void patchEcjTransformers(ScriptManager sm) {
+ patchHandleVal(sm);
+ }
+
+ // 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.
+
+ private static void patchHandleVal(ScriptManager sm) {
+ final String LOCALDECLARATION_SIG = "org.eclipse.jdt.internal.compiler.ast.LocalDeclaration";
+ final String EXPRESSION_SIG = "org.eclipse.jdt.internal.compiler.ast.Expression";
+ final String BLOCKSCOPE_SIG = "org.eclipse.jdt.internal.compiler.lookup.BlockScope";
+ final String PARSER_SIG = "org.eclipse.jdt.internal.compiler.parser.Parser";
+ final String TYPEBINDING_SIG = "org.eclipse.jdt.internal.compiler.lookup.TypeBinding";
+
+ sm.addScript(ScriptBuilder.exitEarly()
+ .target(new MethodTarget(LOCALDECLARATION_SIG, "resolve", "void", BLOCKSCOPE_SIG))
+ .request(StackRequest.THIS, StackRequest.PARAM1)
+ .decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "handleValForLocalDeclaration", "boolean", LOCALDECLARATION_SIG, BLOCKSCOPE_SIG))
+ .build());
+
+ sm.addScript(ScriptBuilder.addField()
+ .fieldName("$initCopy")
+ .fieldType("Lorg/eclipse/jdt/internal/compiler/ast/ASTNode;")
+ .setPublic()
+ .setTransient()
+ .targetClass("org.eclipse.jdt.internal.compiler.ast.LocalDeclaration")
+ .build());
+
+ sm.addScript(ScriptBuilder.wrapReturnValue()
+ .target(new MethodTarget(PARSER_SIG, "consumeExitVariableWithInitialization", "void"))
+ .request(StackRequest.THIS)
+ .wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "copyInitializationOfLocalDeclarationForVal", "void", PARSER_SIG))
+ .build());
+
+ sm.addScript(ScriptBuilder.replaceMethodCall()
+ .target(new MethodTarget(LOCALDECLARATION_SIG, "resolve", "void", BLOCKSCOPE_SIG))
+ .methodToReplace(new Hook(EXPRESSION_SIG, "resolveType", TYPEBINDING_SIG, BLOCKSCOPE_SIG))
+ .replacementMethod(new Hook("lombok.eclipse.agent.PatchFixes", "skipResolveInitializerIfAlreadyCalled", TYPEBINDING_SIG, EXPRESSION_SIG, BLOCKSCOPE_SIG))
+ .build());
+ }
}
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java b/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java
index daf1cbf2..eef6fd9a 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java
@@ -31,10 +31,22 @@ import java.util.List;
import lombok.core.DiagnosticsReceiver;
import lombok.core.PostCompiler;
+import lombok.eclipse.Eclipse;
import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.SimpleName;
+import org.eclipse.jdt.internal.compiler.ast.ASTNode;
+import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
+import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
+import org.eclipse.jdt.internal.compiler.ast.TypeReference;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
+import org.eclipse.jdt.internal.compiler.parser.Parser;
public class PatchFixes {
public static int fixRetrieveStartingCatchPosition(int in) {
@@ -78,7 +90,7 @@ public class PatchFixes {
boolean isGenerated = internalNode.getClass().getField("$generatedBy").get(internalNode) != null;
if (isGenerated) {
domNode.getClass().getField("$isGenerated").set(domNode, true);
- domNode.setFlags(domNode.getFlags() & ~ASTNode.ORIGINAL);
+ domNode.setFlags(domNode.getFlags() & ~org.eclipse.jdt.core.dom.ASTNode.ORIGINAL);
}
}
@@ -127,4 +139,80 @@ public class PatchFixes {
String fileName = path + "/" + name;
return new BufferedOutputStream(PostCompiler.wrapOutputStream(out, fileName, DiagnosticsReceiver.CONSOLE));
}
+
+ public static void copyInitializationOfLocalDeclarationForVal(Parser parser) {
+ ASTNode[] astStack;
+ int astPtr;
+ try {
+ Field astStackF = Parser.class.getDeclaredField("astStack");
+ astStackF.setAccessible(true);
+ astStack = (ASTNode[]) astStackF.get(parser);
+ Field astPtrF = Parser.class.getDeclaredField("astPtr");
+ astPtrF.setAccessible(true);
+ astPtr = (Integer)astPtrF.get(parser);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ AbstractVariableDeclaration variableDecl = (AbstractVariableDeclaration) astStack[astPtr];
+ if (!(variableDecl instanceof LocalDeclaration)) return;
+ ASTNode init = variableDecl.initialization;
+ if (init == null) return;
+ if (variableDecl.type instanceof SingleTypeReference) {
+ SingleTypeReference ref = (SingleTypeReference) variableDecl.type;
+ if (ref.token == null || ref.token.length != 3 || ref.token[0] != 'v' || ref.token[1] != 'a' || ref.token[2] != 'l') return;
+ } else return;
+
+ try {
+ LocalDeclaration.class.getDeclaredField("$initCopy").set(variableDecl, init);
+ } catch (Exception e) {
+ e.printStackTrace(System.out);
+ // In ecj mode this field isn't there and we don't need the copy anyway, so, we ignore the exception.
+ }
+ }
+
+ private static Field initCopyField;
+
+ static {
+ try {
+ initCopyField = LocalDeclaration.class.getDeclaredField("$initCopy");
+ } catch (Throwable t) {
+ //ignore - no $generatedBy exists when running in ecj.
+ }
+ }
+
+ public static boolean handleValForLocalDeclaration(LocalDeclaration local, BlockScope scope) {
+ if (local.type instanceof SingleTypeReference) {
+ char[] token = ((SingleTypeReference)local.type).token;
+ if (token == null || token.length != 3) return false;
+ else if (token[0] != 'v' || token[1] != 'a' || token[2] != 'l') return false;
+ } else return false;
+
+ Expression init = local.initialization;
+ if (init == null && initCopyField != null) {
+ try {
+ init = (Expression) initCopyField.get(local);
+ System.out.println("copy = " + init);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ TypeReference replacement = null;
+ if (init != null) {
+ TypeBinding resolved = init.resolveType(scope);
+ if (resolved != null) {
+ replacement = Eclipse.makeType(resolved, local.type, false);
+ }
+ }
+
+ local.modifiers |= ClassFileConstants.AccFinal;
+ local.type = replacement != null ? replacement : new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, Eclipse.poss(local.type, 3));
+
+ return false;
+ }
+
+ public static TypeBinding skipResolveInitializerIfAlreadyCalled(Expression expr, BlockScope scope) {
+ if (expr.resolvedType != null) return expr.resolvedType;
+ return expr.resolveType(scope);
+ }
}
generated by cgit (git 2.46.0) at 2024-11-27 18:06:59 +0000