diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/core/lombok/javac/JavacResolution.java | 27 | ||||
| -rw-r--r-- | src/core/lombok/javac/handlers/HandleCleanup.java | 5 | ||||
| -rw-r--r-- | src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java | 51 | ||||
| -rw-r--r-- | src/core/lombok/javac/handlers/HandleGetter.java | 9 | ||||
| -rw-r--r-- | src/core/lombok/javac/handlers/HandleSetter.java | 10 | ||||
| -rw-r--r-- | src/core/lombok/javac/handlers/HandleSynchronized.java | 3 | ||||
| -rw-r--r-- | src/core/lombok/javac/handlers/HandleToString.java | 13 | ||||
| -rw-r--r-- | src/core/lombok/javac/handlers/HandleWither.java | 3 | ||||
| -rw-r--r-- | src/core/lombok/javac/handlers/JavacHandlerUtil.java | 9 | ||||
| -rw-r--r-- | src/delombok/lombok/delombok/PrettyCommentsPrinter.java | 234 | ||||
| -rw-r--r-- | src/utils/lombok/javac/Javac.java | 237 |
11 files changed, 397 insertions, 204 deletions
diff --git a/src/core/lombok/javac/JavacResolution.java b/src/core/lombok/javac/JavacResolution.java index 0a21aa58..e5d8ed38 100644 --- a/src/core/lombok/javac/JavacResolution.java +++ b/src/core/lombok/javac/JavacResolution.java @@ -43,7 +43,6 @@ import com.sun.tools.javac.code.Type.ArrayType; import com.sun.tools.javac.code.Type.CapturedType; import com.sun.tools.javac.code.Type.ClassType; import com.sun.tools.javac.code.Type.WildcardType; -import com.sun.tools.javac.code.TypeTags; import com.sun.tools.javac.code.Types; import com.sun.tools.javac.comp.Attr; import com.sun.tools.javac.comp.AttrContext; @@ -419,8 +418,8 @@ public class JavacResolution { TreeMaker maker = ast.getTreeMaker(); - if (type.tag == CTC_BOT) return createJavaLangObject(ast); - if (type.tag == CTC_VOID) return allowVoid ? primitiveToJCTree(type.getKind(), maker) : createJavaLangObject(ast); + if (Javac.compareCTC(type.tag, CTC_BOT)) return createJavaLangObject(ast); + if (Javac.compareCTC(type.tag, CTC_VOID)) return allowVoid ? primitiveToJCTree(type.getKind(), maker) : createJavaLangObject(ast); if (type.isPrimitive()) return primitiveToJCTree(type.getKind(), maker); if (type.isErroneous()) throw new TypeNotConvertibleException("Type cannot be resolved"); @@ -454,7 +453,7 @@ public class JavacResolution { upper = type.getUpperBound(); } if (allowCompound) { - if (lower == null || lower.tag == CTC_BOT) { + if (lower == null || Javac.compareCTC(lower.tag, CTC_BOT)) { if (upper == null || upper.toString().equals("java.lang.Object")) { return maker.Wildcard(maker.TypeBoundKind(BoundKind.UNBOUND), null); } @@ -479,7 +478,7 @@ public class JavacResolution { String qName; if (symbol.isLocal()) { qName = symbol.getSimpleName().toString(); - } else if (symbol.type != null && symbol.type.getEnclosingType() != null && symbol.type.getEnclosingType().tag == TypeTags.CLASS) { + } else if (symbol.type != null && symbol.type.getEnclosingType() != null && Javac.compareCTC(symbol.type.getEnclosingType().tag, Javac.getTypeTag("CLASS"))) { replacement = typeToJCTree0(type.getEnclosingType(), ast, false, false); qName = symbol.getSimpleName().toString(); } else { @@ -515,23 +514,23 @@ public class JavacResolution { private static JCExpression primitiveToJCTree(TypeKind kind, TreeMaker maker) throws TypeNotConvertibleException { switch (kind) { case BYTE: - return maker.TypeIdent(CTC_BYTE); + return Javac.makeTypeIdent(maker, CTC_BYTE); case CHAR: - return maker.TypeIdent(CTC_CHAR); + return Javac.makeTypeIdent(maker, CTC_CHAR); case SHORT: - return maker.TypeIdent(CTC_SHORT); + return Javac.makeTypeIdent(maker, CTC_SHORT); case INT: - return maker.TypeIdent(CTC_INT); + return Javac.makeTypeIdent(maker, CTC_INT); case LONG: - return maker.TypeIdent(CTC_LONG); + return Javac.makeTypeIdent(maker, CTC_LONG); case FLOAT: - return maker.TypeIdent(CTC_FLOAT); + return Javac.makeTypeIdent(maker, CTC_FLOAT); case DOUBLE: - return maker.TypeIdent(CTC_DOUBLE); + return Javac.makeTypeIdent(maker, CTC_DOUBLE); case BOOLEAN: - return maker.TypeIdent(CTC_BOOLEAN); + return Javac.makeTypeIdent(maker, CTC_BOOLEAN); case VOID: - return maker.TypeIdent(CTC_VOID); + return Javac.makeTypeIdent(maker, CTC_VOID); case NULL: case NONE: case OTHER: diff --git a/src/core/lombok/javac/handlers/HandleCleanup.java b/src/core/lombok/javac/handlers/HandleCleanup.java index 09b4faee..c75256a5 100644 --- a/src/core/lombok/javac/handlers/HandleCleanup.java +++ b/src/core/lombok/javac/handlers/HandleCleanup.java @@ -26,6 +26,7 @@ import static lombok.javac.Javac.*; import lombok.Cleanup; import lombok.core.AST.Kind; import lombok.core.AnnotationValues; +import lombok.javac.Javac; import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; @@ -120,7 +121,7 @@ public class HandleCleanup extends JavacAnnotationHandler<Cleanup> { maker.Apply(List.<JCExpression>nil(), cleanupMethod, List.<JCExpression>nil()))); JCMethodInvocation preventNullAnalysis = preventNullAnalysis(maker, annotationNode, maker.Ident(decl.name)); - JCBinary isNull = maker.Binary(CTC_NOT_EQUAL, preventNullAnalysis, maker.Literal(CTC_BOT, null)); + JCBinary isNull = Javac.makeBinary(maker, CTC_NOT_EQUAL, preventNullAnalysis, Javac.makeLiteral(maker, CTC_BOT, null)); JCIf ifNotNullCleanup = maker.If(isNull, maker.Block(0, cleanupCall), null); @@ -141,7 +142,7 @@ public class HandleCleanup extends JavacAnnotationHandler<Cleanup> { private JCMethodInvocation preventNullAnalysis(TreeMaker maker, JavacNode node, JCExpression expression) { JCMethodInvocation singletonList = maker.Apply(List.<JCExpression>nil(), chainDotsString(node, "java.util.Collections.singletonList"), List.of(expression)); - JCMethodInvocation cleanedExpr = maker.Apply(List.<JCExpression>nil(), maker.Select(singletonList, node.toName("get")) , List.<JCExpression>of(maker.Literal(TypeTags.INT, 0))); + JCMethodInvocation cleanedExpr = maker.Apply(List.<JCExpression>nil(), maker.Select(singletonList, node.toName("get")) , List.<JCExpression>of(Javac.makeLiteral(maker, CTC_INT, 0))); return cleanedExpr; } diff --git a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java index 5f69be9d..39edb143 100644 --- a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java +++ b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java @@ -30,6 +30,7 @@ import java.util.Collections; import lombok.EqualsAndHashCode; import lombok.core.AST.Kind; import lombok.core.AnnotationValues; +import lombok.javac.Javac; import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; import lombok.javac.handlers.JavacHandlerUtil.FieldAccess; @@ -39,7 +40,6 @@ import org.mangosdk.spi.ProviderFor; import com.sun.tools.javac.code.BoundKind; import com.sun.tools.javac.code.Flags; -import com.sun.tools.javac.code.TypeTags; import com.sun.tools.javac.tree.JCTree; import com.sun.tools.javac.tree.JCTree.JCAnnotation; import com.sun.tools.javac.tree.JCTree.JCArrayTypeTree; @@ -213,7 +213,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas JCAnnotation overrideAnnotation = maker.Annotation(chainDots(typeNode, "java", "lang", "Override"), List.<JCExpression>nil()); JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation)); - JCExpression returnType = maker.TypeIdent(CTC_INT); + JCExpression returnType = Javac.makeTypeIdent(maker, CTC_INT); ListBuffer<JCStatement> statements = ListBuffer.lb(); Name primeName = typeNode.toName(PRIME_NAME); @@ -221,12 +221,12 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas /* final int PRIME = 31; */ { if (!fields.isEmpty() || callSuper) { statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), - primeName, maker.TypeIdent(CTC_INT), maker.Literal(31))); + primeName, Javac.makeTypeIdent(maker, CTC_INT), maker.Literal(31))); } } /* int result = 1; */ { - statements.append(maker.VarDef(maker.Modifiers(0), resultName, maker.TypeIdent(CTC_INT), maker.Literal(1))); + statements.append(maker.VarDef(maker.Modifiers(0), resultName, Javac.makeTypeIdent(maker, CTC_INT), maker.Literal(1))); } if (callSuper) { @@ -248,7 +248,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas break; case LONG: { Name dollarFieldName = dollar.append(((JCVariableDecl)fieldNode.get()).name); - statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), dollarFieldName, maker.TypeIdent(TypeTags.LONG), fieldAccessor)); + statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), dollarFieldName, Javac.makeTypeIdent(maker, CTC_LONG), fieldAccessor)); statements.append(createResultCalculation(typeNode, longToIntForHashCode(maker, maker.Ident(dollarFieldName), maker.Ident(dollarFieldName)))); } break; @@ -266,7 +266,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas List.<JCExpression>nil(), chainDots(typeNode, "java", "lang", "Double", "doubleToLongBits"), List.of(fieldAccessor)); - statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), dollarFieldName, maker.TypeIdent(TypeTags.LONG), init)); + statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), dollarFieldName, Javac.makeTypeIdent(maker, CTC_LONG), init)); statements.append(createResultCalculation(typeNode, longToIntForHashCode(maker, maker.Ident(dollarFieldName), maker.Ident(dollarFieldName)))); } break; @@ -296,7 +296,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas JCExpression hcCall = maker.Apply(List.<JCExpression>nil(), maker.Select(maker.Ident(dollarFieldName), typeNode.toName("hashCode")), List.<JCExpression>nil()); - JCExpression thisEqualsNull = maker.Binary(CTC_EQUAL, maker.Ident(dollarFieldName), maker.Literal(CTC_BOT, null)); + JCExpression thisEqualsNull = Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(dollarFieldName), Javac.makeLiteral(maker, CTC_BOT, null)); statements.append(createResultCalculation(typeNode, maker.Conditional(thisEqualsNull, maker.Literal(0), hcCall))); } } @@ -314,17 +314,17 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas /* result = result * PRIME + (expr); */ TreeMaker maker = typeNode.getTreeMaker(); Name resultName = typeNode.toName(RESULT_NAME); - JCExpression mult = maker.Binary(CTC_MUL, maker.Ident(resultName), maker.Ident(typeNode.toName(PRIME_NAME))); - JCExpression add = maker.Binary(CTC_PLUS, mult, expr); + JCExpression mult = Javac.makeBinary(maker, CTC_MUL, maker.Ident(resultName), maker.Ident(typeNode.toName(PRIME_NAME))); + JCExpression add = Javac.makeBinary(maker, CTC_PLUS, mult, expr); return maker.Exec(maker.Assign(maker.Ident(resultName), add)); } /** The 2 references must be clones of each other. */ private JCExpression longToIntForHashCode(TreeMaker maker, JCExpression ref1, JCExpression ref2) { /* (int)(ref >>> 32 ^ ref) */ - JCExpression shift = maker.Binary(CTC_UNSIGNED_SHIFT_RIGHT, ref1, maker.Literal(32)); - JCExpression xorBits = maker.Binary(CTC_BITXOR, shift, ref2); - return maker.TypeCast(maker.TypeIdent(CTC_INT), xorBits); + JCExpression shift = Javac.makeBinary(maker, CTC_UNSIGNED_SHIFT_RIGHT, ref1, maker.Literal(32)); + JCExpression xorBits = Javac.makeBinary(maker, CTC_BITXOR, shift, ref2); + return maker.TypeCast(Javac.makeTypeIdent(maker, CTC_INT), xorBits); } private JCExpression createTypeReference(JavacNode type) { @@ -358,18 +358,19 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas JCAnnotation overrideAnnotation = maker.Annotation(chainDots(typeNode, "java", "lang", "Override"), List.<JCExpression>nil()); JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation)); JCExpression objectType = chainDots(typeNode, "java", "lang", "Object"); - JCExpression returnType = maker.TypeIdent(CTC_BOOLEAN); + JCExpression returnType = Javac.makeTypeIdent(maker, CTC_BOOLEAN); ListBuffer<JCStatement> statements = ListBuffer.lb(); final List<JCVariableDecl> params = List.of(maker.VarDef(maker.Modifiers(Flags.FINAL), oName, objectType, null)); /* if (o == this) return true; */ { - statements.append(maker.If(maker.Binary(CTC_EQUAL, maker.Ident(oName), + statements.append(maker.If(Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(oName), maker.Ident(thisName)), returnBool(maker, true), null)); } /* if (!(o instanceof Outer.Inner.MyType) return false; */ { - JCUnary notInstanceOf = maker.Unary(CTC_NOT, maker.TypeTest(maker.Ident(oName), createTypeReference(typeNode))); + + JCUnary notInstanceOf = Javac.makeUnary(maker, CTC_NOT, maker.TypeTest(maker.Ident(oName), createTypeReference(typeNode))); statements.append(maker.If(notInstanceOf, returnBool(maker, false), null)); } @@ -404,7 +405,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas JCExpression equalityCheck = maker.Apply(exprNil, maker.Select(maker.Ident(otherName), typeNode.toName("canEqual")), List.of(castThisRef)); - statements.append(maker.If(maker.Unary(CTC_NOT, equalityCheck), returnBool(maker, false), null)); + statements.append(maker.If(Javac.makeUnary(maker, CTC_NOT, equalityCheck), returnBool(maker, false), null)); } } @@ -413,7 +414,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas JCMethodInvocation callToSuper = maker.Apply(List.<JCExpression>nil(), maker.Select(maker.Ident(typeNode.toName("super")), typeNode.toName("equals")), List.<JCExpression>of(maker.Ident(oName))); - JCUnary superNotEqual = maker.Unary(CTC_NOT, callToSuper); + JCUnary superNotEqual = Javac.makeUnary(maker, CTC_NOT, callToSuper); statements.append(maker.If(superNotEqual, returnBool(maker, false), null)); } @@ -436,7 +437,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas default: /* if (this.fieldName != other.fieldName) return false; */ statements.append( - maker.If(maker.Binary(CTC_NOT_EQUAL, thisFieldAccessor, otherFieldAccessor), returnBool(maker, false), null)); + maker.If(Javac.makeBinary(maker, CTC_NOT_EQUAL, thisFieldAccessor, otherFieldAccessor), returnBool(maker, false), null)); break; } } else if (fType instanceof JCArrayTypeTree) { @@ -447,7 +448,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas JCExpression eqMethod = chainDots(typeNode, "java", "util", "Arrays", useDeepEquals ? "deepEquals" : "equals"); List<JCExpression> args = List.of(thisFieldAccessor, otherFieldAccessor); - statements.append(maker.If(maker.Unary(CTC_NOT, + statements.append(maker.If(Javac.makeUnary(maker, CTC_NOT, maker.Apply(List.<JCExpression>nil(), eqMethod, args)), returnBool(maker, false), null)); } else /* objects */ { /* final java.lang.Object this$fieldName = this.fieldName; */ @@ -460,12 +461,12 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), thisDollarFieldName, chainDots(typeNode, "java", "lang", "Object"), thisFieldAccessor)); statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), otherDollarFieldName, chainDots(typeNode, "java", "lang", "Object"), otherFieldAccessor)); - JCExpression thisEqualsNull = maker.Binary(CTC_EQUAL, maker.Ident(thisDollarFieldName), maker.Literal(CTC_BOT, null)); - JCExpression otherNotEqualsNull = maker.Binary(CTC_NOT_EQUAL, maker.Ident(otherDollarFieldName), maker.Literal(CTC_BOT, null)); + JCExpression thisEqualsNull = Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(thisDollarFieldName), Javac.makeLiteral(maker, CTC_BOT, null)); + JCExpression otherNotEqualsNull = Javac.makeBinary(maker, CTC_NOT_EQUAL, maker.Ident(otherDollarFieldName), Javac.makeLiteral(maker, CTC_BOT, null)); JCExpression thisEqualsThat = maker.Apply(List.<JCExpression>nil(), maker.Select(maker.Ident(thisDollarFieldName), typeNode.toName("equals")), List.<JCExpression>of(maker.Ident(otherDollarFieldName))); - JCExpression fieldsAreNotEqual = maker.Conditional(thisEqualsNull, otherNotEqualsNull, maker.Unary(CTC_NOT, thisEqualsThat)); + JCExpression fieldsAreNotEqual = maker.Conditional(thisEqualsNull, otherNotEqualsNull, Javac.makeUnary(maker, CTC_NOT, thisEqualsThat)); statements.append(maker.If(fieldsAreNotEqual, returnBool(maker, false), null)); } } @@ -486,7 +487,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas TreeMaker maker = typeNode.getTreeMaker(); JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.<JCAnnotation>nil()); - JCExpression returnType = maker.TypeIdent(CTC_BOOLEAN); + JCExpression returnType = Javac.makeTypeIdent(maker, CTC_BOOLEAN); Name canEqualName = typeNode.toName("canEqual"); JCExpression objectType = chainDots(typeNode, "java", "lang", "Object"); Name otherName = typeNode.toName("other"); @@ -503,12 +504,12 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas /* if (Float.compare(fieldName, other.fieldName) != 0) return false; */ JCExpression clazz = chainDots(node, "java", "lang", isDouble ? "Double" : "Float"); List<JCExpression> args = List.of(thisDotField, otherDotField); - JCBinary compareCallEquals0 = maker.Binary(CTC_NOT_EQUAL, maker.Apply( + JCBinary compareCallEquals0 = Javac.makeBinary(maker, CTC_NOT_EQUAL, maker.Apply( List.<JCExpression>nil(), maker.Select(clazz, node.toName("compare")), args), maker.Literal(0)); return maker.If(compareCallEquals0, returnBool(maker, false), null); } private JCStatement returnBool(TreeMaker maker, boolean bool) { - return maker.Return(maker.Literal(CTC_BOOLEAN, bool ? 1 : 0)); + return maker.Return(Javac.makeLiteral(maker, CTC_BOOLEAN, bool ? 1 : 0)); } } diff --git a/src/core/lombok/javac/handlers/HandleGetter.java b/src/core/lombok/javac/handlers/HandleGetter.java index bc68d5ad..2fa2a755 100644 --- a/src/core/lombok/javac/handlers/HandleGetter.java +++ b/src/core/lombok/javac/handlers/HandleGetter.java @@ -35,6 +35,7 @@ import lombok.Getter; import lombok.core.AST.Kind; import lombok.core.AnnotationValues; import lombok.core.TransformationsUtil; +import lombok.javac.Javac; import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; import lombok.javac.handlers.JavacHandlerUtil.FieldAccess; @@ -288,9 +289,9 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> { private static final String AR = "java.util.concurrent.atomic.AtomicReference"; private static final List<JCExpression> NIL_EXPRESSION = List.nil(); - private static final java.util.Map<Integer, String> TYPE_MAP; + private static final java.util.Map<Object, String> TYPE_MAP; static { - Map<Integer, String> m = new HashMap<Integer, String>(); + Map<Object, String> m = new HashMap<Object, String>(); m.put(CTC_INT, "java.lang.Integer"); m.put(CTC_DOUBLE, "java.lang.Double"); m.put(CTC_FLOAT, "java.lang.Float"); @@ -364,7 +365,7 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> { innerIfStatements.append(statement); } - JCBinary isNull = maker.Binary(CTC_EQUAL, maker.Ident(valueName), maker.Literal(CTC_BOT, null)); + JCBinary isNull = Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(valueName), Javac.makeLiteral(maker, CTC_BOT, null)); JCIf ifStatement = maker.If(isNull, maker.Block(0, innerIfStatements.toList()), null); synchronizedStatements.append(ifStatement); } @@ -372,7 +373,7 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> { synchronizedStatement = maker.Synchronized(createFieldAccessor(maker, fieldNode, FieldAccess.ALWAYS_FIELD), maker.Block(0, synchronizedStatements.toList())); } - JCBinary isNull = maker.Binary(CTC_EQUAL, maker.Ident(valueName), maker.Literal(CTC_BOT, null)); + JCBinary isNull = Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(valueName), Javac.makeLiteral(maker, CTC_BOT, null)); JCIf ifStatement = maker.If(isNull, maker.Block(0, List.<JCStatement>of(synchronizedStatement)), null); statements.append(ifStatement); } diff --git a/src/core/lombok/javac/handlers/HandleSetter.java b/src/core/lombok/javac/handlers/HandleSetter.java index c1e03c35..2136024e 100644 --- a/src/core/lombok/javac/handlers/HandleSetter.java +++ b/src/core/lombok/javac/handlers/HandleSetter.java @@ -35,6 +35,7 @@ import lombok.Setter; import lombok.core.AST.Kind; import lombok.core.AnnotationValues; import lombok.core.TransformationsUtil; +import lombok.javac.Javac; import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; import lombok.javac.handlers.JavacHandlerUtil.FieldAccess; @@ -253,14 +254,15 @@ public class HandleSetter extends JavacAnnotationHandler<Setter> { } private static class JCNoType extends Type implements NoType { - public JCNoType(int tag) { - super(tag, null); + public JCNoType(Object tag) { + //FIX + super(1, null); } @Override public TypeKind getKind() { - if (tag == CTC_VOID) return TypeKind.VOID; - if (tag == CTC_NONE) return TypeKind.NONE; + if (Javac.compareCTC(tag, CTC_VOID)) return TypeKind.VOID; + if (Javac.compareCTC(tag, CTC_NONE)) return TypeKind.NONE; throw new AssertionError("Unexpected tag: " + tag); } diff --git a/src/core/lombok/javac/handlers/HandleSynchronized.java b/src/core/lombok/javac/handlers/HandleSynchronized.java index 2bca49e9..2737eeb2 100644 --- a/src/core/lombok/javac/handlers/HandleSynchronized.java +++ b/src/core/lombok/javac/handlers/HandleSynchronized.java @@ -26,6 +26,7 @@ import static lombok.javac.handlers.JavacHandlerUtil.*; import lombok.Synchronized; import lombok.core.AST.Kind; import lombok.core.AnnotationValues; +import lombok.javac.Javac; import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; import lombok.javac.handlers.JavacHandlerUtil.MemberExistsResult; @@ -87,7 +88,7 @@ public class HandleSynchronized extends JavacAnnotationHandler<Synchronized> { JCExpression objectType = chainDots(methodNode, ast.pos, "java", "lang", "Object"); //We use 'new Object[0];' because unlike 'new Object();', empty arrays *ARE* serializable! JCNewArray newObjectArray = maker.NewArray(chainDots(methodNode, ast.pos, "java", "lang", "Object"), - List.<JCExpression>of(maker.Literal(CTC_INT, 0)), null); + List.<JCExpression>of(Javac.makeLiteral(maker, CTC_INT, 0)), null); JCVariableDecl fieldDecl = recursiveSetGeneratedBy(maker.VarDef( maker.Modifiers(Flags.PRIVATE | Flags.FINAL | (isStatic ? Flags.STATIC : 0)), methodNode.toName(lockName), objectType, newObjectArray), ast); diff --git a/src/core/lombok/javac/handlers/HandleToString.java b/src/core/lombok/javac/handlers/HandleToString.java index 520acf62..c37fe149 100644 --- a/src/core/lombok/javac/handlers/HandleToString.java +++ b/src/core/lombok/javac/handlers/HandleToString.java @@ -27,6 +27,7 @@ import static lombok.javac.Javac.*; import lombok.ToString; import lombok.core.AnnotationValues; import lombok.core.AST.Kind; +import lombok.javac.Javac; import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; @@ -193,7 +194,7 @@ public class HandleToString extends JavacAnnotationHandler<ToString> { JCMethodInvocation callToSuper = maker.Apply(List.<JCExpression>nil(), maker.Select(maker.Ident(typeNode.toName("super")), typeNode.toName("toString")), List.<JCExpression>nil()); - current = maker.Binary(CTC_PLUS, current, callToSuper); + current = Javac.makeBinary(maker, CTC_PLUS, current, callToSuper); first = false; } @@ -213,21 +214,21 @@ public class HandleToString extends JavacAnnotationHandler<ToString> { } else expr = fieldAccessor; if (first) { - current = maker.Binary(CTC_PLUS, current, expr); + current = Javac.makeBinary(maker, CTC_PLUS, current, expr); first = false; continue; } if (includeFieldNames) { - current = maker.Binary(CTC_PLUS, current, maker.Literal(infix + fieldNode.getName() + "=")); + current = Javac.makeBinary(maker, CTC_PLUS, current, maker.Literal(infix + fieldNode.getName() + "=")); } else { - current = maker.Binary(CTC_PLUS, current, maker.Literal(infix)); + current = Javac.makeBinary(maker, CTC_PLUS, current, maker.Literal(infix)); } - current = maker.Binary(CTC_PLUS, current, expr); + current = Javac.makeBinary(maker, CTC_PLUS, current, expr); } - if (!first) current = maker.Binary(CTC_PLUS, current, maker.Literal(suffix)); + if (!first) current = Javac.makeBinary(maker, CTC_PLUS, current, maker.Literal(suffix)); JCStatement returnStatement = maker.Return(current); diff --git a/src/core/lombok/javac/handlers/HandleWither.java b/src/core/lombok/javac/handlers/HandleWither.java index ba5aa72d..62ed63f1 100644 --- a/src/core/lombok/javac/handlers/HandleWither.java +++ b/src/core/lombok/javac/handlers/HandleWither.java @@ -31,6 +31,7 @@ import lombok.core.AST.Kind; import lombok.core.AnnotationValues; import lombok.core.TransformationsUtil; import lombok.experimental.Wither; +import lombok.javac.Javac; import lombok.javac.JavacAnnotationHandler; import lombok.javac.JavacNode; import lombok.javac.handlers.JavacHandlerUtil.FieldAccess; @@ -239,7 +240,7 @@ public class HandleWither extends JavacAnnotationHandler<Wither> { } JCNewClass newClass = maker.NewClass(null, List.<JCExpression>nil(), selfType, args.toList(), null); - JCExpression identityCheck = maker.Binary(CTC_EQUAL, createFieldAccessor(maker, field, FieldAccess.ALWAYS_FIELD), maker.Ident(fieldDecl.name)); + JCExpression identityCheck = Javac.makeBinary(maker, CTC_EQUAL, createFieldAccessor(maker, field, FieldAccess.ALWAYS_FIELD), maker.Ident(fieldDecl.name)); JCConditional conditional = maker.Conditional(identityCheck, maker.Ident(field.toName("this")), newClass); JCReturn returnStatement = maker.Return(conditional); diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java index c2de5b05..178b82a2 100644 --- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java +++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java @@ -42,6 +42,7 @@ import lombok.core.AnnotationValues.AnnotationValue; import lombok.core.TransformationsUtil; import lombok.core.TypeResolver; import lombok.experimental.Accessors; +import lombok.javac.Javac; import lombok.javac.JavacNode; import com.sun.tools.javac.code.BoundKind; @@ -882,14 +883,14 @@ public class JavacHandlerUtil { * Generates a new statement that checks if the given variable is null, and if so, throws a {@code NullPointerException} with the * variable name as message. */ - public static JCStatement generateNullCheck(TreeMaker treeMaker, JavacNode variable) { + public static JCStatement generateNullCheck(TreeMaker maker, JavacNode variable) { JCVariableDecl varDecl = (JCVariableDecl) variable.get(); if (isPrimitive(varDecl.vartype)) return null; Name fieldName = varDecl.name; JCExpression npe = chainDots(variable, "java", "lang", "NullPointerException"); - JCTree exception = treeMaker.NewClass(null, List.<JCExpression>nil(), npe, List.<JCExpression>of(treeMaker.Literal(fieldName.toString())), null); - JCStatement throwStatement = treeMaker.Throw(exception); - return treeMaker.If(treeMaker.Binary(CTC_EQUAL, treeMaker.Ident(fieldName), treeMaker.Literal(CTC_BOT, null)), throwStatement, null); + JCTree exception = maker.NewClass(null, List.<JCExpression>nil(), npe, List.<JCExpression>of(maker.Literal(fieldName.toString())), null); + JCStatement throwStatement = maker.Throw(exception); + return maker.If(Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(fieldName), Javac.makeLiteral(maker, CTC_BOT, null)), throwStatement, null); } /** diff --git a/src/delombok/lombok/delombok/PrettyCommentsPrinter.java b/src/delombok/lombok/delombok/PrettyCommentsPrinter.java index 6e9a1c94..d0f38a62 100644 --- a/src/delombok/lombok/delombok/PrettyCommentsPrinter.java +++ b/src/delombok/lombok/delombok/PrettyCommentsPrinter.java @@ -48,7 +48,8 @@ import com.sun.source.tree.Tree; import com.sun.tools.javac.code.BoundKind; import com.sun.tools.javac.code.Flags; import com.sun.tools.javac.code.Symbol; -import com.sun.tools.javac.code.TypeTags; +//import com.sun.tools.javac.code.TypeTags; +import com.sun.tools.javac.main.JavaCompiler; import com.sun.tools.javac.tree.JCTree; import com.sun.tools.javac.tree.TreeInfo; import com.sun.tools.javac.tree.TreeScanner; @@ -121,12 +122,12 @@ public class PrettyCommentsPrinter extends JCTree.Visitor { private static final Method GET_TAG_METHOD; private static final Field TAG_FIELD; - private static final int PARENS = Javac.getCtcInt(JCTree.class, "PARENS"); - private static final int IMPORT = Javac.getCtcInt(JCTree.class, "IMPORT"); - private static final int VARDEF = Javac.getCtcInt(JCTree.class, "VARDEF"); - private static final int SELECT = Javac.getCtcInt(JCTree.class, "SELECT"); + private static final Object PARENS = Javac.getTreeTag("PARENS"); + private static final Object IMPORT = Javac.getTreeTag("IMPORT"); + private static final Object VARDEF = Javac.getTreeTag("VARDEF"); + private static final Object SELECT = Javac.getTreeTag("SELECT"); - private static final Map<Integer, String> OPERATORS; + private static final Map<Object, String> OPERATORS; static { Method m = null; @@ -145,44 +146,44 @@ public class PrettyCommentsPrinter extends JCTree.Visitor { GET_TAG_METHOD = m; TAG_FIELD = f; - Map<Integer, String> map = new HashMap<Integer, String>(); + Map<Object, String> map = new HashMap<Object, String>(); - map.put(Javac.getCtcInt(JCTree.class, "POS"), "+"); - map.put(Javac.getCtcInt(JCTree.class, "NEG"), "-"); - map.put(Javac.getCtcInt(JCTree.class, "NOT"), "!"); - map.put(Javac.getCtcInt(JCTree.class, "COMPL"), "~"); - map.put(Javac.getCtcInt(JCTree.class, "PREINC"), "++"); - map.put(Javac.getCtcInt(JCTree.class, "PREDEC"), "--"); - map.put(Javac.getCtcInt(JCTree.class, "POSTINC"), "++"); - map.put(Javac.getCtcInt(JCTree.class, "POSTDEC"), "--"); - map.put(Javac.getCtcInt(JCTree.class, "NULLCHK"), "<*nullchk*>"); - map.put(Javac.getCtcInt(JCTree.class, "OR"), "||"); - map.put(Javac.getCtcInt(JCTree.class, "AND"), "&&"); - map.put(Javac.getCtcInt(JCTree.class, "EQ"), "=="); - map.put(Javac.getCtcInt(JCTree.class, "NE"), "!="); - map.put(Javac.getCtcInt(JCTree.class, "LT"), "<"); - map.put(Javac.getCtcInt(JCTree.class, "GT"), ">"); - map.put(Javac.getCtcInt(JCTree.class, "LE"), "<="); - map.put(Javac.getCtcInt(JCTree.class, "GE"), ">="); - map.put(Javac.getCtcInt(JCTree.class, "BITOR"), "|"); - map.put(Javac.getCtcInt(JCTree.class, "BITXOR"), "^"); - map.put(Javac.getCtcInt(JCTree.class, "BITAND"), "&"); - map.put(Javac.getCtcInt(JCTree.class, "SL"), "<<"); - map.put(Javac.getCtcInt(JCTree.class, "SR"), ">>"); - map.put(Javac.getCtcInt(JCTree.class, "USR"), ">>>"); - map.put(Javac.getCtcInt(JCTree.class, "PLUS"), "+"); - map.put(Javac.getCtcInt(JCTree.class, "MINUS"), "-"); - map.put(Javac.getCtcInt(JCTree.class, "MUL"), "*"); - map.put(Javac.getCtcInt(JCTree.class, "DIV"), "/"); - map.put(Javac.getCtcInt(JCTree.class, "MOD"), "%"); + map.put(Javac.getTreeTag("POS"), "+"); + map.put(Javac.getTreeTag("NEG"), "-"); + map.put(Javac.getTreeTag("NOT"), "!"); + map.put(Javac.getTreeTag("COMPL"), "~"); + map.put(Javac.getTreeTag("PREINC"), "++"); + map.put(Javac.getTreeTag("PREDEC"), "--"); + map.put(Javac.getTreeTag("POSTINC"), "++"); + map.put(Javac.getTreeTag("POSTDEC"), "--"); + map.put(Javac.getTreeTag("NULLCHK"), "<*nullchk*>"); + map.put(Javac.getTreeTag("OR"), "||"); + map.put(Javac.getTreeTag("AND"), "&&"); + map.put(Javac.getTreeTag("EQ"), "=="); + map.put(Javac.getTreeTag("NE"), "!="); + map.put(Javac.getTreeTag("LT"), "<"); + map.put(Javac.getTreeTag("GT"), ">"); + map.put(Javac.getTreeTag("LE"), "<="); + map.put(Javac.getTreeTag("GE"), ">="); + map.put(Javac.getTreeTag("BITOR"), "|"); + map.put(Javac.getTreeTag("BITXOR"), "^"); + map.put(Javac.getTreeTag("BITAND"), "&"); + map.put(Javac.getTreeTag("SL"), "<<"); + map.put(Javac.getTreeTag("SR"), ">>"); + map.put(Javac.getTreeTag("USR"), ">>>"); + map.put(Javac.getTreeTag("PLUS"), "+"); + map.put(Javac.getTreeTag("MINUS"), "-"); + map.put(Javac.getTreeTag("MUL"), "*"); + map.put(Javac.getTreeTag("DIV"), "/"); + map.put(Javac.getTreeTag("MOD"), "%"); OPERATORS = map; } - static int getTag(JCTree tree) { + static Object getTag(JCTree tree) { if (GET_TAG_METHOD != null) { try { - return (Integer)GET_TAG_METHOD.invoke(tree); + return GET_TAG_METHOD.invoke(tree); } catch (IllegalAccessException e) { throw new RuntimeException(e); @@ -192,7 +193,7 @@ public class PrettyCommentsPrinter extends JCTree.Visitor { } } try { - return TAG_FIELD.getInt(tree); + return TAG_FIELD.get(tree); } catch (IllegalAccessException e) { throw new RuntimeException(e); @@ -1222,7 +1223,7 @@ public class PrettyCommentsPrinter extends JCTree.Visitor { } } - public String operatorName(int tag) { + public String operatorName(Object tag) { String result = OPERATORS.get(tag); if (result == null) throw new Error(); return result; @@ -1232,7 +1233,8 @@ public class PrettyCommentsPrinter extends JCTree.Visitor { try { open(prec, TreeInfo.assignopPrec); printExpr(tree.lhs, TreeInfo.assignopPrec + 1); - print(" " + operatorName(getTag(tree) - JCTree.ASGOffset) + "= "); +// print(" " + operatorName(getTag(tree) - JCTree.ASGOffset) + "= "); + print(" = "); printExpr(tree.rhs, TreeInfo.assignopPrec); close(prec, TreeInfo.assignopPrec); } catch (IOException e) { @@ -1242,10 +1244,10 @@ public class PrettyCommentsPrinter extends JCTree.Visitor { public void visitUnary(JCUnary tree) { try { - int ownprec = TreeInfo.opPrec(getTag(tree)); + int ownprec = isOwnPrec(tree); String opname = operatorName(getTag(tree)); open(prec, ownprec); - if (getTag(tree) <= Javac.getCtcInt(JCTree.class, "PREDEC")) { + if (isPostUnary(tree)) { print(opname); printExpr(tree.arg, ownprec); } else { @@ -1257,10 +1259,63 @@ public class PrettyCommentsPrinter extends JCTree.Visitor { throw new UncheckedIOException(e); } } + + private String assignOpName(JCExpression tree) { + try { + Object tag = getTag(tree); + if (JavaCompiler.version().startsWith("1.8")) { + return operatorName(tag.getClass().getMethod("noAssignOp").invoke(tree)); + } else { + return operatorName((Integer)((Integer)tag - (Integer)JCTree.class.getField("ASGOffset").get(null))); + } + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } + + private int isOwnPrec(JCExpression tree) { + try { + if (JavaCompiler.version().startsWith("1.8")) { + return (Integer)TreeInfo.class.getMethod("opPrec", Class.forName("com.sun.tools.javac.code.TypeTag")).invoke(tree, getTag(tree)); + } else { + return (Integer)TreeInfo.class.getMethod("opPrec", Integer.TYPE).invoke(tree, getTag(tree)); + } + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } + + private boolean isPostUnary(JCUnary tree) { + try { + Object tag = getTag(tree); + if (JavaCompiler.version().startsWith("1.8")) { + return (Boolean) tag.getClass().getMethod("isPostUnaryOp").invoke(tree); + } else { + return ((Integer) tag) <= ((Integer) Javac.getTreeTag("PREDEC")); + } + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } public void visitBinary(JCBinary tree) { try { - int ownprec = TreeInfo.opPrec(getTag(tree)); + int ownprec = isOwnPrec(tree); String opname = operatorName(getTag(tree)); open(prec, ownprec); printExpr(tree.lhs, ownprec); @@ -1327,77 +1382,40 @@ public class PrettyCommentsPrinter extends JCTree.Visitor { public void visitLiteral(JCLiteral tree) { try { - switch (tree.typetag) { - case TypeTags.INT: - print(tree.value.toString()); - break; - case TypeTags.LONG: - print(tree.value + "L"); - break; - case TypeTags.FLOAT: - print(tree.value + "F"); - break; - case TypeTags.DOUBLE: - print(tree.value.toString()); - break; - case TypeTags.CHAR: - print("\'" + - Convert.quote( - String.valueOf((char)((Number)tree.value).intValue())) + - "\'"); - break; - case TypeTags.BOOLEAN: - print(((Number)tree.value).intValue() == 1 ? "true" : "false"); - break; - case TypeTags.BOT: - print("null"); - break; - default: - print("\"" + Convert.quote(tree.value.toString()) + "\""); - break; + if (Javac.compareCTC(Javac.getTreeTypeTag(tree), Javac.CTC_INT)) print(tree.value.toString()); + else if (Javac.compareCTC(Javac.getTreeTypeTag(tree), Javac.CTC_LONG)) print(tree.value + "L"); + else if (Javac.compareCTC(Javac.getTreeTypeTag(tree), Javac.CTC_FLOAT)) print(tree.value + "F"); + else if (Javac.compareCTC(Javac.getTreeTypeTag(tree), Javac.CTC_DOUBLE)) print(tree.value.toString()); + else if (Javac.compareCTC(Javac.getTreeTypeTag(tree), Javac.CTC_CHAR)) { + print("\'" + + Convert.quote( + String.valueOf((char)((Number)tree.value).intValue()))+ + "\'"); } + else if (Javac.compareCTC(Javac.getTreeTypeTag(tree), Javac.CTC_BOOLEAN)) print(((Number)tree.value).intValue() == 1 ? "true" : "false"); + else if (Javac.compareCTC(Javac.getTreeTypeTag(tree), Javac.CTC_BOT)) print("null"); + else print("\"" + Convert.quote(tree.value.toString()) + "\""); } catch (IOException e) { throw new UncheckedIOException(e); } } - public void visitTypeIdent(JCPrimitiveTypeTree tree) { - try { - switch(tree.typetag) { - case TypeTags.BYTE: - print("byte"); - break; - case TypeTags.CHAR: - print("char"); - break; - case TypeTags.SHORT: - print("short"); - break; - case TypeTags.INT: - print("int"); - break; - case TypeTags.LONG: - print("long"); - break; - case TypeTags.FLOAT: - print("float"); - break; - case TypeTags.DOUBLE: - print("double"); - break; - case TypeTags.BOOLEAN: - print("boolean"); - break; - case TypeTags.VOID: - print("void"); - break; - default: - print("error"); - break; - } - } catch (IOException e) { - throw new UncheckedIOException(e); - } + public void visitTypeIdent(JCPrimitiveTypeTree tree) { + Object typetag = Javac.getTreeTypeTag(tree); + try { + if (Javac.compareCTC(typetag, Javac.CTC_BYTE)) print("byte"); + else if (Javac.compareCTC(typetag, Javac.CTC_CHAR)) print("char"); + else if (Javac.compareCTC(typetag, Javac.CTC_SHORT)) print("short"); + else if (Javac.compareCTC(typetag, Javac.CTC_INT)) print("int"); + else if (Javac.compareCTC(typetag, Javac.CTC_LONG)) print("long"); + else if (Javac.compareCTC(typetag, Javac.CTC_FLOAT)) print("float"); + else if (Javac.compareCTC(typetag, Javac.CTC_DOUBLE)) print("double"); + else if (Javac.compareCTC(typetag, Javac.CTC_BOOLEAN)) print("boolean"); + else if (Javac.compareCTC(typetag, Javac.CTC_VOID)) print("void"); + else print("error"); + } catch (IOException e) { + throw new UncheckedIOException(e); + } } public void visitTypeArray(JCArrayTypeTree tree) { diff --git a/src/utils/lombok/javac/Javac.java b/src/utils/lombok/javac/Javac.java index 75bb2dbf..cbbd6730 100644 --- a/src/utils/lombok/javac/Javac.java +++ b/src/utils/lombok/javac/Javac.java @@ -21,29 +21,33 @@ */ package lombok.javac; +import java.lang.reflect.Method; import java.util.regex.Pattern; -import com.sun.tools.javac.code.TypeTags; +import com.sun.tools.javac.main.JavaCompiler; import com.sun.tools.javac.tree.JCTree; +import com.sun.tools.javac.tree.JCTree.JCBinary; import com.sun.tools.javac.tree.JCTree.JCExpression; import com.sun.tools.javac.tree.JCTree.JCFieldAccess; import com.sun.tools.javac.tree.JCTree.JCIdent; import com.sun.tools.javac.tree.JCTree.JCLiteral; +import com.sun.tools.javac.tree.JCTree.JCUnary; +import com.sun.tools.javac.tree.TreeMaker; /** * Container for static utility methods relevant to lombok's operation on javac. */ public class Javac { private Javac() { - //prevent instantiation + // prevent instantiation } /** Matches any of the 8 primitive names, such as {@code boolean}. */ - private static final Pattern PRIMITIVE_TYPE_NAME_PATTERN = Pattern.compile( - "^(boolean|byte|short|int|long|float|double|char)$"); + private static final Pattern PRIMITIVE_TYPE_NAME_PATTERN = Pattern.compile("^(boolean|byte|short|int|long|float|double|char)$"); /** - * Checks if the given expression (that really ought to refer to a type expression) represents a primitive type. + * Checks if the given expression (that really ought to refer to a type + * expression) represents a primitive type. */ public static boolean isPrimitive(JCExpression ref) { String typeName = ref.toString(); @@ -51,15 +55,16 @@ public class Javac { } /** - * Turns an expression into a guessed intended literal. Only works for literals, as you can imagine. + * Turns an expression into a guessed intended literal. Only works for + * literals, as you can imagine. * * Will for example turn a TrueLiteral into 'Boolean.valueOf(true)'. */ public static Object calculateGuess(JCExpression expr) { if (expr instanceof JCLiteral) { - JCLiteral lit = (JCLiteral)expr; + JCLiteral lit = (JCLiteral) expr; if (lit.getKind() == com.sun.source.tree.Tree.Kind.BOOLEAN_LITERAL) { - return ((Number)lit.value).intValue() == 0 ? false : true; + return ((Number) lit.value).intValue() == 0 ? false : true; } return lit.value; } else if (expr instanceof JCIdent || expr instanceof JCFieldAccess) { @@ -70,45 +75,207 @@ public class Javac { if (idx > -1) x = x.substring(idx + 1); } return x; - } else return null; + } else + return null; } - public static final int CTC_BOOLEAN = getCtcInt(TypeTags.class, "BOOLEAN"); - public static final int CTC_INT = getCtcInt(TypeTags.class, "INT"); - public static final int CTC_DOUBLE = getCtcInt(TypeTags.class, "DOUBLE"); - public static final int CTC_FLOAT = getCtcInt(TypeTags.class, "FLOAT"); - public static final int CTC_SHORT = getCtcInt(TypeTags.class, "SHORT"); - public static final int CTC_BYTE = getCtcInt(TypeTags.class, "BYTE"); - public static final int CTC_LONG = getCtcInt(TypeTags.class, "LONG"); - public static final int CTC_CHAR = getCtcInt(TypeTags.class, "CHAR"); - public static final int CTC_VOID = getCtcInt(TypeTags.class, "VOID"); - public static final int CTC_NONE = getCtcInt(TypeTags.class, "NONE"); - - public static final int CTC_NOT_EQUAL = getCtcInt(JCTree.class, "NE"); - public static final int CTC_NOT = getCtcInt(JCTree.class, "NOT"); - public static final int CTC_BITXOR = getCtcInt(JCTree.class, "BITXOR"); - public static final int CTC_UNSIGNED_SHIFT_RIGHT = getCtcInt(JCTree.class, "USR"); - public static final int CTC_MUL = getCtcInt(JCTree.class, "MUL"); - public static final int CTC_PLUS = getCtcInt(JCTree.class, "PLUS"); - public static final int CTC_BOT = getCtcInt(TypeTags.class, "BOT"); - public static final int CTC_EQUAL = getCtcInt(JCTree.class, "EQ"); + public static final Object CTC_BOOLEAN = getTypeTag("BOOLEAN"); + public static final Object CTC_INT = getTypeTag("INT"); + public static final Object CTC_DOUBLE = getTypeTag("DOUBLE"); + public static final Object CTC_FLOAT = getTypeTag("FLOAT"); + public static final Object CTC_SHORT = getTypeTag("SHORT"); + public static final Object CTC_BYTE = getTypeTag("BYTE"); + public static final Object CTC_LONG = getTypeTag("LONG"); + public static final Object CTC_CHAR = getTypeTag("CHAR"); + public static final Object CTC_VOID = getTypeTag("VOID"); + public static final Object CTC_NONE = getTypeTag("NONE"); + public static final Object CTC_BOT = getTypeTag("BOT"); + public static final Object CTC_CLASS = getTypeTag("CLASS"); + + public static final Object CTC_NOT_EQUAL = getTreeTag("NE"); + public static final Object CTC_NOT = getTreeTag("NOT"); + public static final Object CTC_BITXOR = getTreeTag("BITXOR"); + public static final Object CTC_UNSIGNED_SHIFT_RIGHT = getTreeTag("USR"); + public static final Object CTC_MUL = getTreeTag("MUL"); + public static final Object CTC_PLUS = getTreeTag("PLUS"); + public static final Object CTC_EQUAL = getTreeTag("EQ"); + +// /** +// * Retrieves the current ordinal position of a type tag. +// * +// * For JDK 8 this is the ordinal position within the +// * <code>com.sun.tools.javac.code.TypeTag enum</code> for JDK 7 and lower, +// * this is the value of the constant within +// * <code>com.sun.tools.javac.code.TypeTags</code> +// * +// * Solves the problem of compile time constant inlining, resulting in lombok +// * having the wrong value (javac compiler changes private api constants from +// * time to time). +// * +// * @param identifier +// * @return the ordinal value of the typetag constant +// */ +// public static int getTypeTag(String identifier) { +// try { +// if (JavaCompiler.version().startsWith("1.8")) { +// Object enumInstance = Class.forName("com.sun.tools.javac.code.TypeTag").getField(identifier).get(null); +// return (int) Class.forName("com.sun.tools.javac.code.TypeTag").getField("order").get(enumInstance); +// +// } else { +// return (int) Class.forName("com.sun.tools.javac.code.TypeTags").getField(identifier).get(null); +// } +// } catch (NoSuchFieldException e) { +// throw new RuntimeException(e); +// } catch (IllegalAccessException e) { +// throw new RuntimeException(e); +// } catch (Exception e) { +// if (e instanceof RuntimeException) throw (RuntimeException) e; +// throw new RuntimeException(e); +// } +// } + + + + public static boolean compareCTC(Object ctc1, Object ctc2) { + return ctc1.equals(ctc2); + } /** - * Retrieves a compile time constant of type int from the specified class location. + * Retrieves the current type tag. The actual type object differs depending on the Compiler version + * + * For JDK 8 this is an enum value of type <code>com.sun.tools.javac.code.TypeTag</code> + * for JDK 7 and lower, this is the value of the constant within <code>com.sun.tools.javac.code.TypeTags</code> * - * Solves the problem of compile time constant inlining, resulting in lombok having the wrong value - * (javac compiler changes private api constants from time to time) + * Solves the problem of compile time constant inlining, resulting in lombok + * having the wrong value (javac compiler changes private api constants from + * time to time). * - * @param ctcLocation location of the compile time constant - * @param identifier the name of the field of the compile time constant. + * @param identifier + * @return the ordinal value of the typetag constant */ - public static int getCtcInt(Class<?> ctcLocation, String identifier) { + public static Object getTypeTag(String identifier) { try { - return (Integer)ctcLocation.getField(identifier).get(null); + if (JavaCompiler.version().startsWith("1.8")) { + return Class.forName("com.sun.tools.javac.code.TypeTag").getField(identifier).get(null); + } else { + return Class.forName("com.sun.tools.javac.code.TypeTags").getField(identifier).get(null); + } } catch (NoSuchFieldException e) { throw new RuntimeException(e); } catch (IllegalAccessException e) { throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } + + public static Object getTreeTag(String identifier) { + try { + if (JavaCompiler.version().startsWith("1.8")) { + return Class.forName("com.sun.tools.javac.tree.JCTree$Tag").getField(identifier).get(null); + } else { + return Class.forName("com.sun.tools.javac.tree.JCTree").getField(identifier).get(null); + } + } catch (NoSuchFieldException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); } } + + + public static Object getTreeTypeTag(JCTree tree) { + try { + return TreeMaker.class.getField("typetag").get(tree); + } catch (NoSuchFieldException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } + + public static JCExpression makeTypeIdent(TreeMaker maker, Object ctc) { + try { + Method createIdent; + if (JavaCompiler.version().startsWith("1.8")) { + createIdent = TreeMaker.class.getMethod("TypeIdent", Class.forName("com.sun.tools.javac.code.TypeTag")); + } else { + createIdent = TreeMaker.class.getMethod("TypeIdent", Integer.TYPE); + } + return (JCExpression) createIdent.invoke(maker, ctc); + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } + + public static JCLiteral makeLiteral(TreeMaker maker, Object ctc, Object argument) { + try { + Method createLiteral; + if (JavaCompiler.version().startsWith("1.8")) { + createLiteral = TreeMaker.class.getMethod("Literal", Class.forName("com.sun.tools.javac.code.TypeTag"), Object.class); + } else { + createLiteral = TreeMaker.class.getMethod("Literal", Integer.TYPE, Object.class); + } + return (JCLiteral) createLiteral.invoke(maker, ctc, argument); + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } + + public static JCUnary makeUnary(TreeMaker maker, Object ctc, JCExpression argument) { + try { + Method createUnary; + if (JavaCompiler.version().startsWith("1.8")) { + createUnary = TreeMaker.class.getMethod("Unary", Class.forName("com.sun.tools.javac.code.TypeTag"), JCExpression.class); + } else { + createUnary = TreeMaker.class.getMethod("Unary", Integer.TYPE, JCExpression.class); + } + return (JCUnary) createUnary.invoke(maker, ctc, argument); + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } + + public static JCBinary makeBinary(TreeMaker maker, Object ctc, JCExpression rhsArgument, JCExpression lhsArgument) { + try { + Method createUnary; + if (JavaCompiler.version().startsWith("1.8")) { + createUnary = TreeMaker.class.getMethod("Binary", Class.forName("com.sun.tools.javac.code.TypeTag"), JCExpression.class, JCExpression.class); + } else { + createUnary = TreeMaker.class.getMethod("Binary", Integer.TYPE, JCExpression.class, JCExpression.class); + } + return (JCBinary) createUnary.invoke(maker, ctc, rhsArgument, lhsArgument); + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (Exception e) { + if (e instanceof RuntimeException) throw (RuntimeException) e; + throw new RuntimeException(e); + } + } + + } |