prettier-plugin-java 0.7.0 → 0.8.2

package/README.md

@@ -115,3 +115,45 @@ public class HelloWorld {
   }
 }
 ```
+
+## Options
+We added a custom option ```entrypoint``` in order to run prettier on code snippet.
+
+### Usage
+```prettier --write MyJava.java --entrypoint compilationUnit``` \
+[Here](https://github.com/jhipster/prettier-java/blob/master/packages/prettier-plugin-java/src/options.js) is the exhaustive list of all entrypoints.
+
+### Example
+MyJavaCode.java content:
+```java
+public void myfunction() {
+    mymethod.is().very().very().very().very().very().very().very().very().very().very().very().very().very().very().big();
+}
+```
+
+Run: \
+```prettier --write MyJavaCode.java --entrypoint classBodyDeclaration```
+
+Result:
+```java
+public void myfunction() {
+  mymethod
+    .is()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .very()
+    .big();
+}
+```
+

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "prettier-plugin-java",
-  "version": "0.7.0",
+  "version": "0.8.2",
   "description": "Prettier Java Plugin",
   "main": "src/index.js",
   "repository": "https://github.com/jhipster/prettier-java",
   "license": "Apache-2.0",
   "dependencies": {
-    "java-parser": "^0.7.0",
-    "lodash": "4.17.15",
-    "prettier": "1.18.2"
+    "java-parser": "0.8.2",
+    "lodash": "4.17.20",
+    "prettier": "2.1.1"
   },
   "scripts": {
     "test": "npm-run-all test:unit test:e2e-core",
@@ -19,6 +19,5 @@
     "test:e2e-jhipster2": "node scripts/clone-samples e2e-jhipster2 && mocha \"test/repository-test/jhipster-2-test.js\"",
     "test:all": "npm-run-all test test:e2e-jhipster1 test:e2e-jhipster2",
     "clone-samples": "node scripts/clone-samples.js"
-  },
-  "gitHead": "7cf83bececc20e6c658a8b07df5d8dd056a3711f"
+  }
 }

package/src/cst-printer.js

@@ -40,7 +40,7 @@ class CstPrettierPrinter extends BaseJavaCstVisitor {
       return elements.map(element => this.visit(element, params), this);
     };
 
-    this.getSingle = function(ctx) {
+    this.getSingle = function (ctx) {
       const ctxKeys = Object.keys(ctx);
       if (ctxKeys.length !== 1) {
         throw Error(
@@ -59,7 +59,7 @@ class CstPrettierPrinter extends BaseJavaCstVisitor {
       return singleElementValues[0];
     };
 
-    this.visitSingle = function(ctx, params) {
+    this.visitSingle = function (ctx, params) {
       const singleElement = this.getSingle(ctx);
       return this.visit(singleElement, params);
     };
@@ -68,7 +68,7 @@ class CstPrettierPrinter extends BaseJavaCstVisitor {
     // the prototype because we cannot user "super.visit" inside the function
     // below
     const orgVisit = this.visit;
-    this.visit = function(ctx, inParam) {
+    this.visit = function (ctx, inParam) {
       if (ctx === undefined) {
         // empty Doc
         return "";

package/src/index.js

@@ -2,6 +2,7 @@
 
 const parse = require("./parser");
 const print = require("./printer");
+const options = require("./options");
 
 const languages = [
   {
@@ -73,5 +74,6 @@ const printers = {
 module.exports = {
   languages,
   printers,
-  parsers
+  parsers,
+  options
 };

package/src/options.js

@@ -0,0 +1,239 @@
+"use strict";
+
+module.exports = {
+  entrypoint: {
+    type: "choice",
+    category: "Global",
+    default: "compilationUnit",
+    // sed -nr 's/.*\.RULE\(([^,]+),.*/\1/p' $(ls path/to/java-parser/rules/folder/*)
+    choices: [
+      { value: "arrayInitializer" },
+      { value: "variableInitializerList" },
+      { value: "block" },
+      { value: "blockStatements" },
+      { value: "blockStatement" },
+      { value: "localVariableDeclarationStatement" },
+      { value: "localVariableDeclaration" },
+      { value: "localVariableType" },
+      { value: "statement" },
+      { value: "statementWithoutTrailingSubstatement" },
+      { value: "emptyStatement" },
+      { value: "labeledStatement" },
+      { value: "expressionStatement" },
+      { value: "statementExpression" },
+      { value: "ifStatement" },
+      { value: "assertStatement" },
+      { value: "switchStatement" },
+      { value: "switchBlock" },
+      { value: "switchCase" },
+      { value: "switchLabel" },
+      { value: "enumConstantName" },
+      { value: "whileStatement" },
+      { value: "doStatement" },
+      { value: "forStatement" },
+      { value: "basicForStatement" },
+      { value: "forInit" },
+      { value: "forUpdate" },
+      { value: "statementExpressionList" },
+      { value: "enhancedForStatement" },
+      { value: "breakStatement" },
+      { value: "continueStatement" },
+      { value: "returnStatement" },
+      { value: "throwStatement" },
+      { value: "synchronizedStatement" },
+      { value: "tryStatement" },
+      { value: "catches" },
+      { value: "catchClause" },
+      { value: "catchFormalParameter" },
+      { value: "catchType" },
+      { value: "finally" },
+      { value: "tryWithResourcesStatement" },
+      { value: "resourceSpecification" },
+      { value: "resourceList" },
+      { value: "resource" },
+      { value: "resourceInit" },
+      { value: "variableAccess" },
+      { value: "isBasicForStatement" },
+      { value: "isLocalVariableDeclaration" },
+      { value: "classDeclaration" },
+      { value: "normalClassDeclaration" },
+      { value: "classModifier" },
+      { value: "typeParameters" },
+      { value: "typeParameterList" },
+      { value: "superclass" },
+      { value: "superinterfaces" },
+      { value: "interfaceTypeList" },
+      { value: "classBody" },
+      { value: "classBodyDeclaration" },
+      { value: "classMemberDeclaration" },
+      { value: "fieldDeclaration" },
+      { value: "fieldModifier" },
+      { value: "variableDeclaratorList" },
+      { value: "variableDeclarator" },
+      { value: "variableDeclaratorId" },
+      { value: "variableInitializer" },
+      { value: "unannType" },
+      { value: "unannPrimitiveType" },
+      { value: "unannReferenceType" },
+      { value: "unannClassOrInterfaceType" },
+      { value: "unannClassType" },
+      { value: "unannInterfaceType" },
+      { value: "unannTypeVariable" },
+      { value: "methodDeclaration" },
+      { value: "methodModifier" },
+      { value: "methodHeader" },
+      { value: "result" },
+      { value: "methodDeclarator" },
+      { value: "receiverParameter" },
+      { value: "formalParameterList" },
+      { value: "formalParameter" },
+      { value: "variableParaRegularParameter" },
+      { value: "variableArityParameter" },
+      { value: "variableModifier" },
+      { value: "throws" },
+      { value: "exceptionTypeList" },
+      { value: "exceptionType" },
+      { value: "methodBody" },
+      { value: "instanceInitializer" },
+      { value: "staticInitializer" },
+      { value: "constructorDeclaration" },
+      { value: "constructorModifier" },
+      { value: "constructorDeclarator" },
+      { value: "simpleTypeName" },
+      { value: "constructorBody" },
+      { value: "explicitConstructorInvocation" },
+      { value: "unqualifiedExplicitConstructorInvocation" },
+      { value: "qualifiedExplicitConstructorInvocation" },
+      { value: "enumDeclaration" },
+      { value: "enumBody" },
+      { value: "enumConstantList" },
+      { value: "enumConstant" },
+      { value: "enumConstantModifier" },
+      { value: "enumBodyDeclarations" },
+      { value: "isClassDeclaration" },
+      { value: "identifyClassBodyDeclarationType" },
+      { value: "isDims" },
+      { value: "constantExpression" },
+      { value: "expression" },
+      { value: "lambdaExpression" },
+      { value: "lambdaParameters" },
+      { value: "lambdaParametersWithBraces" },
+      { value: "lambdaParameterList" },
+      { value: "inferredLambdaParameterList" },
+      { value: "explicitLambdaParameterList" },
+      { value: "lambdaParameter" },
+      { value: "regularLambdaParameter" },
+      { value: "lambdaParameterType" },
+      { value: "lambdaBody" },
+      { value: "ternaryExpression" },
+      { value: "binaryExpression" },
+      { value: "unaryExpression" },
+      { value: "unaryExpressionNotPlusMinus" },
+      { value: "primary" },
+      { value: "primaryPrefix" },
+      { value: "primarySuffix" },
+      { value: "fqnOrRefType" },
+      { value: "fqnOrRefTypePartRest" },
+      { value: "fqnOrRefTypePartCommon" },
+      { value: "fqnOrRefTypePartFirst" },
+      { value: "parenthesisExpression" },
+      { value: "castExpression" },
+      { value: "primitiveCastExpression" },
+      { value: "referenceTypeCastExpression" },
+      { value: "newExpression" },
+      { value: "unqualifiedClassInstanceCreationExpression" },
+      { value: "classOrInterfaceTypeToInstantiate" },
+      { value: "typeArgumentsOrDiamond" },
+      { value: "diamond" },
+      { value: "methodInvocationSuffix" },
+      { value: "argumentList" },
+      { value: "arrayCreationExpression" },
+      { value: "arrayCreationDefaultInitSuffix" },
+      { value: "arrayCreationExplicitInitSuffix" },
+      { value: "dimExprs" },
+      { value: "dimExpr" },
+      { value: "classLiteralSuffix" },
+      { value: "arrayAccessSuffix" },
+      { value: "methodReferenceSuffix" },
+      { value: "identifyNewExpressionType" },
+      { value: "isLambdaExpression" },
+      { value: "isCastExpression" },
+      { value: "isPrimitiveCastExpression" },
+      { value: "isReferenceTypeCastExpression" },
+      { value: "isRefTypeInMethodRef" },
+      { value: "interfaceDeclaration" },
+      { value: "normalInterfaceDeclaration" },
+      { value: "interfaceModifier" },
+      { value: "extendsInterfaces" },
+      { value: "interfaceBody" },
+      { value: "interfaceMemberDeclaration" },
+      { value: "constantDeclaration" },
+      { value: "constantModifier" },
+      { value: "interfaceMethodDeclaration" },
+      { value: "interfaceMethodModifier" },
+      { value: "annotationTypeDeclaration" },
+      { value: "annotationTypeBody" },
+      { value: "annotationTypeMemberDeclaration" },
+      { value: "annotationTypeElementDeclaration" },
+      { value: "annotationTypeElementModifier" },
+      { value: "defaultValue" },
+      { value: "annotation" },
+      { value: "elementValuePairList" },
+      { value: "elementValuePair" },
+      { value: "elementValue" },
+      { value: "elementValueArrayInitializer" },
+      { value: "elementValueList" },
+      { value: "identifyInterfaceBodyDeclarationType" },
+      { value: "identifyAnnotationBodyDeclarationType" },
+      { value: "isSimpleElementValueAnnotation" },
+      { value: "literal" },
+      { value: "integerLiteral" },
+      { value: "floatingPointLiteral" },
+      { value: "booleanLiteral" },
+      { value: "moduleName" },
+      { value: "packageName" },
+      { value: "typeName" },
+      { value: "expressionName" },
+      { value: "methodName" },
+      { value: "packageOrTypeName" },
+      { value: "ambiguousName" },
+      { value: "compilationUnit" },
+      { value: "ordinaryCompilationUnit" },
+      { value: "modularCompilationUnit" },
+      { value: "packageDeclaration" },
+      { value: "packageModifier" },
+      { value: "importDeclaration" },
+      { value: "typeDeclaration" },
+      { value: "moduleDeclaration" },
+      { value: "moduleDirective" },
+      { value: "requiresModuleDirective" },
+      { value: "exportsModuleDirective" },
+      { value: "opensModuleDirective" },
+      { value: "usesModuleDirective" },
+      { value: "providesModuleDirective" },
+      { value: "requiresModifier" },
+      { value: "isModuleCompilationUnit" },
+      { value: "primitiveType" },
+      { value: "numericType" },
+      { value: "integralType" },
+      { value: "floatingPointType" },
+      { value: "referenceType" },
+      { value: "classOrInterfaceType" },
+      { value: "classType" },
+      { value: "interfaceType" },
+      { value: "typeVariable" },
+      { value: "dims" },
+      { value: "typeParameter" },
+      { value: "typeParameterModifier" },
+      { value: "typeBound" },
+      { value: "additionalBound" },
+      { value: "typeArguments" },
+      { value: "typeArgumentList" },
+      { value: "typeArgument" },
+      { value: "wildcard" },
+      { value: "wildcardBounds" }
+    ],
+    description:
+      "Prettify from the entrypoint, allowing to use prettier on snippet."
+  }
+};

package/src/parser.js

@@ -2,8 +2,8 @@
 
 const javaParser = require("java-parser");
 
-function parse(text) {
-  const cst = javaParser.parse(text);
+function parse(text, parsers, opts) {
+  const cst = javaParser.parse(text, opts.entrypoint);
   return cst;
 }
 

package/src/printer.js

@@ -25,7 +25,6 @@ function genericPrint(path, options, print) {
   //     printed: false
   //   }
   // ];
-
   return createPrettierDoc(node, options);
 }
 

package/src/printers/blocks-and-statements.js

@@ -81,7 +81,9 @@ class BlocksAndStatementPrettierVisitor {
     if (ctx.labeledStatement !== undefined) {
       const newLabelStatement = { ...ctx.labeledStatement[0] };
       const newColon = { ...ctx.labeledStatement[0].children.Colon[0] };
-      const newStatement = { ...ctx.labeledStatement[0].children.statement[0] };
+      const newStatement = {
+        ...ctx.labeledStatement[0].children.statement[0]
+      };
 
       const labeledStatementLeadingComments = [];
 

package/src/printers/classes.js

@@ -16,7 +16,10 @@ const {
 } = require("./printer-utils");
 const { concat, join, group, indent } = require("./prettier-builder");
 const { printTokenWithComments } = require("./comments/format-comments");
-const { hasLeadingLineComments } = require("./comments/comments-utils");
+const {
+  hasLeadingLineComments,
+  hasLeadingComments
+} = require("./comments/comments-utils");
 
 class ClassesPrettierVisitor {
   classDeclaration(ctx) {
@@ -674,15 +677,36 @@ class ClassesPrettierVisitor {
     const enumConstantList = this.visit(ctx.enumConstantList);
     const enumBodyDeclarations = this.visit(ctx.enumBodyDeclarations);
 
+    const hasEnumConstants = ctx.enumConstantList !== undefined;
+    const hasNoClassBodyDeclarations =
+      ctx.enumBodyDeclarations === undefined ||
+      ctx.enumBodyDeclarations[0].children.classBodyDeclaration === undefined;
+
+    // edge case: https://github.com/jhipster/prettier-java/issues/383
+    const handleEnumBodyDeclarationsLeadingComments =
+      !hasNoClassBodyDeclarations &&
+      hasLeadingComments(ctx.enumBodyDeclarations[0])
+        ? hardline
+        : "";
+
     let optionalComma;
-    if (this.prettierOptions.trailingComma !== "none") {
+    if (
+      hasEnumConstants &&
+      hasNoClassBodyDeclarations &&
+      this.prettierOptions.trailingComma !== "none"
+    ) {
       optionalComma = ctx.Comma ? ctx.Comma[0] : ",";
     } else {
       optionalComma = ctx.Comma ? { ...ctx.Comma[0], image: "" } : "";
     }
 
     return putIntoBraces(
-      rejectAndConcat([enumConstantList, optionalComma, enumBodyDeclarations]),
+      rejectAndConcat([
+        enumConstantList,
+        optionalComma,
+        handleEnumBodyDeclarationsLeadingComments,
+        enumBodyDeclarations
+      ]),
       hardline,
       ctx.LCurly[0],
       ctx.RCurly[0]

package/src/printers/expressions.js

@@ -2,7 +2,7 @@
 
 const _ = require("lodash");
 const { ifBreak, line, softline } = require("prettier").doc.builders;
-const { concat, group, indent } = require("./prettier-builder");
+const { concat, group, indent, dedent } = require("./prettier-builder");
 const { printTokenWithComments } = require("./comments/format-comments");
 const {
   handleCommentsBinaryExpression
@@ -288,34 +288,68 @@ class ExpressionsPrettierVisitor {
     const primaryPrefix = this.visit(ctx.primaryPrefix, {
       shouldBreakBeforeFirstMethodInvocation: countMethodInvocation > 1
     });
-    const primarySuffixes = this.mapVisit(ctx.primarySuffix);
 
     const suffixes = [];
 
     if (ctx.primarySuffix !== undefined) {
+      // edge case: https://github.com/jhipster/prettier-java/issues/381
+      let hasFirstInvocationArg = true;
+
+      if (
+        ctx.primarySuffix.length > 1 &&
+        ctx.primarySuffix[1].children.methodInvocationSuffix &&
+        Object.keys(
+          ctx.primarySuffix[1].children.methodInvocationSuffix[0].children
+        ).length === 2
+      ) {
+        hasFirstInvocationArg = false;
+      }
+
       if (
         ctx.primarySuffix[0].children.Dot !== undefined &&
         ctx.primaryPrefix[0].children.newExpression !== undefined
       ) {
         suffixes.push(softline);
       }
-      suffixes.push(primarySuffixes[0]);
+      suffixes.push(
+        this.visit(ctx.primarySuffix[0], {
+          shouldDedent:
+            // dedent when simple method invocation
+            countMethodInvocation !== 1 &&
+            // dedent when (chain) method invocation
+            ctx.primaryPrefix[0] &&
+            ctx.primaryPrefix[0].children.fqnOrRefType &&
+            !(
+              ctx.primaryPrefix[0].children.fqnOrRefType[0].children.Dot !==
+              undefined
+            ) &&
+            // indent when lambdaExpression
+            ctx.primarySuffix[0].children.methodInvocationSuffix &&
+            ctx.primarySuffix[0].children.methodInvocationSuffix[0].children
+              .argumentList &&
+            ctx.primarySuffix[0].children.methodInvocationSuffix[0].children
+              .argumentList[0].children.expression &&
+            ctx.primarySuffix[0].children.methodInvocationSuffix[0].children
+              .argumentList[0].children.expression[0].children
+              .lambdaExpression === undefined
+        })
+      );
 
-      for (let i = 1; i < primarySuffixes.length; i++) {
+      for (let i = 1; i < ctx.primarySuffix.length; i++) {
         if (
           ctx.primarySuffix[i].children.Dot !== undefined &&
           ctx.primarySuffix[i - 1].children.methodInvocationSuffix !== undefined
         ) {
           suffixes.push(softline);
         }
-        suffixes.push(primarySuffixes[i]);
+        suffixes.push(this.visit(ctx.primarySuffix[i]));
       }
 
       if (countMethodInvocation === 1) {
         return group(
           rejectAndConcat([
             primaryPrefix,
-            suffixes[0],
+            hasFirstInvocationArg ? suffixes[0] : indent(suffixes[0]),
             indent(rejectAndConcat(suffixes.slice(1)))
           ])
         );
@@ -335,7 +369,7 @@ class ExpressionsPrettierVisitor {
     return this.visitSingle(ctx, params);
   }
 
-  primarySuffix(ctx) {
+  primarySuffix(ctx, params) {
     if (ctx.Dot) {
       if (ctx.This) {
         return rejectAndConcat([ctx.Dot[0], ctx.This[0]]);
@@ -352,7 +386,7 @@ class ExpressionsPrettierVisitor {
         unqualifiedClassInstanceCreationExpression
       ]);
     }
-    return this.visitSingle(ctx);
+    return this.visitSingle(ctx, params);
   }
 
   fqnOrRefType(ctx, params) {
@@ -360,20 +394,40 @@ class ExpressionsPrettierVisitor {
     const fqnOrRefTypePartRest = this.mapVisit(ctx.fqnOrRefTypePartRest);
     const dims = this.visit(ctx.dims);
     const dots = ctx.Dot ? ctx.Dot : [];
+    const isMethodInvocation = ctx.Dot && ctx.Dot.length === 1;
 
     if (
       params !== undefined &&
       params.shouldBreakBeforeFirstMethodInvocation === true
     ) {
-      return rejectAndConcat([
-        indent(
-          rejectAndJoin(concat([softline, dots[0]]), [
-            fqnOrRefTypePartFirst,
-            rejectAndJoinSeps(dots.slice(1), fqnOrRefTypePartRest),
+      // when fqnOrRefType is a method call from an object
+      if (isMethodInvocation) {
+        return rejectAndConcat([
+          indent(
+            rejectAndJoin(concat([softline, dots[0]]), [
+              fqnOrRefTypePartFirst,
+              rejectAndJoinSeps(dots.slice(1), fqnOrRefTypePartRest),
+              dims
+            ])
+          )
+        ]);
+        // otherwise it is a fully qualified name but we need to exclude when it is just a method call
+      } else if (ctx.Dot) {
+        return indent(
+          rejectAndConcat([
+            rejectAndJoinSeps(dots.slice(0, dots.length - 1), [
+              fqnOrRefTypePartFirst,
+              ...fqnOrRefTypePartRest.slice(0, fqnOrRefTypePartRest.length - 1)
+            ]),
+            softline,
+            rejectAndConcat([
+              dots[dots.length - 1],
+              fqnOrRefTypePartRest[fqnOrRefTypePartRest.length - 1]
+            ]),
             dims
           ])
-        )
-      ]);
+        );
+      }
     }
 
     return rejectAndConcat([
@@ -532,12 +586,17 @@ class ExpressionsPrettierVisitor {
     return concat([ctx.Less[0], ctx.Greater[0]]);
   }
 
-  methodInvocationSuffix(ctx) {
+  methodInvocationSuffix(ctx, params) {
     if (ctx.argumentList === undefined) {
       return rejectAndConcat([ctx.LBrace[0], ctx.RBrace[0]]);
     }
 
     const argumentList = this.visit(ctx.argumentList);
+    if (params && params.shouldDedent) {
+      return dedent(
+        putIntoBraces(argumentList, softline, ctx.LBrace[0], ctx.RBrace[0])
+      );
+    }
     return putIntoBraces(argumentList, softline, ctx.LBrace[0], ctx.RBrace[0]);
   }
 

package/src/printers/printer-utils.js

@@ -334,8 +334,7 @@ function needLineClassBodyDeclaration(declaration) {
       classMemberDeclaration.children.fieldDeclaration[0];
     if (
       fieldDeclaration.children.fieldModifier !== undefined &&
-      fieldDeclaration.children.fieldModifier[0].children.annotation !==
-        undefined
+      hasAnnotation(fieldDeclaration.children.fieldModifier)
     ) {
       return true;
     }
@@ -352,8 +351,7 @@ function needLineInterfaceMemberDeclaration(declaration) {
     const constantDeclaration = declaration.children.constantDeclaration[0];
     if (
       constantDeclaration.children.constantModifier !== undefined &&
-      constantDeclaration.children.constantModifier[0].children.annotation !==
-        undefined
+      hasAnnotation(constantDeclaration.children.constantModifier)
     ) {
       return true;
     }
@@ -364,8 +362,9 @@ function needLineInterfaceMemberDeclaration(declaration) {
     if (
       interfaceMethodDeclaration.children.interfaceMethodModifier !==
         undefined &&
-      interfaceMethodDeclaration.children.interfaceMethodModifier[0].children
-        .annotation !== undefined
+      hasNonTrailingAnnotation(
+        interfaceMethodDeclaration.children.interfaceMethodModifier
+      )
     ) {
       return true;
     }
@@ -391,6 +390,32 @@ function isInterfaceMemberASemicolon(interfaceMemberDeclaration) {
   return interfaceMemberDeclaration.children.Semicolon !== undefined;
 }
 
+function hasAnnotation(modifiers) {
+  return modifiers.some(modifier => modifier.children.annotation !== undefined);
+}
+
+/**
+ * Return true if there is a method modifier that does not come after all other modifiers
+ * It is useful to know if sortModifiers will add an annotation before other modifiers
+ *
+ * @param methodModifiers
+ * @returns {boolean}
+ */
+function hasNonTrailingAnnotation(methodModifiers) {
+  const firstAnnotationIndex = methodModifiers.findIndex(
+    modifier => modifier.children.annotation !== undefined
+  );
+  const lastNonAnnotationIndex = _.findLastIndex(
+    methodModifiers,
+    modifier => modifier.children.annotation === undefined
+  );
+
+  return (
+    firstAnnotationIndex < lastNonAnnotationIndex ||
+    lastNonAnnotationIndex === -1
+  );
+}
+
 function getClassBodyDeclarationsSeparator(classBodyDeclarationContext) {
   return getDeclarationsSeparator(
     classBodyDeclarationContext,
@@ -625,7 +650,7 @@ function isUniqueMethodInvocation(primarySuffixes) {
 
 function printArrayList({ list, extraComma, LCurly, RCurly, trailingComma }) {
   let optionalComma;
-  if (trailingComma !== "none") {
+  if (trailingComma !== "none" && list !== "") {
     optionalComma = extraComma
       ? ifBreak(extraComma[0], { ...extraComma[0], image: "" })
       : ifBreak(",", "");

package/LICENSE

@@ -1,204 +0,0 @@
-
-    Copyright 2013-2020 Shahar Soel and the respective prettier-java contributors
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-    1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-    2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-    3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-    4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-    5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-    6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-    7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-    8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-    9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-    END OF TERMS AND CONDITIONS
-
-    APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-    Copyright [yyyy] [name of copyright owner]
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.