aboutsummaryrefslogtreecommitdiff
path: root/src/core/lombok/eclipse
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/lombok/eclipse')
-rw-r--r--src/core/lombok/eclipse/handlers/HandleSuperBuilder.java199
1 files changed, 60 insertions, 139 deletions
diff --git a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
index d01e250d..71683516 100644
--- a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
@@ -199,49 +199,61 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
// Set the names of the builder classes.
String builderClassName = String.valueOf(td.name) + "Builder";
String builderImplClassName = builderClassName + "Impl";
+
+ typeParams = td.typeParameters != null ? td.typeParameters : new TypeParameter[0];
+ returnType = namePlusTypeParamsToTypeReference(td.name, typeParams, p);
+
+ // <C, B> are the generics for our builder.
+ String classGenericName = "C";
+ String builderGenericName = "B";
+ // If these generics' names collide with any generics on the annotated class, modify them.
+ // For instance, if there are generics <B, B2, C> on the annotated class, use "C2" and "B3" for our builder.
+ java.util.List<String> typeParamStrings = new ArrayList<String>();
+ for (TypeParameter typeParam : typeParams) {
+ typeParamStrings.add(typeParam.toString());
+ }
+ classGenericName = generateNonclashingNameFor(classGenericName, typeParamStrings);
+ builderGenericName = generateNonclashingNameFor(builderGenericName, typeParamStrings);
TypeReference extendsClause = td.superclass;
TypeReference superclassBuilderClass = null;
-// if (extendsClause.getTypeArguments() != null) {
-// // Remember the type arguments, because we need them for the extends clause of our abstract builder class.
-// superclassTypeParams = ((JCTypeApply)extendsClause).getTypeArguments();
-// // A class name with a generics type, e.g., "Superclass<A>".
-// extendsClause = ((JCTypeApply)extendsClause).getType();
-// }
+ TypeReference[] typeArguments = new TypeReference[] {
+ new SingleTypeReference(classGenericName.toCharArray(), 0),
+ new SingleTypeReference(builderGenericName.toCharArray(), 0)
+ };
if (extendsClause instanceof QualifiedTypeReference) {
QualifiedTypeReference qualifiedTypeReference = (QualifiedTypeReference)extendsClause;
String superclassClassName = String.valueOf(qualifiedTypeReference.getLastToken());
String superclassBuilderClassName = superclassClassName + "Builder";
+
char[][] tokens = Arrays.copyOf(qualifiedTypeReference.tokens, qualifiedTypeReference.tokens.length + 1);
tokens[tokens.length] = superclassBuilderClassName.toCharArray();
long[] poss = new long[tokens.length];
Arrays.fill(poss, p);
- superclassBuilderClass = new QualifiedTypeReference(tokens, poss);
+
+ // Every token may potentially have type args. Here, we only have
+ // type args for the last token, the superclass' builder.
+ TypeReference[][] typeArgsForTokens = new TypeReference[tokens.length][];
+ typeArgsForTokens[typeArgsForTokens.length-1] = typeArguments;
+
+ superclassBuilderClass = new ParameterizedQualifiedTypeReference(tokens, typeArgsForTokens, 0, poss);
} else if (extendsClause != null) {
String superClass = String.valueOf(extendsClause.getTypeName()[0]);
String superclassBuilderClassName = superClass + "Builder";
+
char[][] tokens = new char[][] {superClass.toCharArray(), superclassBuilderClassName.toCharArray()};
long[] poss = new long[tokens.length];
Arrays.fill(poss, p);
- superclassBuilderClass = new QualifiedTypeReference(tokens, poss);
- }
- // If there is no superclass, superclassBuilderClassExpression is still == null at this point.
- // You can use it to check whether to inherit or not.
- typeParams = td.typeParameters != null ? td.typeParameters : new TypeParameter[0];
- returnType = namePlusTypeParamsToTypeReference(td.name, typeParams, p);
+ // Every token may potentially have type args. Here, we only have
+ // type args for the last token, the superclass' builder.
+ TypeReference[][] typeArgsForTokens = new TypeReference[tokens.length][];
+ typeArgsForTokens[typeArgsForTokens.length-1] = typeArguments;
- // <C, B> are the generics for our builder.
- String classGenericName = "C";
- String builderGenericName = "B";
- // If these generics' names collide with any generics on the annotated class, modify them.
- // For instance, if there are generics <B, B2, C> on the annotated class, use "C2" and "B3" for our builder.
- java.util.List<String> typeParamStrings = new ArrayList<String>();
- for (TypeParameter typeParam : typeParams) {
- typeParamStrings.add(typeParam.toString());
+ superclassBuilderClass = new ParameterizedQualifiedTypeReference(tokens, typeArgsForTokens, 0, poss);
}
- classGenericName = generateNonclashingNameFor(classGenericName, typeParamStrings);
- builderGenericName = generateNonclashingNameFor(builderGenericName, typeParamStrings);
+ // If there is no superclass, superclassBuilderClassExpression is still == null at this point.
+ // You can use it to check whether to inherit or not.
generateBuilderBasedConstructor(tdParent, typeParams, builderFields, annotationNode, builderClassName,
superclassBuilderClass != null);
@@ -335,14 +347,10 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
// Add the builder() method to the annotated class.
if (methodExists(builderMethodName, tdParent, -1) == MemberExistsResult.NOT_EXISTS) {
MethodDeclaration md = generateBuilderMethod(builderMethodName, builderClassName, builderImplClassName, tdParent, typeParams, ast);
-// recursiveSetGeneratedBy(md, ast, annotationNode.getContext());
if (md != null) {
injectMethod(tdParent, md);
}
}
-
-// recursiveSetGeneratedBy(builderType.get(), ast, annotationNode.getContext());
-// recursiveSetGeneratedBy(builderImplType.get(), ast, annotationNode.getContext());
}
private String generateNonclashingNameFor(String classGenericName, java.util.List<String> typeParamStrings) {
@@ -441,40 +449,19 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
injectMethod(typeNode, constructor);
}
-// private ListBuffer<JCExpression> getTypeParamExpressions(List<? extends JCTree> typeParams, JavacTreeMaker maker) {
-// ListBuffer<JCExpression> typeParamsForBuilderParameter = new ListBuffer<JCExpression>();
-// for (JCTree typeParam : typeParams) {
-// if (typeParam instanceof JCTypeParameter) {
-// typeParamsForBuilderParameter.add(maker.Ident(((JCTypeParameter)typeParam).getName()));
-// } else if (typeParam instanceof JCIdent) {
-// typeParamsForBuilderParameter.add(maker.Ident(((JCIdent)typeParam).getName()));
-// }
-// }
-// return typeParamsForBuilderParameter;
-// }
-
private MethodDeclaration generateAbstractSelfMethod(EclipseNode tdParent, boolean override, String builderGenericName) {
- // TODO: @Override annotation if override == true.
MethodDeclaration out = new MethodDeclaration(((CompilationUnitDeclaration) tdParent.top().get()).compilationResult);
out.selector = SELF_METHOD.toCharArray();
out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
out.modifiers = ClassFileConstants.AccAbstract | ClassFileConstants.AccProtected;
+ if (override) {
+ out.annotations = new Annotation[] {makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, tdParent.get())};
+ }
out.returnType = new SingleTypeReference(builderGenericName.toCharArray(), 0);
return out;
}
private MethodDeclaration generateSelfMethod(EclipseNode builderImplType) {
-// JavacTreeMaker maker = builderImplType.getTreeMaker();
-//
-// JCAnnotation overrideAnnotation = maker.Annotation(genJavaLangTypeRef(builderImplType, "Override"), List.<JCExpression>nil());
-// JCModifiers modifiers = maker.Modifiers(Flags.PROTECTED, List.of(overrideAnnotation));
-// Name name = builderImplType.toName(SELF_METHOD);
-// JCExpression returnType = maker.Ident(builderImplType.toName(builderImplType.getName()));
-//
-// JCStatement statement = maker.Return(maker.Ident(builderImplType.toName("this")));
-// JCBlock body = maker.Block(0, List.<JCStatement>of(statement));
-//
-// return maker.MethodDef(modifiers, name, returnType, List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null);
MethodDeclaration out = new MethodDeclaration(((CompilationUnitDeclaration) builderImplType.top().get()).compilationResult);
out.selector = SELF_METHOD.toCharArray();
out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
@@ -497,11 +484,6 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
if (override) {
out.annotations = new Annotation[] {makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, source)};
}
-
- AllocationExpression allocationStatement = new AllocationExpression();
- allocationStatement.type = copyType(out.returnType);
- // Use a constructor that only has this builder as parameter.
- allocationStatement.arguments = new Expression[] {new ThisReference(0, 0)};
out.traverse(new SetGeneratedByVisitor(source), (ClassScope) null);
return out;
}
@@ -550,51 +532,21 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
return out;
}
-// private MethodDeclaration generateBuildMethod(String buildName, JCExpression returnType, EclipseNode type, List<JCExpression> thrownExceptions) {
-// JavacTreeMaker maker = type.getTreeMaker();
-//
-// JCExpression call;
-// ListBuffer<JCStatement> statements = new ListBuffer<JCStatement>();
-//
-// // Use a constructor that only has this builder as parameter.
-// List<JCExpression> builderArg = List.<JCExpression>of(maker.Ident(type.toName("this")));
-// call = maker.NewClass(null, List.<JCExpression>nil(), returnType, builderArg, null);
-// statements.append(maker.Return(call));
-//
-// JCBlock body = maker.Block(0, statements.toList());
-//
-// JCAnnotation overrideAnnotation = maker.Annotation(genJavaLangTypeRef(type, "Override"), List.<JCExpression>nil());
-// JCModifiers modifiers = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
-//
-// return maker.MethodDef(modifiers, type.toName(buildName), returnType, List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), thrownExceptions, body, null);
-// }
-
- private MethodDeclaration generateDefaultProvider(char[] methodName, TypeParameter[] typeParameters, EclipseNode fieldNode, ASTNode source) {
- int pS = source.sourceStart, pE = source.sourceEnd;
-
- MethodDeclaration out = new MethodDeclaration(((CompilationUnitDeclaration) fieldNode.top().get()).compilationResult);
- out.typeParameters = copyTypeParams(typeParameters, source);
- out.selector = methodName;
- out.modifiers = ClassFileConstants.AccPrivate | ClassFileConstants.AccStatic;
- out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
- FieldDeclaration fd = (FieldDeclaration) fieldNode.get();
- out.returnType = copyType(fd.type, source);
- out.statements = new Statement[] {new ReturnStatement(fd.initialization, pS, pE)};
- fd.initialization = null;
-
- out.traverse(new SetGeneratedByVisitor(source), ((TypeDeclaration) fieldNode.up().get()).scope);
- return out;
- }
-// public MethodDeclaration generateDefaultProvider(Name methodName, EclipseNode fieldNode, List<JCTypeParameter> params) {
-// JavacTreeMaker maker = fieldNode.getTreeMaker();
-// JCVariableDecl field = (JCVariableDecl) fieldNode.get();
+// private MethodDeclaration generateDefaultProvider(char[] methodName, TypeParameter[] typeParameters, EclipseNode fieldNode, ASTNode source) {
+// int pS = source.sourceStart, pE = source.sourceEnd;
//
-// JCStatement statement = maker.Return(field.init);
-// field.init = null;
+// MethodDeclaration out = new MethodDeclaration(((CompilationUnitDeclaration) fieldNode.top().get()).compilationResult);
+// out.typeParameters = copyTypeParams(typeParameters, source);
+// out.selector = methodName;
+// out.modifiers = ClassFileConstants.AccPrivate | ClassFileConstants.AccStatic;
+// out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
+// FieldDeclaration fd = (FieldDeclaration) fieldNode.get();
+// out.returnType = copyType(fd.type, source);
+// out.statements = new Statement[] {new ReturnStatement(fd.initialization, pS, pE)};
+// fd.initialization = null;
//
-// JCBlock body = maker.Block(0, List.<JCStatement>of(statement));
-// int modifiers = Flags.PRIVATE | Flags.STATIC;
-// return maker.MethodDef(maker.Modifiers(modifiers), methodName, cloneType(maker, field.vartype, field, fieldNode.getContext()), copyTypeParams(fieldNode, params), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null);
+// out.traverse(new SetGeneratedByVisitor(source), ((TypeDeclaration) fieldNode.up().get()).scope);
+// return out;
// }
private MethodDeclaration generateBuilderMethod(String builderMethodName, String builderClassName, String builderImplClassName, EclipseNode type, TypeParameter[] typeParams, ASTNode source) {
@@ -605,41 +557,21 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
out.selector = builderMethodName.toCharArray();
out.modifiers = ClassFileConstants.AccPublic | ClassFileConstants.AccStatic;
out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
- out.returnType = namePlusTypeParamsToTypeReference(builderClassName.toCharArray(), typeParams, p);
+
+ // TODO: add type params
//out.typeParameters = copyTypeParams(typeParams, source);
+ TypeReference[] returnTypeParams = new TypeReference[2];
+ returnTypeParams[0] = new Wildcard(Wildcard.UNBOUND);
+ returnTypeParams[1] = new Wildcard(Wildcard.UNBOUND);
+ out.returnType = new ParameterizedSingleTypeReference(builderClassName.toCharArray(), returnTypeParams, 0, p);
+
AllocationExpression invoke = new AllocationExpression();
- invoke.type = namePlusTypeParamsToTypeReference(builderClassName.toCharArray(), typeParams, p);
+ invoke.type = namePlusTypeParamsToTypeReference(builderImplClassName.toCharArray(), typeParams, p);
out.statements = new Statement[] {new ReturnStatement(invoke, pS, pE)};
out.traverse(new SetGeneratedByVisitor(source), ((TypeDeclaration) type.get()).scope);
return out;
}
-// public MethodDeclaration generateBuilderMethod(String builderMethodName, String builderClassName, String builderImplClassName, EclipseNode source, EclipseNode type, List<JCTypeParameter> typeParams) {
-// JavacTreeMaker maker = type.getTreeMaker();
-//
-// ListBuffer<JCExpression> typeArgs = new ListBuffer<JCExpression>();
-// for (JCTypeParameter typeParam : typeParams) {
-// typeArgs.append(maker.Ident(typeParam.name));
-// }
-//
-// JCExpression call = maker.NewClass(null, List.<JCExpression>nil(), namePlusTypeParamsToTypeReference(maker, type.toName(builderImplClassName), typeParams), List.<JCExpression>nil(), null);
-// JCStatement statement = maker.Return(call);
-//
-// JCBlock body = maker.Block(0, List.<JCStatement>of(statement));
-// int modifiers = Flags.PUBLIC;
-// modifiers |= Flags.STATIC;
-//
-// // Add any type params of the annotated class to the return type.
-// ListBuffer<JCExpression> typeParameterNames = new ListBuffer<JCExpression>();
-// typeParameterNames.addAll(typeParameterNames(maker, typeParams));
-// // Now add the <?, ?>.
-// JCWildcard wildcard = maker.Wildcard(maker.TypeBoundKind(BoundKind.UNBOUND), null);
-// typeParameterNames.add(wildcard);
-// typeParameterNames.add(wildcard);
-// JCTypeApply returnType = maker.TypeApply(maker.Ident(type.toName(builderClassName)), typeParameterNames.toList());
-//
-// return maker.MethodDef(maker.Modifiers(modifiers), type.toName(builderMethodName), returnType, copyTypeParams(source, typeParams), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null);
-// }
private void generateBuilderFields(EclipseNode builderType, List<BuilderFieldData> builderFields, ASTNode source) {
List<EclipseNode> existing = new ArrayList<EclipseNode>();
@@ -779,18 +711,7 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
o.type = new ParameterizedSingleTypeReference(builderClass.toCharArray(), typerefs, 0, 0);
builder.typeParameters[builder.typeParameters.length - 1] = o;
- builder.superclass = superclassBuilderClass;
- // TODO: Extends clause when there is a superclass.
-// JCExpression extending = null;
-// if (superclassBuilderClassExpression != null) {
-// // If the annotated class extends another class, we want this builder to extend the builder of the superclass.
-// // 1. Add the type parameters of the superclass.
-// typeParamsForBuilder = getTypeParamExpressions(superclassTypeParams, maker);
-// // 2. Add the builder type params <C, B>.
-// typeParamsForBuilder.add(maker.Ident(tdParent.toName(classGenericName)));
-// typeParamsForBuilder.add(maker.Ident(tdParent.toName(builderGenericName)));
-// extending = maker.TypeApply(superclassBuilderClassExpression, typeParamsForBuilder.toList());
-// }
+ builder.superclass = copyType(superclassBuilderClass, source);
builder.traverse(new SetGeneratedByVisitor(source), (ClassScope) null);
return injectType(tdParent, builder);
generated by cgit (git 2.46.0) at 2024-11-27 20:46:53 +0000