mirror of
https://github.com/tiennm99/lombok.git
synced 2026-10-14 06:17:44 +00:00
'val' support for eclipse.
This commit is contained in:
Reinier Zwitserloot committed
1 parent
fcf39d88b4
commit
3b58e1a115
4 files changed
+327
-3
No files matched your search
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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 { ... })");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user