From 6aeb5bc54e4e24c2921b901fe8ffd7936b08cc49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Dessoude?= Date: Mon, 9 Sep 2019 16:35:30 +0200 Subject: [PATCH 1/5] improve localVariableDeclaration rendering --- .../src/printers/blocks-and-statements.js | 2 +- .../src/printers/classes.js | 84 +++++++++++++++++-- .../src/printers/expressions.js | 52 ++++++++++-- 3 files changed, 124 insertions(+), 14 deletions(-) diff --git a/packages/prettier-plugin-java/src/printers/blocks-and-statements.js b/packages/prettier-plugin-java/src/printers/blocks-and-statements.js index 5480c526f..cb4fa91e3 100644 --- a/packages/prettier-plugin-java/src/printers/blocks-and-statements.js +++ b/packages/prettier-plugin-java/src/printers/blocks-and-statements.js @@ -325,7 +325,7 @@ class BlocksAndStatementPrettierVisitor { returnStatement(ctx) { if (ctx.expression) { - const expression = this.visit(ctx.expression); + const expression = this.visit(ctx.expression, { addParenthesis: true }); return rejectAndConcat([ concat([ctx.Return[0], " "]), diff --git a/packages/prettier-plugin-java/src/printers/classes.js b/packages/prettier-plugin-java/src/printers/classes.js index d5ab13c08..6f29c27dd 100644 --- a/packages/prettier-plugin-java/src/printers/classes.js +++ b/packages/prettier-plugin-java/src/printers/classes.js @@ -194,11 +194,85 @@ class ClassesPrettierVisitor { const variableDeclaratorId = this.visit(ctx.variableDeclaratorId); if (ctx.Equals) { const variableInitializer = this.visit(ctx.variableInitializer); - return rejectAndJoin(" ", [ - variableDeclaratorId, - ctx.Equals[0], - variableInitializer - ]); + + // Array Initialisation + if (ctx.variableInitializer[0].children.arrayInitializer !== undefined) { + return rejectAndJoin(" ", [ + variableDeclaratorId, + ctx.Equals[0], + variableInitializer + ]); + } + + // Ternary Expression + if ( + ctx.variableInitializer[0].children.expression[0].children + .ternaryExpression !== undefined && + ctx.variableInitializer[0].children.expression[0].children + .ternaryExpression[0].children.QuestionMark !== undefined + ) { + return rejectAndJoin(" ", [ + variableDeclaratorId, + ctx.Equals[0], + variableInitializer + ]); + } + + if ( + ctx.variableInitializer[0].children.expression[0].children + .ternaryExpression !== undefined + ) { + const firstPrimary = + ctx.variableInitializer[0].children.expression[0].children + .ternaryExpression[0].children.binaryExpression[0].children + .unaryExpression[0].children.primary[0]; + + // Cast Expression + if ( + firstPrimary.children.primaryPrefix[0].children.castExpression !== + undefined + ) { + return rejectAndJoin(" ", [ + variableDeclaratorId, + ctx.Equals[0], + variableInitializer + ]); + } + + // New Expression + if ( + firstPrimary.children.primaryPrefix[0].children.newExpression !== + undefined + ) { + return rejectAndJoin(" ", [ + variableDeclaratorId, + ctx.Equals[0], + variableInitializer + ]); + } + + // Method Invocation + if ( + firstPrimary.children.primarySuffix !== undefined && + firstPrimary.children.primarySuffix[0].children + .methodInvocationSuffix !== undefined + ) { + return rejectAndJoin(" ", [ + variableDeclaratorId, + ctx.Equals[0], + variableInitializer + ]); + } + } + + return group( + indent( + rejectAndJoin(line, [ + rejectAndJoin(" ", [variableDeclaratorId, ctx.Equals[0]]), + variableInitializer + ]) + ) + ); } return variableDeclaratorId; } diff --git a/packages/prettier-plugin-java/src/printers/expressions.js b/packages/prettier-plugin-java/src/printers/expressions.js index ee7004a8b..62ae6f542 100644 --- a/packages/prettier-plugin-java/src/printers/expressions.js +++ b/packages/prettier-plugin-java/src/printers/expressions.js @@ -2,7 +2,7 @@ /* eslint-disable no-unused-vars */ const _ = require("lodash"); -const { line, softline } = require("prettier").doc.builders; +const { ifBreak, line, softline } = require("prettier").doc.builders; const { concat, group, @@ -27,8 +27,8 @@ class ExpressionsPrettierVisitor { return this.visitSingle(ctx); } - expression(ctx) { - return this.visitSingle(ctx); + expression(ctx, params) { + return this.visitSingle(ctx, params); } lambdaExpression(ctx) { @@ -128,8 +128,8 @@ class ExpressionsPrettierVisitor { return this.visitSingle(ctx); } - ternaryExpression(ctx) { - const binaryExpression = this.visit(ctx.binaryExpression); + ternaryExpression(ctx, params) { + const binaryExpression = this.visit(ctx.binaryExpression, params); if (ctx.QuestionMark) { const expression1 = this.visit(ctx.expression[0]); const expression2 = this.visit(ctx.expression[1]); @@ -153,10 +153,11 @@ class ExpressionsPrettierVisitor { return binaryExpression; } - binaryExpression(ctx) { + binaryExpression(ctx, params) { const referenceType = this.mapVisit(ctx.referenceType); const expression = this.mapVisit(ctx.expression); const unaryExpression = this.mapVisit(ctx.unaryExpression); + const unaryExpression2 = this.mapVisit(ctx.unaryExpression); const { groupsOfOperator, @@ -165,6 +166,10 @@ class ExpressionsPrettierVisitor { const segmentsSplittedByBinaryOperator = []; let currentSegment = []; + if (groupsOfOperator.length === 1 && groupsOfOperator[0].length === 0) { + return unaryExpression.shift(); + } + groupsOfOperator.forEach(subgroup => { currentSegment = [unaryExpression.shift()]; for (let i = 0; i < subgroup.length; i++) { @@ -207,9 +212,40 @@ class ExpressionsPrettierVisitor { group(rejectAndJoin(" ", currentSegment)) ); }); - if (groupsOfOperator.length === 0) { - return unaryExpression.shift(); + + if (params !== undefined && params.addParenthesis) { + // console.log( + // JSON.stringify( + // ctx, + // (key, value) => { if (key !== 'START_CHARS_HINT' && key !== "location") return value; }, + // 2 + // ) + // ); + // console.log( + // JSON.stringify( + // unaryExpression2, + // (key, value) => { if (key !== 'START_CHARS_HINT' && key !== "location") return value; }, + // 2 + // ) + // ); + return group( + concat([ + ifBreak("(", ""), + indent( + concat([ + softline, + rejectAndJoinSeps( + sortedBinaryOperators.map(elt => concat([" ", elt, line])), + segmentsSplittedByBinaryOperator + ) + ]) + ), + softline, + ifBreak(")") + ]) + ); } + return group( rejectAndJoinSeps( sortedBinaryOperators.map(elt => concat([" ", elt, line])), From f68bac3199ac05a700f5b94390b7ab4af7b1b7f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Dessoude?= Date: Tue, 10 Sep 2019 16:13:06 +0200 Subject: [PATCH 2/5] improve primary rendering --- .../prettier-plugin-java/src/cst-printer.js | 4 +- .../src/printers/expressions.js | 96 ++++++++++--------- .../src/printers/printer-utils.js | 23 ++++- .../test/unit-test/member_chain/_output.java | 3 +- .../multiple-ignore/_output.java | 3 +- .../test/unit-test/variables/_input.java | 19 ++++ .../test/unit-test/variables/_output.java | 53 +++++++++- 7 files changed, 147 insertions(+), 54 deletions(-) diff --git a/packages/prettier-plugin-java/src/cst-printer.js b/packages/prettier-plugin-java/src/cst-printer.js index 68f93886d..d061622b1 100644 --- a/packages/prettier-plugin-java/src/cst-printer.js +++ b/packages/prettier-plugin-java/src/cst-printer.js @@ -32,13 +32,13 @@ class CstPrettierPrinter extends BaseJavaCstVisitor { // TODO: this methods should be defined on the prototype // defining as instance members **after** the validations to avoid // false positive errors on redundant methods - this.mapVisit = elements => { + this.mapVisit = (elements, params) => { if (elements === undefined) { // TODO: can optimize this by returning an immutable empty array singleton. return []; } - return elements.map(this.visit, this); + return elements.map(element => this.visit(element, params), this); }; this.getSingle = function(ctx) { diff --git a/packages/prettier-plugin-java/src/printers/expressions.js b/packages/prettier-plugin-java/src/printers/expressions.js index 62ae6f542..d45bd4919 100644 --- a/packages/prettier-plugin-java/src/printers/expressions.js +++ b/packages/prettier-plugin-java/src/printers/expressions.js @@ -2,7 +2,7 @@ /* eslint-disable no-unused-vars */ const _ = require("lodash"); -const { ifBreak, line, softline } = require("prettier").doc.builders; +const { ifBreak, line, softline, hardline } = require("prettier").doc.builders; const { concat, group, @@ -19,7 +19,8 @@ const { isExplicitLambdaParameter, putIntoBraces, separateTokensIntoGroups, - isShiftOperator + isShiftOperator, + isUniqueMethodInvocation } = require("./printer-utils"); class ExpressionsPrettierVisitor { @@ -157,7 +158,6 @@ class ExpressionsPrettierVisitor { const referenceType = this.mapVisit(ctx.referenceType); const expression = this.mapVisit(ctx.expression); const unaryExpression = this.mapVisit(ctx.unaryExpression); - const unaryExpression2 = this.mapVisit(ctx.unaryExpression); const { groupsOfOperator, @@ -214,20 +214,6 @@ class ExpressionsPrettierVisitor { }); if (params !== undefined && params.addParenthesis) { - // console.log( - // JSON.stringify( - // ctx, - // (key, value) => { if (key !== 'START_CHARS_HINT' && key !== "location") return value; }, - // 2 - // ) - // ); - // console.log( - // JSON.stringify( - // unaryExpression2, - // (key, value) => { if (key !== 'START_CHARS_HINT' && key !== "location") return value; }, - // 2 - // ) - // ); return group( concat([ ifBreak("(", ""), @@ -287,52 +273,56 @@ class ExpressionsPrettierVisitor { } primary(ctx) { - const primaryPrefix = this.visit(ctx.primaryPrefix); + const countMethodInvocation = isUniqueMethodInvocation(ctx.primarySuffix); + + const primaryPrefix = this.visit(ctx.primaryPrefix, { + shouldBreak: countMethodInvocation > 1 + }); const primarySuffixes = this.mapVisit(ctx.primarySuffix); const suffixes = []; - let addIndent = false; - for (let i = 0; i < primarySuffixes.length; i++) { - if (ctx.primarySuffix[i].children.Dot !== undefined) { - suffixes.push(indent(softline), primarySuffixes[i]); - addIndent = true; - } else if ( - ctx.primarySuffix[i].children.methodInvocationSuffix === undefined + + if (ctx.primarySuffix !== undefined) { + if ( + ctx.primarySuffix[0].children.Dot !== undefined && + ctx.primaryPrefix[0].children.newExpression !== undefined ) { - suffixes.push(softline, primarySuffixes[i]); - } else { - if (addIndent) { - suffixes.push(indent(primarySuffixes[i])); - addIndent = false; - } else { - suffixes.push(primarySuffixes[i]); + suffixes.push(softline); + } + suffixes.push(primarySuffixes[0]); + + for (let i = 1; i < primarySuffixes.length; i++) { + if ( + ctx.primarySuffix[i].children.Dot !== undefined && + ctx.primarySuffix[i - 1].children.methodInvocationSuffix !== undefined + ) { + suffixes.push(softline); } + suffixes.push(primarySuffixes[i]); } - } - let firstSeparator = suffixes.shift(); - if ( - ctx.primaryPrefix[0].children.This !== undefined || - firstSeparator === undefined - ) { - firstSeparator = ""; + if (countMethodInvocation === 1) { + return group( + rejectAndConcat([ + primaryPrefix, + suffixes[0], + indent(rejectAndConcat(suffixes.slice(1))) + ]) + ); + } } return group( - rejectAndConcat([ - primaryPrefix, - firstSeparator, - rejectAndConcat(suffixes) - ]) + rejectAndConcat([primaryPrefix, indent(rejectAndConcat(suffixes))]) ); } - primaryPrefix(ctx) { + primaryPrefix(ctx, params) { if (ctx.This || ctx.Void || ctx.Boolean) { return getImageWithComments(this.getSingle(ctx)); } - return this.visitSingle(ctx); + return this.visitSingle(ctx, params); } primarySuffix(ctx) { @@ -355,10 +345,22 @@ class ExpressionsPrettierVisitor { return this.visitSingle(ctx); } - fqnOrRefType(ctx) { + fqnOrRefType(ctx, params) { const fqnOrRefTypePart = this.mapVisit(ctx.fqnOrRefTypePart); const dims = this.visit(ctx.dims); const dots = ctx.Dot ? ctx.Dot : []; + + if (params !== undefined && params.shouldBreak === true) { + return rejectAndConcat([ + indent( + rejectAndJoin(concat([softline, dots[0]]), [ + fqnOrRefTypePart[0], + rejectAndJoinSeps(dots.slice(1), fqnOrRefTypePart.slice(1)), + dims + ]) + ) + ]); + } return rejectAndConcat([rejectAndJoinSeps(dots, fqnOrRefTypePart), dims]); } diff --git a/packages/prettier-plugin-java/src/printers/printer-utils.js b/packages/prettier-plugin-java/src/printers/printer-utils.js index 5840da09d..36e014eb2 100644 --- a/packages/prettier-plugin-java/src/printers/printer-utils.js +++ b/packages/prettier-plugin-java/src/printers/printer-utils.js @@ -583,6 +583,25 @@ function compareFqn(packageOrTypeNameFirst, packageOrTypeNameSecond) { return 0; } +function isUniqueMethodInvocation(primarySuffixes) { + if (primarySuffixes === undefined) { + return 0; + } + + let count = 0; + primarySuffixes.forEach(primarySuffix => { + if (primarySuffix.children.methodInvocationSuffix !== undefined) { + count++; + + if (count > 1) { + return 2; + } + } + }); + + return count; +} + module.exports = { buildFqn, reject, @@ -607,7 +626,9 @@ module.exports = { isShiftOperator, retrieveNodesToken, buildOriginalText, + isStatementEmptyStatement, getCSTNodeStartEndToken, isStatementEmptyStatement, - sortImports + sortImports, + isUniqueMethodInvocation }; diff --git a/packages/prettier-plugin-java/test/unit-test/member_chain/_output.java b/packages/prettier-plugin-java/test/unit-test/member_chain/_output.java index 473310853..7d5c7a788 100644 --- a/packages/prettier-plugin-java/test/unit-test/member_chain/_output.java +++ b/packages/prettier-plugin-java/test/unit-test/member_chain/_output.java @@ -43,7 +43,8 @@ public void doSomethingLongNew2() { } public void doSomethingLongStatic() { - return Object.something() + return Object + .something() .more() .and() .that() diff --git a/packages/prettier-plugin-java/test/unit-test/prettier-ignore/multiple-ignore/_output.java b/packages/prettier-plugin-java/test/unit-test/prettier-ignore/multiple-ignore/_output.java index c175b2818..b99e1abb8 100644 --- a/packages/prettier-plugin-java/test/unit-test/prettier-ignore/multiple-ignore/_output.java +++ b/packages/prettier-plugin-java/test/unit-test/prettier-ignore/multiple-ignore/_output.java @@ -14,7 +14,8 @@ public void myPrettierIgnoreMethod( int param10 ) { for (int i = 0; i < param1; i++) { - param2.methodcall() + param2 + .methodcall() .methodcall() .methodcall() .methodcall() diff --git a/packages/prettier-plugin-java/test/unit-test/variables/_input.java b/packages/prettier-plugin-java/test/unit-test/variables/_input.java index d6297e174..86e2788e5 100644 --- a/packages/prettier-plugin-java/test/unit-test/variables/_input.java +++ b/packages/prettier-plugin-java/test/unit-test/variables/_input.java @@ -73,4 +73,23 @@ public boolean localVariableDeclarationWhichDoNotBreak() { BackupStatus lastStatus = value; } + public void breakVariables() { + Obj newObject = new Object().something().more().and().that().as().well().but().not().something(); + + Object.test.creation thisObject = classWithName.invocationOne().invocationTwo(); + + Object.test.creation thisObject1 = classWithName.invocationOne(argument1, argument2, argument3); + + Object.test.creation thisObject2 = classWithName.invocationOne(argument1, argument2, argument3).invocationTwo(); + + Object.test.creation thisObject3 = classWithName.invocationOne().invocationTwo(argument1, argument2, argument3); + + Object.test.creation thisObject4 = classWithName.invocationOne(argument1, argument2, argument3).invocationTwo(argument1, argument2); + + Object.test.creation thisObject5 = classWithName.invocationOne(argument1WithAVeryVeryVeryVeryLongName, argument2, argument3).attributeOne.attributeTwo + .invocationTwo(argument1, argument2).attributeThree.invocationThree(); + + Object.test.creation thisObject6 = classWithName.invocationOne(argument1, argument2, + argument3).attributeOne.attributeTwo.invocationTwo(argument1, argument2).attributeThree.invocationThree(); + } } diff --git a/packages/prettier-plugin-java/test/unit-test/variables/_output.java b/packages/prettier-plugin-java/test/unit-test/variables/_output.java index bf29079ee..457a26db5 100644 --- a/packages/prettier-plugin-java/test/unit-test/variables/_output.java +++ b/packages/prettier-plugin-java/test/unit-test/variables/_output.java @@ -37,8 +37,8 @@ public class Variables { private Range creator1 = this.dateRangeField.new Range(from, to); private Range creator2 = this.dateRangeField.new Range(from, to); - private Range creator3 = this.dateRangeField - .new Range<>(from, to); + private Range creator3 = + this.dateRangeField.new Range<>(from, to); private Range creator3 = new Range<>(from, to); private int hexLiteral = 0x0000; @@ -97,4 +97,53 @@ public boolean localVariableDeclarationWhichDoNotBreak() { BackupStatus lastStatus = value; } + + public void breakVariables() { + Obj newObject = new Object() + .something() + .more() + .and() + .that() + .as() + .well() + .but() + .not() + .something(); + + Object.test.creation thisObject = classWithName + .invocationOne() + .invocationTwo(); + + Object.test.creation thisObject1 = classWithName.invocationOne( + argument1, + argument2, + argument3 + ); + + Object.test.creation thisObject2 = classWithName + .invocationOne(argument1, argument2, argument3) + .invocationTwo(); + + Object.test.creation thisObject3 = classWithName + .invocationOne() + .invocationTwo(argument1, argument2, argument3); + + Object.test.creation thisObject4 = classWithName + .invocationOne(argument1, argument2, argument3) + .invocationTwo(argument1, argument2); + + Object.test.creation thisObject5 = classWithName + .invocationOne( + argument1WithAVeryVeryVeryVeryLongName, + argument2, + argument3 + ) + .attributeOne.attributeTwo.invocationTwo(argument1, argument2) + .attributeThree.invocationThree(); + + Object.test.creation thisObject6 = classWithName + .invocationOne(argument1, argument2, argument3) + .attributeOne.attributeTwo.invocationTwo(argument1, argument2) + .attributeThree.invocationThree(); + } } From 06d6d40cb6701dd12d4cb192b29c475051b20efc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Dessoude?= Date: Thu, 5 Sep 2019 16:42:43 +0200 Subject: [PATCH 3/5] fix mutlines comments --- packages/prettier-plugin-java/src/printers/printer-utils.js | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/packages/prettier-plugin-java/src/printers/printer-utils.js b/packages/prettier-plugin-java/src/printers/printer-utils.js index 36e014eb2..482c85dee 100644 --- a/packages/prettier-plugin-java/src/printers/printer-utils.js +++ b/packages/prettier-plugin-java/src/printers/printer-utils.js @@ -602,6 +602,10 @@ function isUniqueMethodInvocation(primarySuffixes) { return count; } +function isStatementEmptyStatement(statement) { + return statement.type === "concat" && statement.parts[0] === ";"; +} + module.exports = { buildFqn, reject, From 04c966106f85b4a2fbb60c1af64c4771027e3dc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Dessoude?= Date: Tue, 10 Sep 2019 17:00:39 +0200 Subject: [PATCH 4/5] cleanup --- .../src/printers/blocks-and-statements.js | 4 +++- .../src/printers/classes.js | 19 ++++++------------- .../src/printers/expressions.js | 9 ++++++--- .../src/printers/printer-utils.js | 5 ----- 4 files changed, 15 insertions(+), 22 deletions(-) diff --git a/packages/prettier-plugin-java/src/printers/blocks-and-statements.js b/packages/prettier-plugin-java/src/printers/blocks-and-statements.js index cb4fa91e3..6698b7971 100644 --- a/packages/prettier-plugin-java/src/printers/blocks-and-statements.js +++ b/packages/prettier-plugin-java/src/printers/blocks-and-statements.js @@ -325,7 +325,9 @@ class BlocksAndStatementPrettierVisitor { returnStatement(ctx) { if (ctx.expression) { - const expression = this.visit(ctx.expression, { addParenthesis: true }); + const expression = this.visit(ctx.expression, { + addParenthesisToWrapStatement: true + }); return rejectAndConcat([ concat([ctx.Return[0], " "]), diff --git a/packages/prettier-plugin-java/src/printers/classes.js b/packages/prettier-plugin-java/src/printers/classes.js index 6f29c27dd..3f20260c2 100644 --- a/packages/prettier-plugin-java/src/printers/classes.js +++ b/packages/prettier-plugin-java/src/printers/classes.js @@ -195,21 +195,14 @@ class ClassesPrettierVisitor { if (ctx.Equals) { const variableInitializer = this.visit(ctx.variableInitializer); - // Array Initialisation - if (ctx.variableInitializer[0].children.arrayInitializer !== undefined) { - return rejectAndJoin(" ", [ - variableDeclaratorId, - ctx.Equals[0], - variableInitializer - ]); - } - - // Ternary Expression if ( - ctx.variableInitializer[0].children.expression[0].children + // Array Initialisation + ctx.variableInitializer[0].children.arrayInitializer !== undefined || + // Ternary Expression + (ctx.variableInitializer[0].children.expression[0].children .ternaryExpression !== undefined && - ctx.variableInitializer[0].children.expression[0].children - .ternaryExpression[0].children.QuestionMark !== undefined + ctx.variableInitializer[0].children.expression[0].children + .ternaryExpression[0].children.QuestionMark !== undefined) ) { return rejectAndJoin(" ", [ variableDeclaratorId, diff --git a/packages/prettier-plugin-java/src/printers/expressions.js b/packages/prettier-plugin-java/src/printers/expressions.js index d45bd4919..a279aa24b 100644 --- a/packages/prettier-plugin-java/src/printers/expressions.js +++ b/packages/prettier-plugin-java/src/printers/expressions.js @@ -213,7 +213,7 @@ class ExpressionsPrettierVisitor { ); }); - if (params !== undefined && params.addParenthesis) { + if (params !== undefined && params.addParenthesisToWrapStatement) { return group( concat([ ifBreak("(", ""), @@ -276,7 +276,7 @@ class ExpressionsPrettierVisitor { const countMethodInvocation = isUniqueMethodInvocation(ctx.primarySuffix); const primaryPrefix = this.visit(ctx.primaryPrefix, { - shouldBreak: countMethodInvocation > 1 + shouldBreakBeforeFirstMethodInvocation: countMethodInvocation > 1 }); const primarySuffixes = this.mapVisit(ctx.primarySuffix); @@ -350,7 +350,10 @@ class ExpressionsPrettierVisitor { const dims = this.visit(ctx.dims); const dots = ctx.Dot ? ctx.Dot : []; - if (params !== undefined && params.shouldBreak === true) { + if ( + params !== undefined && + params.shouldBreakBeforeFirstMethodInvocation === true + ) { return rejectAndConcat([ indent( rejectAndJoin(concat([softline, dots[0]]), [ diff --git a/packages/prettier-plugin-java/src/printers/printer-utils.js b/packages/prettier-plugin-java/src/printers/printer-utils.js index 482c85dee..79b5265ca 100644 --- a/packages/prettier-plugin-java/src/printers/printer-utils.js +++ b/packages/prettier-plugin-java/src/printers/printer-utils.js @@ -602,10 +602,6 @@ function isUniqueMethodInvocation(primarySuffixes) { return count; } -function isStatementEmptyStatement(statement) { - return statement.type === "concat" && statement.parts[0] === ";"; -} - module.exports = { buildFqn, reject, @@ -630,7 +626,6 @@ module.exports = { isShiftOperator, retrieveNodesToken, buildOriginalText, - isStatementEmptyStatement, getCSTNodeStartEndToken, isStatementEmptyStatement, sortImports, From 638717ead6fa99639f36ee12300a372f016d2b83 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Dessoude?= Date: Wed, 25 Sep 2019 14:23:56 +0200 Subject: [PATCH 5/5] fix stable reformatting in return statements --- .../src/printers/blocks-and-statements.js | 3 +- .../src/printers/expressions.js | 21 ++++++++++---- .../test/unit-test/return/_input.java | 20 +++++++++++++ .../test/unit-test/return/_output.java | 28 +++++++++++++++++++ 4 files changed, 66 insertions(+), 6 deletions(-) diff --git a/packages/prettier-plugin-java/src/printers/blocks-and-statements.js b/packages/prettier-plugin-java/src/printers/blocks-and-statements.js index 6698b7971..13d8f0bc5 100644 --- a/packages/prettier-plugin-java/src/printers/blocks-and-statements.js +++ b/packages/prettier-plugin-java/src/printers/blocks-and-statements.js @@ -326,7 +326,8 @@ class BlocksAndStatementPrettierVisitor { returnStatement(ctx) { if (ctx.expression) { const expression = this.visit(ctx.expression, { - addParenthesisToWrapStatement: true + addParenthesisToWrapStatement: true, + shouldIndentBinaryOperationInExpression: false }); return rejectAndConcat([ diff --git a/packages/prettier-plugin-java/src/printers/expressions.js b/packages/prettier-plugin-java/src/printers/expressions.js index a279aa24b..5ab1e0b65 100644 --- a/packages/prettier-plugin-java/src/printers/expressions.js +++ b/packages/prettier-plugin-java/src/printers/expressions.js @@ -203,9 +203,18 @@ class ExpressionsPrettierVisitor { ); i += 2; } else if (matchCategory(token, "'BinaryOperator'")) { - currentSegment.push( - indent(rejectAndJoin(line, [token, unaryExpression.shift()])) - ); + const binaryOperation = rejectAndJoin(line, [ + token, + unaryExpression.shift() + ]); + if ( + params !== undefined && + !params.shouldIndentBinaryOperationInExpression + ) { + currentSegment.push(binaryOperation); + } else { + currentSegment.push(indent(binaryOperation)); + } } } segmentsSplittedByBinaryOperator.push( @@ -416,8 +425,10 @@ class ExpressionsPrettierVisitor { } parenthesisExpression(ctx) { - const expression = this.visit(ctx.expression); - return rejectAndConcat([ctx.LBrace[0], expression, ctx.RBrace[0]]); + const expression = this.visit(ctx.expression, { + shouldIndentBinaryOperationInExpression: false + }); + return putIntoBraces(expression, softline, ctx.LBrace[0], ctx.RBrace[0]); } castExpression(ctx) { diff --git a/packages/prettier-plugin-java/test/unit-test/return/_input.java b/packages/prettier-plugin-java/test/unit-test/return/_input.java index 463ce96b0..15e5d02c4 100644 --- a/packages/prettier-plugin-java/test/unit-test/return/_input.java +++ b/packages/prettier-plugin-java/test/unit-test/return/_input.java @@ -16,4 +16,24 @@ Object returnCast() { return (BeanItemContainer) super.getContainerDataSource(); } + Object returnSomethingWhichDoNotBreak() { + return oneVariable + secondVariable; + } + + Object returnSomethingWhichBreak() { + return oneVariable + secondVariable + thirdVariable + fourthVariable + fifthVariable + sixthVariable + seventhVariable; + } + + Object returnSomethingWhichBreakAndAlreadyInParenthesis() { + return ( + oneVariable + + secondVariable + + thirdVariable + + fourthVariable + + fifthVariable + + sixthVariable + + seventhVariable + ); + } + } diff --git a/packages/prettier-plugin-java/test/unit-test/return/_output.java b/packages/prettier-plugin-java/test/unit-test/return/_output.java index f30b31fea..436b18c3a 100644 --- a/packages/prettier-plugin-java/test/unit-test/return/_output.java +++ b/packages/prettier-plugin-java/test/unit-test/return/_output.java @@ -15,4 +15,32 @@ void exit() { Object returnCast() { return (BeanItemContainer) super.getContainerDataSource(); } + + Object returnSomethingWhichDoNotBreak() { + return oneVariable + secondVariable; + } + + Object returnSomethingWhichBreak() { + return ( + oneVariable + + secondVariable + + thirdVariable + + fourthVariable + + fifthVariable + + sixthVariable + + seventhVariable + ); + } + + Object returnSomethingWhichBreakAndAlreadyInParenthesis() { + return ( + oneVariable + + secondVariable + + thirdVariable + + fourthVariable + + fifthVariable + + sixthVariable + + seventhVariable + ); + } }