Removed the dependency on lombok version 1.16.20, which was used for …

…the experimental versions of the @builder and @value annotations. (#551)

* Removed the dependency on lombok version 1.16.20, which was used for the experimental versions of the @builder and @value annotations.

@builder was promoted in lombok from experimental to the main package in v1.16.0 on January 26th, 2015, nearly 4 years ago.
@value was promoted in lombok from experimental to the main package in v0.12.0 on July 16th, 2013, over 5 years ago.

The experimental versions of @builder and @value have been replaced with the main package versions, or otherwise removed where appropriate.

The chain and fluent options to @builder are now the default, so the BuilderChainAndFluent test was removed.
The ValueExperimental test no longer seems relevant so it was also removed.
Other tests were updated as necessary.

* Removed or updated @SuppressWarnings annotations.  Removed isFluentBuilder() and isChainBuilder() from the BuilderHandler class.

* Removed duplicate Value class annotation.

* Added non-varargs constructors to avoid using @SuppressWarnings annotations, to match AbstractClassProcessor.

build.gradle

@@ -110,12 +110,10 @@ jacocoTestReport {
 // Configurations
 configurations {
   lombok
-  lombok_dep
 }
 
 dependencies {
   lombok group: 'org.projectlombok', name: 'lombok', version: '1.18.2', classifier: 'sources', ext: 'jar'
-  lombok_dep group: 'org.projectlombok', name: 'lombok', version: '1.16.20', classifier: 'sources', ext: 'jar'
 
   testCompile group: 'junit', name: 'junit', version: '4.12'
   testCompile group: 'org.mockito', name: 'mockito-core', version: '1.+'
@@ -149,15 +147,6 @@ copy {
   into("generated/src")
 }
 
-copy {
-  includeEmptyDirs = false
-  from({ zipTree(configurations.lombok_dep.singleFile) }) {
-    include 'lombok/experimental/Value.java'
-    include 'lombok/experimental/Builder.java'
-  }
-  into("generated/src")
-}
-
 copy {
   includeEmptyDirs = false
   from({ zipTree(configurations.lombok.singleFile) }) {

src/main/java/de/plushnikov/intellij/plugin/extension/LombokElementFinder.java

@@ -36,7 +36,6 @@ JavaFileManager getServiceManager(GlobalSearchScope scope) {
 
   @Nullable
   @Override
-  @SuppressWarnings("deprecation")
   public PsiClass findClass(@NotNull String qualifiedName, @NotNull GlobalSearchScope scope) {
     final int lastDot = qualifiedName.lastIndexOf('.');
     if (lastDot < 0) {
@@ -51,12 +50,12 @@ public PsiClass findClass(@NotNull String qualifiedName, @NotNull GlobalSearchSc
 
     final PsiClass parentClass = getPsiClassAndPreventRecursionCalls(parentName, scope);
     if (null != parentClass) {
-      if (PsiAnnotationSearchUtil.isAnnotatedWith(parentClass, Builder.class, lombok.experimental.Builder.class)) {
+      if (PsiAnnotationSearchUtil.isAnnotatedWith(parentClass, Builder.class)) {
         return parentClass.findInnerClassByName(shortName, false);
       } else {
         final Collection<PsiMethod> psiMethods = PsiClassUtil.collectClassMethodsIntern(parentClass);
         for (PsiMethod psiMethod : psiMethods) {
-          if (PsiAnnotationSearchUtil.isAnnotatedWith(psiMethod, Builder.class, lombok.experimental.Builder.class)) {
+          if (PsiAnnotationSearchUtil.isAnnotatedWith(psiMethod, Builder.class)) {
             return parentClass.findInnerClassByName(shortName, false);
           }
         }

src/main/java/de/plushnikov/intellij/plugin/extension/LombokRenameFieldReferenceProcessor.java

@@ -68,7 +68,7 @@ public void prepareRenaming(@NotNull PsiElement element, @NotNull String newFiel
         }
       }
 
-      final PsiAnnotation builderAnnotation = PsiAnnotationSearchUtil.findAnnotation(containingClass, Builder.class, lombok.experimental.Builder.class);
+      final PsiAnnotation builderAnnotation = PsiAnnotationSearchUtil.findAnnotation(containingClass, Builder.class);
       if (null != builderAnnotation) {
         final PsiAnnotation singularAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, Singular.class);
         final BuilderElementHandler handler = SingularHandlerFactory.getHandlerFor(psiField, singularAnnotation);

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/DataProcessor.java

@@ -109,7 +109,7 @@ private boolean shouldGenerateRequiredArgsConstructor(@NotNull PsiClass psiClass
     boolean result = false;
     // create required constructor only if there are no other constructor annotations
     if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, NoArgsConstructor.class, RequiredArgsConstructor.class, AllArgsConstructor.class,
-      Builder.class, lombok.experimental.Builder.class)) {
+      Builder.class)) {
       final Collection<PsiMethod> definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass);
       filterToleratedElements(definedConstructors);
 

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/EqualsAndHashCodeProcessor.java

@@ -152,15 +152,14 @@ protected Collection<PsiMethod> createEqualAndHashCode(@NotNull PsiClass psiClas
     return result;
   }
 
-  @SuppressWarnings("deprecation")
   private boolean shouldGenerateCanEqual(@NotNull PsiClass psiClass) {
     final boolean isNotDirectDescendantOfObject = PsiClassUtil.hasSuperClass(psiClass);
     if (isNotDirectDescendantOfObject) {
       return true;
     }
 
     final boolean isFinal = psiClass.hasModifierProperty(PsiModifier.FINAL) ||
-      (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class) && PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, NonFinal.class));
+      (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class) && PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, NonFinal.class));
     return !isFinal;
   }
 

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/ValueProcessor.java

@@ -37,10 +37,9 @@ public class ValueProcessor extends AbstractClassProcessor {
   private final AllArgsConstructorProcessor allArgsConstructorProcessor;
   private final NoArgsConstructorProcessor noArgsConstructorProcessor;
 
-  @SuppressWarnings({"deprecation", "unchecked"})
   public ValueProcessor(GetterProcessor getterProcessor, EqualsAndHashCodeProcessor equalsAndHashCodeProcessor,
                         ToStringProcessor toStringProcessor, AllArgsConstructorProcessor allArgsConstructorProcessor, NoArgsConstructorProcessor noArgsConstructorProcessor) {
-    super(PsiMethod.class, Value.class, lombok.experimental.Value.class);
+    super(PsiMethod.class, Value.class);
 
     this.getterProcessor = getterProcessor;
     this.equalsAndHashCodeProcessor = equalsAndHashCodeProcessor;
@@ -68,7 +67,7 @@ private boolean validateAnnotationOnRightType(@NotNull PsiClass psiClass, @NotNu
     return result;
   }
 
-  @SuppressWarnings("deprecation")
+  @SuppressWarnings({"unchecked"})
   protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) {
 
     if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, Getter.class)) {
@@ -82,7 +81,7 @@ protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnot
     }
     // create required constructor only if there are no other constructor annotations
     if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, NoArgsConstructor.class, RequiredArgsConstructor.class, AllArgsConstructor.class,
-      lombok.experimental.Builder.class, lombok.Builder.class)) {
+      lombok.Builder.class)) {
       final Collection<PsiMethod> definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass);
       filterToleratedElements(definedConstructors);
       // and only if there are no any other constructors!

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/AbstractBuilderPreDefinedInnerClassProcessor.java

@@ -26,6 +26,12 @@ public abstract class AbstractBuilderPreDefinedInnerClassProcessor extends Abstr
 
   protected final BuilderHandler builderHandler;
 
+  AbstractBuilderPreDefinedInnerClassProcessor(@NotNull BuilderHandler builderHandler, @NotNull Class<? extends PsiElement> supportedClass,
+    @NotNull Class<? extends Annotation> supportedAnnotationClass) {
+    super(supportedClass, supportedAnnotationClass);
+    this.builderHandler = builderHandler;
+  }
+
   AbstractBuilderPreDefinedInnerClassProcessor(@NotNull BuilderHandler builderHandler, @NotNull Class<? extends PsiElement> supportedClass,
                                                @NotNull Class<? extends Annotation> supportedAnnotationClass,
                                                @NotNull Class<? extends Annotation>... equivalentAnnotationClasses) {

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/BuilderClassProcessor.java

@@ -24,9 +24,8 @@ public class BuilderClassProcessor extends AbstractClassProcessor {
 
   private final BuilderHandler builderHandler;
 
-  @SuppressWarnings({"deprecation", "unchecked"})
   public BuilderClassProcessor(@NotNull BuilderHandler builderHandler) {
-    super(PsiClass.class, Builder.class, lombok.experimental.Builder.class);
+    super(PsiClass.class, Builder.class);
     this.builderHandler = builderHandler;
   }
 

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/BuilderPreDefinedInnerClassFieldProcessor.java

@@ -23,9 +23,8 @@
  */
 public class BuilderPreDefinedInnerClassFieldProcessor extends AbstractBuilderPreDefinedInnerClassProcessor {
 
-  @SuppressWarnings({"deprecation", "unchecked"})
   public BuilderPreDefinedInnerClassFieldProcessor(@NotNull BuilderHandler builderHandler) {
-    super(builderHandler, PsiField.class, Builder.class, lombok.experimental.Builder.class);
+    super(builderHandler, PsiField.class, Builder.class);
   }
 
   @Override

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/BuilderPreDefinedInnerClassMethodProcessor.java

@@ -23,9 +23,8 @@
  */
 public class BuilderPreDefinedInnerClassMethodProcessor extends AbstractBuilderPreDefinedInnerClassProcessor {
 
-  @SuppressWarnings({"deprecation", "unchecked"})
   public BuilderPreDefinedInnerClassMethodProcessor(@NotNull BuilderHandler builderHandler) {
-    super(builderHandler, PsiMethod.class, Builder.class, lombok.experimental.Builder.class);
+    super(builderHandler, PsiMethod.class, Builder.class);
   }
 
   protected void generatePsiElements(@NotNull PsiClass psiParentClass, @Nullable PsiMethod psiParentMethod, @NotNull PsiClass psiBuilderClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) {

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/BuilderProcessor.java

@@ -38,9 +38,8 @@ public class BuilderProcessor extends AbstractClassProcessor {
   private final BuilderHandler builderHandler;
   private final AllArgsConstructorProcessor allArgsConstructorProcessor;
 
-  @SuppressWarnings({"deprecation", "unchecked"})
   public BuilderProcessor(@NotNull AllArgsConstructorProcessor allArgsConstructorProcessor, @NotNull BuilderHandler builderHandler) {
-    super(PsiMethod.class, Builder.class, lombok.experimental.Builder.class);
+    super(PsiMethod.class, Builder.class);
     this.builderHandler = builderHandler;
     this.allArgsConstructorProcessor = allArgsConstructorProcessor;
   }

src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java

@@ -159,10 +159,9 @@ private PsiMethod findExistedMethod(final Collection<PsiMethod> definedMethods,
   }
 
   @NotNull
-  @SuppressWarnings("deprecation")
   protected Collection<PsiField> getAllNotInitializedAndNotStaticFields(@NotNull PsiClass psiClass) {
     Collection<PsiField> allNotInitializedNotStaticFields = new ArrayList<PsiField>();
-    final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class);
+    final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class);
     for (PsiField psiField : psiClass.getFields()) {
       // skip fields named $
       boolean addField = !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER);
@@ -191,10 +190,9 @@ public Collection<PsiField> getAllFields(@NotNull PsiClass psiClass) {
   }
 
   @NotNull
-  @SuppressWarnings("deprecation")
   public Collection<PsiField> getRequiredFields(@NotNull PsiClass psiClass) {
     Collection<PsiField> result = new ArrayList<PsiField>();
-    final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class);
+    final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class);
 
     for (PsiField psiField : getAllNotInitializedAndNotStaticFields(psiClass)) {
       final PsiModifierList modifierList = psiField.getModifierList();

src/main/java/de/plushnikov/intellij/plugin/processor/field/WitherFieldProcessor.java

@@ -118,10 +118,9 @@ private boolean validIsWitherUnique(@NotNull PsiField psiField, @NotNull final P
     return true;
   }
 
-  @SuppressWarnings("deprecation")
+  @SuppressWarnings({"unchecked"})
   public boolean validConstructor(@NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) {
-    if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, AllArgsConstructor.class, Value.class, lombok.experimental.Value.class,
-      Builder.class, lombok.experimental.Builder.class)) {
+    if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, AllArgsConstructor.class, Value.class, Builder.class)) {
       return true;
     }
 

src/main/java/de/plushnikov/intellij/plugin/processor/handler/BuilderHandler.java

@@ -53,7 +53,7 @@ public class BuilderHandler {
   private static final Collection<String> INVALID_ON_BUILDERS = Collections.unmodifiableSet(new HashSet<String>(Arrays.asList(
     Getter.class.getSimpleName(), Setter.class.getSimpleName(), Wither.class.getSimpleName(), ToString.class.getSimpleName(), EqualsAndHashCode.class.getSimpleName(),
     RequiredArgsConstructor.class.getSimpleName(), AllArgsConstructor.class.getSimpleName(), NoArgsConstructor.class.getSimpleName(),
-    Data.class.getSimpleName(), Value.class.getSimpleName(), lombok.experimental.Value.class.getSimpleName(), FieldDefaults.class.getSimpleName())));
+    Data.class.getSimpleName(), Value.class.getSimpleName(), FieldDefaults.class.getSimpleName())));
 
   private final ToStringProcessor toStringProcessor;
   private final NoArgsConstructorProcessor noArgsConstructorProcessor;
@@ -315,8 +315,7 @@ private Stream<BuilderInfo> createBuilderInfos(@NotNull PsiAnnotation psiAnnotat
       result = PsiClassUtil.collectClassFieldsIntern(psiClass).stream().map(BuilderInfo::fromPsiField)
         .filter(BuilderInfo::useForBuilder);
     }
-    return result.map(info -> info.withFluent(isFluentBuilder(psiAnnotation)))
-      .map(info -> info.withChain(isChainBuilder(psiAnnotation)));
+    return result;
   }
 
   public List<BuilderInfo> createBuilderInfos(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass,
@@ -522,16 +521,4 @@ private void addTypeParameters(PsiClass builderClass, PsiMethod psiMethod, Lombo
       methodBuilder.withTypeParameter(psiTypeParameter);
     }
   }
-
-  // These exist just to support the 'old' lombok.experimental.Builder, which had these properties. lombok.Builder no longer has them.
-  private static final String ANNOTATION_FLUENT = "fluent";
-  private static final String ANNOTATION_CHAIN = "chain";
-
-  private boolean isFluentBuilder(@NotNull PsiAnnotation psiAnnotation) {
-    return PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, ANNOTATION_FLUENT, true);
-  }
-
-  private boolean isChainBuilder(@NotNull PsiAnnotation psiAnnotation) {
-    return PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, ANNOTATION_CHAIN, true);
-  }
 }

src/main/java/de/plushnikov/intellij/plugin/processor/handler/EqualsAndHashCodeToStringHandler.java

@@ -220,7 +220,7 @@ private String buildAttributeNameString(boolean doNotUseGetters, @NotNull PsiFie
       final String getterName = LombokUtils.getGetterName(classField);
 
       final boolean hasGetter;
-      if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Data.class, Value.class, lombok.experimental.Value.class, Getter.class)) {
+      if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Data.class, Value.class, Getter.class)) {
         final PsiAnnotation getterLombokAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, Getter.class);
         hasGetter = null == getterLombokAnnotation || null != LombokProcessorUtil.getMethodModifier(getterLombokAnnotation);
       } else {

src/main/java/de/plushnikov/intellij/plugin/processor/method/AbstractMethodProcessor.java

@@ -27,6 +27,10 @@
  */
 public abstract class AbstractMethodProcessor extends AbstractProcessor implements MethodProcessor {
 
+  AbstractMethodProcessor(@NotNull Class<? extends PsiElement> supportedClass, @NotNull Class<? extends Annotation> supportedAnnotationClass) {
+    super(supportedClass, supportedAnnotationClass);
+  }
+
   AbstractMethodProcessor(@NotNull Class<? extends PsiElement> supportedClass, @NotNull Class<? extends Annotation> supportedAnnotationClass, Class<? extends Annotation>... equivalentAnnotationClasses) {
     super(supportedClass, supportedAnnotationClass, equivalentAnnotationClasses);
   }

src/main/java/de/plushnikov/intellij/plugin/processor/method/BuilderClassMethodProcessor.java

@@ -24,9 +24,8 @@ public class BuilderClassMethodProcessor extends AbstractMethodProcessor {
 
   private final BuilderHandler builderHandler;
 
-  @SuppressWarnings({"deprecation", "unchecked"})
   public BuilderClassMethodProcessor(@NotNull BuilderHandler builderHandler) {
-    super(PsiClass.class, Builder.class, lombok.experimental.Builder.class);
+    super(PsiClass.class, Builder.class);
     this.builderHandler = builderHandler;
   }
 

src/main/java/de/plushnikov/intellij/plugin/processor/method/BuilderMethodProcessor.java

@@ -24,9 +24,8 @@ public class BuilderMethodProcessor extends AbstractMethodProcessor {
 
   private final BuilderHandler builderHandler;
 
-  @SuppressWarnings({"deprecation", "unchecked"})
   public BuilderMethodProcessor(@NotNull BuilderHandler builderHandler) {
-    super(PsiMethod.class, Builder.class, lombok.experimental.Builder.class);
+    super(PsiMethod.class, Builder.class);
     this.builderHandler = builderHandler;
   }
 

src/main/java/de/plushnikov/intellij/plugin/processor/modifier/ValueModifierProcessor.java

@@ -30,7 +30,7 @@ public boolean isSupported(@NotNull PsiModifierList modifierList) {
 
     PsiClass searchableClass = PsiTreeUtil.getParentOfType(modifierList, PsiClass.class, true);
 
-    return null != searchableClass && PsiAnnotationSearchUtil.isAnnotatedWith(searchableClass, lombok.Value.class, lombok.experimental.Value.class);
+    return null != searchableClass && PsiAnnotationSearchUtil.isAnnotatedWith(searchableClass, lombok.Value.class);
   }
 
   @Override

src/test/java/de/plushnikov/intellij/plugin/processor/BuilderTest.java

@@ -37,10 +37,6 @@ public void setUp() throws Exception {
     doTest(true);
   }
 
-  public void testBuilder$BuilderChainAndFluent() {
-    doTest(true);
-  }
-
   public void testBuilder$BuilderWithAccessors() {
     doTest(true);
   }

src/test/java/de/plushnikov/intellij/plugin/processor/ValueTest.java

@@ -22,11 +22,7 @@ protected boolean shouldCompareCodeBlocks() {
     doTest(true);
   }
 
-  public void testValue$ValueExperimental() {
-    doTest(true);
-  }
-
-  public void testValue$ValueExperimentalStarImport() {
+  public void testValue$ValueStarImport() {
     doTest(true);
   }
 

testData/after/builder/BuilderExampleCustomized.java

@@ -19,12 +19,14 @@ public static class HelloWorldBuilder {
     HelloWorldBuilder() {
     }
 
-    public void setName(String name) {
+    public HelloWorldBuilder name(String name) {
       this.name = name;
+      return this;
     }
 
-    public void setAge(int age) {
+    public HelloWorldBuilder age(int age) {
       this.age = age;
+      return this;
     }
 
     public BuilderExampleCustomized execute() {