pair) {
- ! pair.key.lineRegions.last.contains( pair.value )
- }
-
-// def dispatch format(FunctionOrFieldAccessor fofAccessor, extension IFormattableDocument document) {
-// val begin = fofAccessor.body.semanticRegions.head
-// val end = fofAccessor.body.semanticRegions.last
-// if (begin?.lineRegions?.head?.contains(end?.endOffset)) {
-// // same line
-// } else {
-// // body spans multiple lines
-// begin.append[newLine;];
-// end.prepend[newLine;];
-// // fofAccessor.body.interior[indent]; // already by parenthesis?
-// }
-//
-// fofAccessor.body?.format;
-//
-// }
-
- def dispatch void format(N4EnumDeclaration enumDecl, extension IFormattableDocument document) {
- enumDecl.configureAnnotations(document);
- enumDecl.configureModifiers(document);
- enumDecl.insertSpaceInFrontOfCurlyBlockOpener(document);
- enumDecl.indentExcludingAnnotations(document);//.interiorBUGFIX([indent],document); //enumDecl.interior[indent];
- enumDecl.configureCommas(document);
-
- val braces = enumDecl.regionFor.keywordPairs("{","}").head;
-
- val multiLine = enumDecl.isMultiline;
-
- enumDecl.literals.forEach[
- format;
- if( multiLine ) {
- if( it.regionForEObject.previousHiddenRegion.containsComment )
- { // comment above
- it.prepend[newLines=2];
- } else { // no comment above
- it.prepend[newLine];
- }
- }
- ];
- if( multiLine ) {
- braces.value.prepend[newLine];
- }
- }
-
- def dispatch void format(ParameterizedPropertyAccessExpression exp, extension IFormattableDocument document) {
- val dotKW = exp.regionFor.keyword(".");
- dotKW.prepend[noSpace; autowrap; setNewLines(0,0,1)].append[noSpace;];
- if( exp.eContainer instanceof ExpressionStatement) {
- // top-level PPA, indent one level.
- exp.interiorBUGFIX([indent],document); //exp.interior[indent];
- }
- exp.target.format;
- }
-
- def dispatch void format(ParameterizedCallExpression exp, extension IFormattableDocument document) {
- // FIXME process typeArgs !!!
- val dotKW = exp.regionFor.keyword(".");
- dotKW.prepend[noSpace; autowrap;].append[noSpace;]
- exp.regionFor.keyword("(").prepend[noSpace].append[noSpace];
- exp.regionFor.keyword(")").prepend[noSpace];
- exp.configureCommas(document);
-
- exp.arguments.tail.forEach[prepend[oneSpace;autowrap]];
- exp.arguments.forEach[format];
-
- if( exp.eContainer instanceof ExpressionStatement) {
- // top-level PPA, indent one level.
- exp.interiorBUGFIX([indent],document); //exp.interior[indent];
- }
- exp.target.format;
- }
-
-
-
- def dispatch void format(ImportDeclaration decl, extension IFormattableDocument document) {
-
- // read configuration:
- val extraSpace = getPreference(FORMAT_SURROUND_IMPORT_LIST_WITH_SPACE)
-
- decl.regionFor.keyword("{").prepend[oneSpace].append[if(extraSpace) oneSpace else noSpace];
- decl.regionFor.keyword("}").prepend[if(extraSpace) oneSpace else noSpace].append[oneSpace; newLines = 0];
- decl.regionFor.keyword("from").surround[oneSpace];
- decl.configureCommas(document);
- decl.eContents.forEach[format];
- }
-
- def dispatch void format(NamedImportSpecifier namedImp, extension IFormattableDocument document){
- namedImp.regionFor.keyword("as").prepend[oneSpace].append[oneSpace];
- namedImp.regionFor.feature(N4JSPackage.Literals.IMPORT_SPECIFIER__DECLARED_DYNAMIC).prepend[noSpace].append[oneSpace]; // "+"-KW after alias-name
- }
-
- def dispatch void format(NamespaceImportSpecifier nsImp, extension IFormattableDocument document){
- nsImp.regionFor.keyword("*").append[oneSpace];
- nsImp.regionFor.keyword("as").append[oneSpace];
- nsImp.regionFor.feature(N4JSPackage.Literals.IMPORT_SPECIFIER__DECLARED_DYNAMIC).prepend[noSpace].append[oneSpace]; // "+"-KW after alias-name
- }
-
- def dispatch void format(ExportDeclaration export, extension IFormattableDocument document){
- export.regionFor.keyword("export").append[
- oneSpace;
- newLines=0;
- // Apply prioritization to catch cases of 'trapped' annotations e.g. "export @Final public class" which
- // could also be reordered to "@Final export public class.."
- priority=PRIO_13; // Priority higher then highPriority used in AnnotationList.
- ];
-
- export.eContents.forEach[format];
-
- // Fix Trapped annotations:
- val exported = export.exportedElement;
- if( exported instanceof AnnotableScriptElement ){
- val annoList = exported.annotationList;
- if( annoList !== null && !annoList.annotations.isEmpty) {
- annoList.annotations.last.append[
- newLines = 0; oneSpace; priority = PRIO_13;
- ]
- }
- }
- }
-
- def dispatch void format(IfStatement stmt, extension IFormattableDocument document) {
- val parenPair = stmt.regionFor.keywordPairs("(",")").head;
- parenPair.interior[noSpace;indent];
- parenPair.key.prepend[oneSpace];
- parenPair.value.append[oneSpace];
-
- stmt.regionFor.keyword("else").prepend[autowrap;oneSpace].append[oneSpace];
-
- stmt.elseStmt.prepend[oneSpace; newLines = 0];
-
- stmt.expression.format;
- stmt.ifStmt.format;
- stmt.elseStmt.format;
- }
-
- def dispatch void format(SwitchStatement swStmt, extension IFormattableDocument document) {
- swStmt.insertSpaceInFrontOfCurlyBlockOpener(document);
- swStmt.interiorBUGFIX([indent],document); //swStmt.interior[indent];
- swStmt.expression.format;
- swStmt.cases.head.prepend[newLine];
- swStmt.cases.forEach[format];
- }
-
- /** Formats DefaultCaseClause + CaseClause */
- def dispatch void format(AbstractCaseClause caseClause, extension IFormattableDocument document) {
- caseClause.interiorBUGFIX([indent],document); //caseClause.interior[indent];
-
- if (caseClause.statements.size == 1) {
- if (caseClause.statements.head instanceof Block) {
- caseClause.statements.head.prepend[setNewLines(0,0,0)];
- } else {
- caseClause.statements.head.prepend[setNewLines(0,1,1)];
- }
- } else {
- caseClause.statements.head.prepend[setNewLines(1,1,1)];
- }
-
- // caseClause.regionFor.keyword(":").prepend[oneSpace]; // In case one space before the colon is desired
- caseClause.statements.forEach[format];
- caseClause.statements.forEach[append[setNewLines(1,1,maxConsecutiveNewLines)]];
- caseClause.append[setNewLines(1, 1, maxConsecutiveNewLines)];
- }
-
- def dispatch void format(CastExpression expr, extension IFormattableDocument document) {
- expr.regionFor.keyword("as").prepend[newLines = 0; oneSpace].append[newLines = 0; oneSpace];
- expr.expression.format;
- expr.targetTypeRefNode.format;
- }
-
- def dispatch void format(Block block, extension IFormattableDocument document) {
- if( debug ) println("Formatting block "+containmentStructure(block));
-
- // Beware there are blocks in the grammar, that are not surrounded by curly braces. (e.g. FunctionExpression)
-
- // Block not nested in other blocks usually are bodies. We want them separated by a space:
- if (! (block.eContainer instanceof Block || block.eContainer instanceof Script)) { // TODO maybe invert the control here, since the block is formatting the outside.
- block.regionFor.keyword("{").prepend[oneSpace];
- }
-
- block.interiorBUGFIX([indent],document); //block.interior[indent];
-
- block.statements.head.prepend[setNewLines(1,1,maxConsecutiveNewLines)];
- block.statements.forEach[append[setNewLines(1,1,maxConsecutiveNewLines)]];
-
- block.statements.forEach[format];
-
- // Format empty curly blocks, necessary for comments inside:
- val braces = block.regionFor.keywordPairs("{","}").head
- if( braces !== null
- && braces.key.nextSemanticRegion == braces.value
- ) {
- // empty block:
- if( braces.key.nextHiddenRegion.containsComment ) {
- braces.key.append[setNewLines(1,1,maxConsecutiveNewLines)];
- } else {
- braces.key.append[newLines=0;noSpace];
- }
- }
- }
-
-
- def dispatch void format(ReturnStatement ret, extension IFormattableDocument document) {
- ret.interiorBUGFIX([indent],document); //ret.interior[indent;]
- ret.expression.prepend[oneSpace; newLines = 0];
- ret.expression.format;
- }
-
- def dispatch void format(AdditiveExpression add, extension IFormattableDocument document) {
- add.regionFor.feature(N4JSPackage.Literals.ADDITIVE_EXPRESSION__OP).surround[oneSpace].append[autowrap];
- add.lhs.format
- add.rhs.format
- }
-
- def dispatch void format(MultiplicativeExpression mul, extension IFormattableDocument document) {
- mul.regionFor.feature(N4JSPackage.Literals.MULTIPLICATIVE_EXPRESSION__OP).surround[oneSpace].append[autowrap];
- mul.lhs.format
- mul.rhs.format
- }
-
- def dispatch void format(BinaryBitwiseExpression binbit, extension IFormattableDocument document) {
- binbit.regionFor.feature(N4JSPackage.Literals.BINARY_BITWISE_EXPRESSION__OP).surround[oneSpace];
- binbit.lhs.format
- binbit.rhs.format
- }
-
- def dispatch void format(BinaryLogicalExpression binLog, extension IFormattableDocument document) {
- val opReg = binLog.regionFor.feature(N4JSPackage.Literals.BINARY_LOGICAL_EXPRESSION__OP);
- opReg.surround[oneSpace];
- binLog.lhs.format
- binLog.rhs.format
- // auto-wrap:
- val autoWrapInFront = getPreference(FORMAT_AUTO_WRAP_IN_FRONT_OF_LOGICAL_OPERATOR);
- if( autoWrapInFront ) {
- opReg.prepend[autowrap; lowPriority; setNewLines(0,0,1);]
- } else {
- opReg.append[autowrap; lowPriority; setNewLines(0,0,1);]
- };
- }
-
- def dispatch void format(EqualityExpression eqExpr, extension IFormattableDocument document) {
- eqExpr.regionFor.feature(N4JSPackage.Literals.EQUALITY_EXPRESSION__OP).surround[oneSpace].append[autowrap];
- eqExpr.lhs.format
- eqExpr.rhs.format
- }
-
- def dispatch void format(RelationalExpression relExpr, extension IFormattableDocument document) {
- relExpr.regionFor.feature(N4JSPackage.Literals.RELATIONAL_EXPRESSION__OP).surround[oneSpace].append[autowrap];
- relExpr.lhs.format
- relExpr.rhs.format
- }
-
- def dispatch void format(ShiftExpression shiftExpr, extension IFormattableDocument document) {
- shiftExpr.regionFor.feature(N4JSPackage.Literals.SHIFT_EXPRESSION__OP).surround[oneSpace].append[autowrap];
- shiftExpr.lhs.format
- shiftExpr.rhs.format
- }
-
- def dispatch void format(CommaExpression comma, extension IFormattableDocument document) {
- comma.configureCommas(document);
- comma.eContents.forEach[format];
- }
-
- def dispatch void format(ConditionalExpression cond, extension IFormattableDocument document) {
- cond.regionFor.keyword("?").surround[oneSpace].append[autowrap; lowPriority; setNewLines(0,0,1);];
- cond.regionFor.keyword(":").surround[oneSpace].append[autowrap; lowPriority; setNewLines(0,0,1);];
- cond.expression.format;
- cond.trueExpression.format;
- cond.falseExpression.format;
- }
-
- def dispatch void format(AwaitExpression await, extension IFormattableDocument document) {
- await.regionFor.keyword("await").prepend[oneSpace].append[oneSpace; newLines = 0];
- await.expression.format
- }
-
- def dispatch void format(PromisifyExpression promify, extension IFormattableDocument document) {
- promify.noSpaceAfterAT(document);
- promify.regionFor.keyword("Promisify").append[oneSpace];
- promify.expression.format
- }
-
- def dispatch void format(IndexedAccessExpression idxAcc, extension IFormattableDocument document) {
- val indexRegion = idxAcc.index.regionForEObject();
- indexRegion.previousSemanticRegion.prepend[noSpace;newLines=0].append[noSpace;newLines = 0];
- indexRegion.nextSemanticRegion.prepend[noSpace];
-
- idxAcc.index.format;
- idxAcc.target.format;
- }
-
- def dispatch void format(NewExpression newExp, extension IFormattableDocument document) {
- newExp.regionFor.keyword("new").prepend[oneSpace].append[oneSpace;newLines=0];
- newExp.callee.format;
- // Watch out, commas are used in Type-args and in argument list ! If necessary distinguish by offset.
- val commas = newExp.regionFor.keyword(",");
- commas.prepend[noSpace].append[oneSpace];
-
- // TODO maybe factor out TypeArgs formatting.
- val typeArgsAngle = newExp.regionFor.keywordPairs("<",">").head;
- if( typeArgsAngle !== null ) {
- typeArgsAngle.key.append[noSpace;newLines=0].prepend[noSpace;newLines=0];
- typeArgsAngle.value.prepend[noSpace;newLines=0];
- }
- newExp.typeArgs.forEach[format];
-
-
- if( newExp.isWithArgs ) {
- val argParen = newExp.regionFor.keywordPairs("(",")").head;
- argParen.key.prepend[newLines=0;noSpace].append[noSpace];
- argParen.value.prepend[noSpace];
- newExp.arguments.forEach[format];
- }
- }
-
- def dispatch void format(PostfixExpression postFix, extension IFormattableDocument document) {
- // no line break allowed between Expression and operator !
- postFix.regionFor.feature(N4JSPackage.Literals.POSTFIX_EXPRESSION__OP)
- .prepend[newLines=0;noSpace;].append[oneSpace;lowPriority]; // giving low priority for situations of closing parenthesis: "(a++)"
- postFix.expression.format;
- }
-
- def dispatch void format(TaggedTemplateString taggedTemplate, extension IFormattableDocument document) {
- taggedTemplate.regionFor.feature(N4JSPackage.Literals.EXPRESSION_WITH_TARGET__TARGET).append[ newLines = 0; oneSpace ];
- taggedTemplate.target.format;
- taggedTemplate.template.format;
- }
-
- def dispatch void format(UnaryExpression unaryExpr, extension IFormattableDocument document) {
- // The operators 'void' 'delete' and 'typeof' must be separated from operand.
- val boolean requireSpace=(unaryExpr.op.ordinal <= UnaryOperator.TYPEOF_VALUE);
- unaryExpr.regionFor.feature(N4JSPackage.Literals.UNARY_EXPRESSION__OP)
- .append[if(requireSpace) oneSpace else noSpace; newLines = 0;];
- unaryExpr.expression.format;
- }
-
- def dispatch void format(YieldExpression yieldExpr, extension IFormattableDocument document) {
- // " yield " or " yield* "
- yieldExpr.regionFor.keyword("yield")
- .prepend[oneSpace;]
- .append[if( yieldExpr.isMany ) noSpace else oneSpace];
- if( yieldExpr.isMany ){
- yieldExpr.regionFor.keyword("*").prepend[noSpace;newLines=0].append[oneSpace]
- }
- yieldExpr.expression.format;
- }
-
- def dispatch void format(ParenExpression parenE, extension IFormattableDocument document) {
- parenE.semanticRegions.head.append[noSpace;newLines=0;autowrap];
- parenE.semanticRegions.last.prepend[noSpace;newLines=0;autowrap];
- parenE.interiorBUGFIX([indent],document); //parenE.interior[indent];
- parenE.expression.format;
- }
-
- def dispatch void format(ArrowFunction arrowF, extension IFormattableDocument document) {
- arrowF.configureCommas(document);
- arrowF.regionFor.ruleCallTo(arrowRule).surround[oneSpace];
- arrowF.regionFor.keywordPairs("(",")").head?.interior[noSpace];
- // too lax: arrowF.fpars.configureFormalParameters(document,[/*NTD*/]);
-
- if( arrowF.isHasBracesAroundBody ) {
- // format body as block. NOTE: this block differs from other blocks, since the curly braces are defined in the ArrowExpression.
- // special handling of indentation in inside the braces.
- val bracesPair = arrowF.regionFor.keywordPairs("{","}").head;
- bracesPair.interior[indent];
- if( bracesPair.key.lineRegions.last.contains( bracesPair.value) // one line '{ do; stuff; }'
- || bracesPair.key.lineRegions.last.contains( bracesPair.key.nextSemanticRegion ) // no line-break after braces e.g. '{ do; \n stuff; }'
- ) {
- // one line
- arrowF.body?.statements.forEach[ it,idx|
- format; if( idx !==0 ) {it.prepend[oneSpace; autowrap; newLines=0;]}
- ];
- bracesPair.key.append[oneSpace]; // do not autowrap after "{" to keep wrap-semantic
- bracesPair.value.prepend[oneSpace];
- } else {
- // multi-line
- if( arrowF.body !== null && !arrowF.body.statements.empty ) {
- arrowF.body?.statements.head.prepend[newLines=1;];
- arrowF.body?.statements.forEach[format;append[newLines=1]];
- } else {
- // empty block, squash interior.
- bracesPair.key.append[noSpace;newLines=1;];
- bracesPair.value.prepend[noSpace;newLines=1];
- }
- }
- } else {
- // no braces Around the implicit return statement.
- arrowF.body?.statements.head.format;
- }
- }
-
-
- def dispatch void format(ArrayLiteral al, extension IFormattableDocument document) {
- val bracketPair = al.regionFor.keywordPairs("[","]").head;
- bracketPair.interior[indent];
- val sameLine = bracketPair.key.lineRegions.head.contains( bracketPair.value );
- // auto wrap in front of AL-Elements, to preserve comma at end.
- if( ! sameLine) {
- al.elements.last.append[autowrap];
- al.elements.forEach[it,num|prepend[autowrap;setNewLines(0,0,1);if(num!==0)oneSpace;].append[noSpace]];
- // format last bracket if in single.line.
- if( ! bracketPair.value.previousSemanticRegion.lineRegions.last.contains( bracketPair.value ) ) {
- bracketPair.value.prepend[newLine];
- }
- } else {
- al.elements.forEach[it,num|prepend[autowrap;if(num!==0)oneSpace;]];
- }
- }
-
- def dispatch void format(ObjectLiteral ol, extension IFormattableDocument document) {
- ol.configureCommas(document);
-
- val bracePair = ol.regionFor.keywordPairs("{","}").head;
- bracePair.interior[indent];
-
-
- // Decide on multiline or not.
- // Rule: if opening brace is preceded by a line break, then go multiline.
- val sameLine = bracePair.key.lineRegions.head.contains( bracePair.key.nextSemanticRegion.lineRegions.head );
- // OLD: val sameLine = bracePair.key.lineRegions.head.contains( bracePair.value );
- if( ! sameLine) {
- bracePair.value.prepend[newLine]; // format WS in front of closing brace
- ol.propertyAssignments.forEach[it,num|prepend[newLine]];
- if( bracePair.key.nextSemanticRegion == bracePair.value ) {
- // empty multiline, trigger formatting:
- bracePair.key.append[newLine];
- }
- } else { // in one line
- bracePair.key.append[newLines=0];
- ol.propertyAssignments.forEach[it,num|prepend[newLines=0;if(num!==0) { autowrap; oneSpace; } else {noSpace;}]];
- bracePair.value.prepend[newLines=0; noSpace; lowPriority]; // low priority to avoid conflict with dangling commas
- }
-
- ol.eContents.forEach[format];
- }
-
- def dispatch void format( ForStatement fst, extension IFormattableDocument document){
-
- fst.regionFor.keyword("for").append[oneSpace;newLines=0; autowrap];
-
- val parenPair = fst.regionFor.keywordPairs("(",")").head;
- parenPair.key.append[noSpace;autowrap;newLines=0];
- parenPair.value.prepend[noSpace;newLines=0].append[oneSpace;newLines=0;autowrap;];
-
- fst.regionFor.keywords("in","of").forEach[ it.surround[oneSpace; newLines=0; autowrap] ];
- fst.regionFor.keywords(";").forEach[it.prepend[noSpace;newLines=0;].append[oneSpace;newLines=0;autowrap]];
-
- fst.eContents.forEach[format];
- }
-
- def dispatch void format(TemplateLiteral tl, extension IFormattableDocument document) {
- tl.interiorBUGFIX([indent],document); //tl.interior[indent;];
- tl.segments.forEach[
- switch(it) {
- TemplateSegment: noOp
- default: it.surround[oneSpace; autowrap;]
- };
- it.format;
- ];
- }
- private def noOp (){}
-
- def dispatch void format(TemplateSegment tl, extension IFormattableDocument document) {
- // just leave as is.
- }
-
- def dispatch void format(N4TypeVariable tv, extension IFormattableDocument document) {
- // "out"
- if( tv.declaredCovariant ) { tv.regionFor.feature(N4JSPackage.Literals.N4_TYPE_VARIABLE__DECLARED_COVARIANT).append[oneSpace]; }
- // "in"
- if( tv.declaredContravariant ) {tv.regionFor.feature(N4JSPackage.Literals.N4_TYPE_VARIABLE__DECLARED_CONTRAVARIANT).append[oneSpace];}
-
- val upperBoundNode = tv.declaredUpperBoundNode;
- if( upperBoundNode!==null ) {
- // "extends"
- tv.regionFor.keyword("extends").surround[oneSpace];
- upperBoundNode.immediatelyFollowing.keyword("&").surround[oneSpace];
- upperBoundNode.format(document);
- }
-
- }
-
-
-
- def dispatch void format(Expression exp, extension IFormattableDocument document) {
- switch(exp) {
- // Things not to format:
- BooleanLiteral,
- IdentifierRef,
- IntLiteral,
- NullLiteral,
- NumberLiteral,
- RegularExpressionLiteral,
- StringLiteral,
- ThisLiteral,
- SuperLiteral,
- JSXElement
- : return
- }
- throw new UnsupportedOperationException("expression "+exp.class.simpleName+" not yet implemented.");
- }
-
- /** simply formats all content */
- def void genericFormat(Expression exp, extension IFormattableDocument document) {
- exp.eContents.forEach[format];
- }
-
-
- def dispatch void format(AssignmentExpression ass, extension IFormattableDocument document) {
- ass.lhs.append[oneSpace]
- ass.rhs.prepend[oneSpace]
- ass.lhs.format;
- ass.rhs.format;
- }
-
- def dispatch void format( ExpressionStatement eStmt, extension IFormattableDocument docuemt){
- eStmt.expression.format;
- }
-
- /** var,let,const */
- def dispatch void format(VariableStatement vStmt, extension IFormattableDocument document) {
-
- vStmt.configureModifiers(document);
-
- vStmt.regionFor.feature(
- N4JSPackage.Literals.VARIABLE_DECLARATION_CONTAINER__VAR_STMT_KEYWORD).append [
- oneSpace;
- ]; // "let", "var" or "const"
-
- vStmt.configureCommas(document);
-
- vStmt.interiorBUGFIX([indent],document); //vStmt.interior[indent];
- val lastIdx = vStmt.varDeclsOrBindings.size - 1;
-
- vStmt.varDeclsOrBindings.forEach [ e, int i |
- e.format;
- if (i > 0) { // assignments start in separate lines.
- if (e instanceof VariableDeclaration) {
- if (e.expression !== null) e.prepend[newLine]
- else e.prepend[setNewLines(0,1,1); lowPriority];
- } else if (e instanceof VariableBinding) {
- if (e.expression !== null) e.prepend[newLine]
- else e.prepend[setNewLines(0,1,1); lowPriority];
- }
- }
- if (i < lastIdx) { // assignments start let following continue in separate lines.
- if (e instanceof VariableDeclaration) {
- if (e.expression !== null) e.immediatelyFollowing.keyword(",").append[newLine]
- else e.prepend[setNewLines(0,1,1); lowPriority];
- } else if (e instanceof VariableBinding) {
- if (e.expression !== null) e.immediatelyFollowing.keyword(",").append[newLine]
- else e.prepend[setNewLines(0,1,1); lowPriority];
- }
-
- }
- ];
- }
-
- def dispatch void format(VariableDeclaration vDecl, extension IFormattableDocument document) {
- vDecl.previousHiddenRegion.set[oneSpace];
- vDecl.regionFor.keyword("=").surround[oneSpace];
- vDecl.expression.format;
- vDecl.declaredTypeRefInAST.format;
- }
-
- def dispatch void format(VariableBinding vBind, extension IFormattableDocument document) {
- vBind.previousHiddenRegion.set[oneSpace];
- vBind.regionFor.keyword("=").surround[oneSpace];
- vBind.pattern.format;
- vBind.expression.format;
- vBind.pattern.format;
- }
-
- def dispatch void format( BindingPattern bp, extension IFormattableDocument document) {
- // ObjectBindingPattern
- // ArrayBindingPattern
-
- // '{' or '['
- bp.semanticRegions.head.append[noSpace;newLines=0;autowrap];
- bp.semanticRegions.last.prepend[noSpace;newLines=0;autowrap];
- bp.configureCommas(document); // doesn't handle elision.
-
- bp.eContents.forEach[format];
- }
-
-
- def dispatch void format(ThrowStatement thrStmt, extension IFormattableDocument document) {
- thrStmt.expression.prepend[setNewLines(0, 0, 0); oneSpace]; // No autowrap, otherwise ASI
- thrStmt.expression.format;
- }
-
-
- def dispatch void format(CatchBlock ctch, extension IFormattableDocument document) {
- ctch.prepend[setNewLines(0, 0, 0); oneSpace];
- ctch.catchVariable.format;
- ctch.block.format;
- }
-
- def dispatch void format(FinallyBlock finlly, extension IFormattableDocument document) {
- finlly.previousHiddenRegion.set[newLines = 0; oneSpace];
- finlly.block.format;
- }
-
- /** Insert one space in front of first '{' in the direct content of the element.
- * semEObject is a semanticObject, e.g. N4EnumDecl, N4Classifier ...*/
- private def void insertSpaceInFrontOfCurlyBlockOpener(EObject semEObject, extension IFormattableDocument document) {
- semEObject.regionFor.keyword("{").prepend[oneSpace];
- }
-
- /** force: " @" and no newLine after '@' */
- private def void noSpaceAfterAT(EObject semEObject, extension IFormattableDocument document) {
- semEObject.regionFor.keyword("@").append[noSpace;newLines=0].prepend[oneSpace];
- }
-
- /** On the direct level of an semantic Object enforce commas to ", " with autoWrap option. */
- private def void configureCommas(EObject semEObject, extension IFormattableDocument document) {
- semEObject.regionFor.keywords(",").forEach [
- prepend[noSpace];
- append[oneSpace; autowrap];
- ];
- }
-
- def void indentExcludingAnnotations(EObject semObject, extension IFormattableDocument document) {
- //Exclude Annotations from indentation field.interior[indent];
- val begin = semObject.semanticRegions.findFirst[!(semanticElement instanceof Annotation)];
- val end = semObject.semanticRegions.last;
- if( begin !== end ) { // guard to prevent wrong indentation
- interior(begin,end,[indent]);
- }
- }
-
-
- private def dispatch void configureAnnotations(AnnotableN4MemberDeclaration semEObject, extension IFormattableDocument document) {
- configureAnnotations( semEObject.annotationList, document );
- }
-
- private def dispatch void configureAnnotations(AnnotablePropertyAssignment semEObject, extension IFormattableDocument document) {
- configureAnnotations( semEObject.annotationList, document );
- }
-
- private def dispatch void configureAnnotations(AnnotableScriptElement semEObject, extension IFormattableDocument document) {
- configureAnnotations( semEObject.annotationList, document );
- }
-
- private def dispatch void configureAnnotations(AnnotableExpression semEObject, extension IFormattableDocument document) {
- configureAnnotations( semEObject.annotationList, document );
- }
-
- private def dispatch void configureAnnotations(AbstractAnnotationList aList, extension IFormattableDocument document) {
- if( aList === null || aList.annotations.isEmpty ) return;
-
- aList.prepend[setNewLines(2,2,2);highPriority]; // TODO in case of trapped in Annotation like 'export @Final public class A{}' - a reorder would be necessary (see format for export)
- aList.append[newLine]; // TODO special annotations like @Internal ? --> together with public, reorder to be in same line?
- aList.annotations.forEach[it, idx |
- it.configureAnnotation(document,true,idx ===0);
- ];
- }
-
- /**
- *
- * @param withLineWraps true do line-wrapping
- * @param isFirstenAnnotation if this is the first annotation in a sequence ( used with line-wrapping in front of '@')
- */
- private def configureAnnotation(Annotation it, extension IFormattableDocument document, boolean withLineWraps, boolean isFirstAnnotation ){
- // configure arguments
- val parens = it.regionFor.keywordPairs("(",")").head;
- if( parens !== null ) {
- parens=>[
- it.key.prepend[noSpace].append[noSpace];
- it.value.prepend[noSpace].append[if( withLineWraps ) {noSpace; newLines=1;} else {oneSpace; newLines=0;}];
- it.interior[indent];
- // line break before "@":
- if( withLineWraps && !isFirstAnnotation ) {
- it.key.previousSemanticRegion.previousSemanticRegion.prepend[newLines = 1];
- }
- ];
- it.configureCommas(document);
- }
-
- // Configure @-Syntax
- // Special case here: for "@XY" we can either get "@" or "XY" as the first semantic element
- it.semanticRegions.head =>[
- if( it.grammarElement instanceof Keyword) {
- // assume '@'
- it.append[ noSpace; newLines=0 ];
- } else {
- it.prepend[ // for "@Final" "Final" will be the first semantic region in case of exported classes,
- noSpace; newLines=0
- ];
- }
- ];
- }
-
- private def dispatch void configureAnnotations(Object semEObject, extension IFormattableDocument document) {
- // no annotations to be configured.
- }
-
- private def dispatch void configureAnnotations(Void x, extension IFormattableDocument document) {
- // no annotations to be configured.
- }
-
- private def void configureAnnotationsInLine(FormalParameter fpar, extension IFormattableDocument document) {
- if( fpar.annotations.isEmpty ) return;
- // (@x @y("") bogus a:typ)
- fpar.annotations.head=>[
- it.configureAnnotation(document,false,true);
- prepend[noSpace;newLines=0;autowrap;];
- ]
- fpar.annotations.tail.forEach[
- configureAnnotation(document,false,false);
- prepend[oneSpace;newLines=0;autowrap;];
- ]
- fpar.annotations.last.append[oneSpace;newLines=0;autowrap;];
- }
-
-
- /** only script-level annotations '@@' */
- private def void formatScriptAnnotations(Script script, extension IFormattableDocument document) {
- if( script.annotations.isEmpty ) return;
-
- if (script.annotations.head.previousHiddenRegion.containsComment) {
- script.annotations.head.prepend[noSpace;];
- } else {
- script.annotations.head.prepend[noSpace;newLines=0;];
- }
- script.annotations.last.append[setNewLines(2,2,2)];
-
- script.annotations.forEach[it,idx|
- if( idx !==0 ) it.prepend[newLines=1;noSpace];
- it.semanticRegions.head=>[ // its an '@@'
- append[noSpace;newLines=0]
- ]
- ]
-
- }
-
-
-
-
- public override ITextReplacer createCommentReplacer(IComment comment) {
- // Overridden to distinguish between JSDOC-style, standard ML, formatter-off ML-comment.
- val EObject grammarElement = comment.getGrammarElement();
- if (grammarElement instanceof AbstractRule) {
- val String ruleName = (/*(AbstractRule)*/ grammarElement).getName();
- if (ruleName.startsWith("ML")) {
- val cText = comment.text;
- if (cText.startsWith("/**") && !cText.startsWith("/***")) { // JSDOC
- return new N4MultilineCommentReplacer(comment, '*');
- } else if (cText.startsWith("/*-")) { // Turn-off formatting.
- return new OffMultilineCommentReplacer(comment, !comment.isNotFirstInLine);
- } else { // All other
- return new FixedMultilineCommentReplacer(comment);
- }
- }
- if (ruleName.startsWith("SL")) {
- if (comment.isNotFirstInLine) {
- return new SinglelineDocCommentReplacer(comment, "//");
- } else {
- return new SinglelineCodeCommentReplacer(comment, "//");
- }
- }
- }
-
- // fall back to super-impl.
- super.createCommentReplacer(comment);
- }
-
- private static def boolean isNotFirstInLine(IComment comment) {
- val lineRegion = comment.getLineRegions().get(0);
-
- return !comment.contains( lineRegion.offset );
- }
-
-
- public override createTextReplacerMerger(){
- return new IndentHandlingTextReplaceMerger(this);
- }
-
- /** DEBUG-helper */
- private def static String containmentStructure(EObject eo) {
- val name = eo.class.simpleName;
- if( eo.eContainer !== null )
- return '''«eo.eContainer.containmentStructure».«eo.eContainingFeature.name»-> «name»'''
- return name
- }
-
- /** HELPER to avoid Warnings in code, since @SuppressWarnings("unused") is not active in xtend code.*/
- def suppressUnusedWarnings(Object ... e)
- {
- PRIO_4;
- }
-
- /**
- * Simple tracker that only gives exactly one time the value {@code true}
- * when calling {@link StateTrack#shouldDoThenDone()}
- */
- private final static class StateTrack {
- private boolean done=false;
-
- /**
- * This method returns {@code true} exactly on it's first invocation. Proceeding calls always return {@code false}.
- *
- * @return Returns {@code true} if not done, immediately switches {@link #done} to {@code true};
- * returns {@code false} if already done.
- */
- def boolean shouldDoThenDone(){
- val ret = !done;
- done = true;
- return ret;
- }
- }
-
-
- /****************************************************************************************************************
- *
- * Type Expression
- *
- ***************************************************************************************************************/
- def dispatch void format(UnionTypeExpression ute, extension IFormattableDocument document) {
- ute.regionFor.keywords("|").forEach[ surround[oneSpace;newLines=0].prepend[autowrap;highPriority] ];
- ute.typeRefs.forEach[format];
- // OLD syntax:
- val kwUnion = ute.regionFor.keyword("union");
- if( kwUnion !== null ) {
- kwUnion.prepend[oneSpace].append[oneSpace;newLines=0].nextSemanticRegion/*'{'*/.append[oneSpace;newLines=0];
- ute.semanticRegions.last/*'}'*/.prepend[oneSpace;newLines=0];
- }
- }
-
- def dispatch void format(IntersectionTypeExpression ite, extension IFormattableDocument document) {
- ite.regionFor.keywords("&").forEach[surround[oneSpace;newLines=0].prepend[autowrap;highPriority]];
- ite.typeRefs.forEach[format];
- // OLD syntax
- val kwInersection = ite.regionFor.keyword("intersection");
- if( kwInersection !== null ) {
- kwInersection.prepend[oneSpace].append[oneSpace;newLines=0].nextSemanticRegion/*'{'*/.append[oneSpace;newLines=0];
- ite.semanticRegions.last/*'}'*/.prepend[oneSpace;newLines=0];
- }
- }
-
- def dispatch void format( TStructMember tsm, extension IFormattableDocument document) {
- if(tsm instanceof TField) {
- tsm.configureOptionality(document);
- } else if(tsm instanceof org.eclipse.n4js.ts.types.FieldAccessor) {
- tsm.configureGetSetKeyword(document);
- tsm.configureOptionality(document);
-
- val parenPair = tsm.regionFor.keywordPairs("(",")").head;
- parenPair.key.prepend[noSpace; newLines = 0].append[noSpace];
- }
- // get, set, method, field
- tsm.eContents.forEach[format;];
- // TODO format TStruct* more thoroughly
- // (note: added some TStructMember formatting while working on IDE-2405, but it is still incomplete!)
- }
-
-
-
- def private void configureUndefModifier( StaticBaseTypeRef sbtr, extension IFormattableDocument document){
- // UndefModifier "?"
- sbtr.regionFor.feature(TypeRefsPackage.Literals.TYPE_REF__FOLLOWED_BY_QUESTION_MARK).prepend[noSpace;newLines=0;];
- }
-
- def dispatch void format( ThisTypeRef ttr, extension IFormattableDocument document) {
- ttr.configureUndefModifier(document);
- if( ttr instanceof ThisTypeRefStructural) {
- ttr.interiorBUGFIX([indent],document)
- configureStructuralAdditions(ttr,document);
- ttr.eContents.forEach[
- format;
- ]
- }
- }
-
- def dispatch void format( ParameterizedTypeRef ptr, extension IFormattableDocument document) {
- ptr.interiorBUGFIX([indent],document); //ptr.interior[indent];
- ptr.configureUndefModifier(document);
-
- // Union / Intersection
- ptr.regionFor.keywords("&","|").forEach[ surround[oneSpace;newLines=0].append[autowrap;highPriority]];
- // Short-Hand Syntax for Arrays
- if( ptr.isArrayTypeExpression ) {
- ptr.regionFor.keyword("[").append[noSpace];
- ptr.regionFor.keyword("]").append[noSpace];
- }
- // Short-Hand Syntax for IterableN
- if( ptr.isArrayNTypeExpression ) {
- ptr.regionFor.keyword("[").append[noSpace];
- ptr.regionFor.keyword("]").append[noSpace];
- }
- ptr.formatTypeArguments(document);
-
- // ParameterizedTypeRefStructural :
- configureStructuralAdditions(ptr,document);
-
- // generically format content:
- ptr.eContents.forEach[format]
- }
-
- /** used for "~X with {}" except for the 'X' part. */
- def void configureStructuralAdditions( TypeRef ptr, extension IFormattableDocument document) {
- val semRegTypingStrategy = ptr.regionFor.ruleCallTo(typingStrategyUseSiteOperatorRule);
- if( semRegTypingStrategy!== null) {
- semRegTypingStrategy.prepend[oneSpace].append[noSpace;newLines=0;];
-
- // declaredType
- semRegTypingStrategy.nextSemanticRegion.append[];
-
- val kwWith = ptr.regionFor.keyword("with");
- if( kwWith !== null ) {
- kwWith.surround[oneSpace;newLines=0;autowrap];
- val bracesPair = ptr.regionFor.keywordPairs("{","}").head;
- bracesPair.key.append[noSpace;newLines=0;autowrap];
- bracesPair.value.prepend[noSpace;newLines=0;autowrap];
- //ptr.regionFor.keywords(",",";").forEach[ prepend[noSpace;newLines=0].append[oneSpace;newLines=0;autowrap] ]
- ptr.regionFor.keywords(";").forEach[ prepend[noSpace;newLines=0].append[oneSpace;newLines=0;autowrap;lowPriority] ]
- ((ptr as StructuralTypeRef).astStructuralMembers.tail
- .forEach[ regionForEObject.previousHiddenRegion.set[oneSpace;newLines=0;autowrap]]
- );
- }
- }
- }
-
- /** formats type argument section including outside border. */
- def void formatTypeArguments(ParameterizedTypeRef semObject, extension IFormattableDocument document) {
- if( semObject.declaredTypeArgs.isEmpty ) return;
- // to "<":
- semObject.regionFor.keyword("<").append[noSpace].prepend[noSpace; newLines=0; lowPriority];
- semObject.regionFor.keyword(">").prepend[noSpace].append[noSpace; newLines=0; lowPriority];
- for( typeArg: semObject.declaredTypeArgs ){
- typeArg.append[noSpace].immediatelyFollowing.keyword(",").append[oneSpace];
- typeArg.format(document);
- }
-
- }
-
-
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- // Configure Methods
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- def private void configureGetSetKeyword(FieldAccessor fieldAccessor, extension IFormattableDocument document) {
- val kw = if(fieldAccessor instanceof GetterDeclaration) "get" else "set";
- fieldAccessor.regionFor.keyword(kw).prepend[oneSpace].append[oneSpace; newLines=0; autowrap];
- }
- def private void configureGetSetKeyword(org.eclipse.n4js.ts.types.FieldAccessor tFieldAccessor, extension IFormattableDocument document) {
- val kw = if(tFieldAccessor instanceof TGetter) "get" else "set";
- tFieldAccessor.regionFor.keyword(kw).prepend[oneSpace].append[oneSpace; newLines=0; autowrap];
- }
-
- def private void configureOptionality(N4FieldDeclaration fieldDecl, extension IFormattableDocument document) {
- fieldDecl.regionFor.feature(N4JSPackage.Literals.N4_FIELD_DECLARATION__DECLARED_OPTIONAL).prepend[noSpace;newLines=0;];
- }
- def private void configureOptionality(FieldAccessor fieldAccessor, extension IFormattableDocument document) {
- fieldAccessor.regionFor.feature(N4JSPackage.Literals.FIELD_ACCESSOR__DECLARED_OPTIONAL).prepend[noSpace;newLines=0;];
- }
- def private void configureOptionality(TField tField, extension IFormattableDocument document) {
- tField.regionFor.feature(TypesPackage.Literals.TFIELD__OPTIONAL).prepend[noSpace;newLines=0;];
- }
- def private void configureOptionality(org.eclipse.n4js.ts.types.FieldAccessor tFieldAccessor, extension IFormattableDocument document) {
- tFieldAccessor.regionFor.feature(TypesPackage.Literals.FIELD_ACCESSOR__OPTIONAL).prepend[noSpace;newLines=0;];
- }
-
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- // Bug-workarounds
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /** Temporarily used method to replace document.interior(EObject, Procedure1) to prevent wrong indentations.
- *
- * Main pattern replace document-extension method call:
- *
- * object.interior[indent]
- *
- * by
- *
- * object.interiorBUGFIX([indent],document);
- *
- *
- */
- def void interiorBUGFIX(EObject object, Procedure1 init,IFormattableDocument document ){
- val IEObjectRegion objRegion = getTextRegionAccess().regionForEObject(object);
- if (objRegion !== null) {
- val IHiddenRegion previous = objRegion.getPreviousHiddenRegion();
- val IHiddenRegion next = objRegion.getNextHiddenRegion();
- if (previous !== null && next !== null && previous != next) {
- val nsr = previous.getNextSemanticRegion();
- val psr = next.getPreviousSemanticRegion();
- if( nsr != psr )
- { // standard case
- document.interior(nsr, psr , init);
- } else {
- // former error-case:
- // there is no interior --> don't do anything!
- //
- // applying to the next HiddenRegion is a bad idea,
- // since it could wrongly indent a multiline-comment (c.f. GHOLD-260)
- }
- }
- }
- }
-
-
- /** Dummy method to prevent accidentally calling interior - extension method form document. You should call interiorBUGFIX instead ! */
- def Procedure1 interior( EObject eo, Procedure1 init ){
- throw new IllegalStateException("Method should not be called.")
- }
-
-}
diff --git a/plugins/org.eclipse.n4js/src/org/eclipse/n4js/formatting2/N4JSGenericFormatter.java b/plugins/org.eclipse.n4js/src/org/eclipse/n4js/formatting2/N4JSGenericFormatter.java
new file mode 100644
index 0000000000..17560c88f9
--- /dev/null
+++ b/plugins/org.eclipse.n4js/src/org/eclipse/n4js/formatting2/N4JSGenericFormatter.java
@@ -0,0 +1,368 @@
+/**
+ * Copyright (c) 2016 NumberFour AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * NumberFour AG - Initial API and implementation
+ */
+package org.eclipse.n4js.formatting2;
+
+import static org.eclipse.xtext.xbase.lib.IterableExtensions.filter;
+import static org.eclipse.xtext.xbase.lib.IterableExtensions.findFirst;
+import static org.eclipse.xtext.xbase.lib.IterableExtensions.groupBy;
+import static org.eclipse.xtext.xbase.lib.IterableExtensions.last;
+import static org.eclipse.xtext.xbase.lib.IterableExtensions.map;
+import static org.eclipse.xtext.xbase.lib.IterableExtensions.sortBy;
+import static org.eclipse.xtext.xbase.lib.IterableExtensions.toList;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.n4js.services.N4JSGrammarAccess;
+import org.eclipse.xtend.lib.annotations.Accessors;
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.formatting2.AbstractFormatter2;
+import org.eclipse.xtext.formatting2.IFormattableDocument;
+import org.eclipse.xtext.formatting2.IHiddenRegionFormatting;
+import org.eclipse.xtext.formatting2.ITextReplacer;
+import org.eclipse.xtext.formatting2.ITextReplacerContext;
+import org.eclipse.xtext.formatting2.internal.HiddenRegionReplacer;
+import org.eclipse.xtext.formatting2.internal.TextReplacerMerger;
+import org.eclipse.xtext.formatting2.regionaccess.IHiddenRegion;
+import org.eclipse.xtext.formatting2.regionaccess.ISemanticRegion;
+import org.eclipse.xtext.formatting2.regionaccess.ITextRegionExtensions;
+import org.eclipse.xtext.formatting2.regionaccess.ITextSegment;
+import org.eclipse.xtext.xbase.lib.Pair;
+
+/**
+ *
+ */
+@SuppressWarnings("restriction")
+@FinalFieldsConstructor
+class N4JSGenericFormatter {
+
+ N4JSGrammarAccess grammarAccess;
+ ITextRegionExtensions trExtensions;
+
+ public static int PRIO_1 = -10;
+ public static int PRIO_2 = -9;
+ public static int PRIO_3 = -8;
+
+ public N4JSGenericFormatter(N4JSGrammarAccess grammarAccess, ITextRegionExtensions trExtensions) {
+ this.grammarAccess = grammarAccess;
+ this.trExtensions = trExtensions;
+ }
+
+ public void formatColon(EObject semanticElement, IFormattableDocument document) {
+ for (ISemanticRegion colon : trExtensions.allRegionsFor(semanticElement).keywords(":")) {
+ ISemanticRegion sr = document.prepend(colon, hrf -> {
+ hrf.noSpace();
+ hrf.setNewLines(0);
+ hrf.setPriority(PRIO_3);
+ });
+ document.append(sr, hrf -> {
+ hrf.oneSpace();
+ hrf.setPriority(PRIO_2);
+ });
+ }
+ }
+
+ /**
+ * Formats whitespace around already present semicolons (;) and inserts new semicolons where the parser expects
+ * them.
+ */
+ public void formatSemicolons(EObject script, IFormattableDocument document) {
+ for (ISemanticRegion region : trExtensions.allRegionsFor(script).ruleCallsTo(grammarAccess.getSemiRule())) {
+ String text = region.getText();
+ IHiddenRegion previous = region.getPreviousHiddenRegion();
+ if (text == ";") {
+
+ // there is already a ";" so let's format it
+ document.prepend(region, hrf -> {
+ hrf.noSpace();
+ hrf.setNewLines(0);
+ hrf.highPriority();
+ });
+ } else if (region.getNextSemanticRegion() != null && "}".equals(region.getNextSemanticRegion().getText())
+ && !region.isMultiline()) {
+ // do nothing
+ } else if (previous.containsComment()) {
+
+ // we're behind a comment - insert semicolon before the comment
+ ITextSegment insertAt = region.getTextRegionAccess().regionForOffset(previous.getOffset(), 0);
+ document.addReplacer(new InsertSemi(insertAt, ";"));
+ } else if (text.trim().isEmpty()) {
+ // Don't eat up white space here.
+ // Look for first line break and replace with ";\n":
+ int lbIdx = text.indexOf("\n");
+ if (lbIdx >= 0) {
+ ITextSegment replaceRegion = region.getTextRegionAccess().regionForOffset(region.getOffset(),
+ lbIdx + 1);
+ document.addReplacer(new InsertSemi(replaceRegion, ";\n"));
+ } else {
+ // the text region only contains whitespace, e.g. so let's insert a ; and a "\n"
+ document.addReplacer(new InsertSemi(region, ";"));
+ }
+ } else {
+
+ // we probably are the comment, so let's prefix it with ;
+ ITextSegment insertAt = region.getTextRegionAccess().regionForOffset(region.getOffset(), 0);
+ document.addReplacer(new InsertSemi(insertAt, ";"));
+ }
+ }
+ }
+
+ /**
+ * Format whitespace around (), [], and {}
+ *
+ * When multiple pairs of (), [], or {} open in the same line, indentation is only applied for the innermost pair.
+ */
+ public void formatParenthesisBracketsAndBraces(EObject script, IFormattableDocument document) {
+ List> all = new ArrayList<>();
+ all.addAll(trExtensions.allRegionsFor(script).keywordPairs("(", ")"));
+ all.addAll(trExtensions.allRegionsFor(script).keywordPairs("{", "}"));
+ all.addAll(trExtensions.allRegionsFor(script).keywordPairs("[", "]"));
+
+ Map>> byLine = groupBy(all,
+ p -> p.getKey().getLineRegions().get(0).getOffset());
+
+ for (Entry>> e : byLine.entrySet()) {
+ List> bracePairsInSameLine = sortBy(e.getValue(),
+ p -> p.getKey().getOffset());
+ Pair outermost = bracePairsInSameLine.get(0);
+ Pair innermost = last(bracePairsInSameLine);
+
+ // keep track of lastOpen/lastClose to avoid formatting the HiddenRegion twice if that hidden region
+ // is located directly between two brackets. Then, first.append[] would collide with second.prepend[].
+ IHiddenRegion lastOpen = null;
+ IHiddenRegion lastClose = null;
+ for (Pair pair : bracePairsInSameLine) {
+ ISemanticRegion open = pair.getKey();
+ ISemanticRegion close = pair.getValue();
+ if (open.getPreviousHiddenRegion() != lastOpen && lastOpen != null) {
+ // something between last opening and this one; null-check for first opening-> don't force noSpace
+ // here
+ document.prepend(open, hrf -> {
+ hrf.noSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ }
+ if (pair != innermost) {
+ document.append(open, hrf -> {
+ hrf.noSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ document.prepend(close, hrf -> {
+ hrf.noSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ }
+ if (close.getNextHiddenRegion() != lastClose) {
+ if (pair == outermost) {
+ // close.appendNewLine(document)
+ } else {
+ document.append(close, hrf -> {
+ hrf.noSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ }
+ }
+ lastOpen = open.getNextHiddenRegion();
+ lastClose = close.getPreviousHiddenRegion();
+ }
+
+ ISemanticRegion open = innermost.getKey();
+ ISemanticRegion close = innermost.getValue();
+ if (open.getNextSemanticRegion() == close && !open.getNextHiddenRegion().isMultiline()) { // empty
+ // brace-pair
+ document.append(open, hrf -> {
+ hrf.noSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ } // otherwise, if there is a newline before the innermost closing bracket, we want to format the surrounded
+ // tokens multiline style.
+ else if (close.getPreviousHiddenRegion().isMultiline()) {
+ appendNewLine(document.prepend(close, hrf -> {
+ hrf.newLine();
+ hrf.setPriority(PRIO_1);
+ }), document);
+ document.append(open, hrf -> {
+ hrf.newLine();
+ hrf.setPriority(PRIO_1);
+ });
+ document.interior(innermost, hrf -> hrf.indent());
+ for (ISemanticRegion comma : trExtensions.regionFor(open.getSemanticElement()).keywords(",")) {
+ // FIXME: bug in toString: println(comma.toString);
+ ISemanticRegion sr = document.prepend(comma, hrf -> {
+ hrf.noSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ document.append(sr, hfr -> {
+ // If dangling comma, then a conflict arises with new line of close.
+ // Avoid here by using Prio_2
+ hfr.setNewLines(1, 1, 2);
+ hfr.setPriority(PRIO_2);
+ });
+ }
+ } // otherwise, format the tokens into a single line.
+ else {
+ if (document.getRequest().getPreferences()
+ .getPreference(N4JSFormatterPreferenceKeys.FORMAT_SURROUND_PAREN_CONTENT_WITH_SPACE)) {
+ // configured way to have single space in parenthesised expression.
+ document.prepend(close, hrf -> {
+ hrf.oneSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ document.append(open, hrf -> {
+ hrf.oneSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ }
+ for (ISemanticRegion comma : trExtensions.regionFor(open.getSemanticElement()).keywords(",")) {
+ ISemanticRegion sr = document.prepend(comma, hrf -> {
+ hrf.noSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ document.append(sr, hrf -> {
+ hrf.oneSpace();
+ hrf.setPriority(PRIO_1);
+ });
+ }
+ }
+ }
+ }
+
+ public ISemanticRegion appendNewLine(ISemanticRegion appendAfter, IFormattableDocument doc) {
+ EObject semi = appendAfter.getNextSemanticRegion() == null ? null
+ : appendAfter.getNextSemanticRegion().getGrammarElement();
+ if (semi instanceof RuleCall && ((RuleCall) semi).getRule() == grammarAccess.getSemiRule()) {
+ // noop, handled by org.eclipse.n4js.formatting2.N4JSGenericFormatter.formatSemicolons(EObject,
+ // IFormattableDocument)
+ } else {
+ doc.append(appendAfter, hrf -> {
+ hrf.newLine();
+ hrf.setPriority(PRIO_1);
+ });
+ }
+ return appendAfter;
+ }
+
+ static interface InsertSemiBase extends ITextReplacer {
+ // marker interface
+ }
+
+ @Accessors
+ static class InsertSemi implements InsertSemiBase {
+ ITextSegment region;
+ String text;
+
+ public InsertSemi(ITextSegment region, String text) {
+ this.region = region;
+ this.text = text;
+ }
+
+ @Override
+ public ITextReplacerContext createReplacements(ITextReplacerContext context) {
+ context.addReplacement(region.replaceWith(text));
+ return context;
+ }
+
+ @Override
+ public ITextSegment getRegion() {
+ return this.region;
+ }
+
+ public String getText() {
+ return this.text;
+ }
+ }
+
+ static class InsertSemiFollowedByTextReplacer implements InsertSemiBase {
+ InsertSemiBase insertSemi;
+ ITextReplacer textReplacer;
+ ITextSegment region;
+
+ InsertSemiFollowedByTextReplacer(InsertSemiBase insertSemi, ITextReplacer textReplacer) {
+ this.insertSemi = insertSemi;
+ this.textReplacer = textReplacer;
+ this.region = insertSemi.getRegion().merge(textReplacer.getRegion());
+ }
+
+ @Override
+ public ITextReplacerContext createReplacements(ITextReplacerContext context) {
+ // First insert semicolon
+ ITextReplacerContext replContext = insertSemi.createReplacements(context).withReplacer(textReplacer);
+ // Then apply the text replacer
+ return textReplacer.createReplacements(replContext);
+ }
+
+ @Override
+ public ITextSegment getRegion() {
+ return this.region;
+ }
+ }
+
+ static class IndentHandlingTextReplaceMerger extends TextReplacerMerger {
+ private final static Logger LOGGER = Logger.getLogger(IndentHandlingTextReplaceMerger.class);
+
+ AbstractFormatter2 fmt;
+
+ IndentHandlingTextReplaceMerger(AbstractFormatter2 formatter) {
+ super(formatter);
+ fmt = formatter;
+ }
+
+ /**
+ * Overridden for special case of {@link InsertSemi} & {@link HiddenRegionReplacer} merging. Calls super
+ * implementation if no InsertSemi object is involved
+ */
+ @Override
+ public ITextReplacer merge(List conflicting) {
+ if (findFirst(conflicting, tr -> tr instanceof InsertSemiBase) == null) {
+ // standard case, but not handled as we want by super because due to ASI there can be
+ // HiddenRegionReplacer that have equal offsets and length but are not identical.
+ List hrf = toList(filter(conflicting, HiddenRegionReplacer.class));
+ if (hrf.size() == conflicting.size()) {
+ IHiddenRegionFormatting merged = fmt.createHiddenRegionFormattingMerger()
+ .merge(toList(map(hrf, hrr -> hrr.getFormatting())));
+ if (merged != null) {
+ return fmt.createHiddenRegionReplacer(hrf.get(0).getRegion(), merged);
+ }
+ }
+ return super.merge(conflicting);
+ }
+
+ // there is an insertSemi.
+ List semiReplacements = toList(
+ filter(conflicting, tr -> tr instanceof InsertSemiBase));
+ List otherReplacements = toList(
+ filter(conflicting, tr -> !(tr instanceof InsertSemiBase)));
+
+ if (semiReplacements.size() != 1 || otherReplacements.size() != 1) {
+ LOGGER.warn("""
+ Unhandled merge-case: "
+ "Semis replacer («semiReplacements.size») :«semiReplacements»
+ "Non-Semi replacer ( «otherReplacements.size» «otherReplacements»
+ """);
+ return null; // null creates merge Exception
+ }
+ // exactly one:
+ InsertSemiBase semiRepl = (InsertSemiBase) semiReplacements.get(0);
+ ITextReplacer otherRepl = otherReplacements.get(0);
+
+ if (otherRepl instanceof HiddenRegionReplacer) {
+ return new InsertSemiFollowedByTextReplacer(semiRepl, otherRepl);
+ }
+
+ return null;
+ }
+ }
+}
diff --git a/plugins/org.eclipse.n4js/src/org/eclipse/n4js/formatting2/N4JSGenericFormatter.xtend b/plugins/org.eclipse.n4js/src/org/eclipse/n4js/formatting2/N4JSGenericFormatter.xtend
deleted file mode 100644
index 886173e018..0000000000
--- a/plugins/org.eclipse.n4js/src/org/eclipse/n4js/formatting2/N4JSGenericFormatter.xtend
+++ /dev/null
@@ -1,257 +0,0 @@
-/**
- * Copyright (c) 2016 NumberFour AG.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * NumberFour AG - Initial API and implementation
- */
-package org.eclipse.n4js.formatting2
-
-import org.eclipse.n4js.services.N4JSGrammarAccess
-import org.eclipse.emf.ecore.EObject
-import org.eclipse.xtend.lib.annotations.Accessors
-import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
-import org.eclipse.xtext.RuleCall
-import org.eclipse.xtext.formatting2.IFormattableDocument
-import org.eclipse.xtext.formatting2.ITextReplacer
-import org.eclipse.xtext.formatting2.ITextReplacerContext
-import org.eclipse.xtext.formatting2.regionaccess.IHiddenRegion
-import org.eclipse.xtext.formatting2.regionaccess.ISemanticRegion
-import org.eclipse.xtext.formatting2.regionaccess.ITextRegionExtensions
-import org.eclipse.xtext.formatting2.regionaccess.ITextSegment
-import org.eclipse.xtext.formatting2.internal.TextReplacerMerger
-import org.eclipse.xtext.formatting2.AbstractFormatter2
-import java.util.List
-import org.eclipse.n4js.utils.Log
-import org.eclipse.xtext.formatting2.internal.HiddenRegionReplacer
-
-/**
- *
- */
-@FinalFieldsConstructor class N4JSGenericFormatter {
-
- val extension N4JSGrammarAccess
- val extension ITextRegionExtensions
-
- public static val PRIO_1 = -10
- public static val PRIO_2 = -9
- public static val PRIO_3 = -8
-
- def void formatColon(EObject semanticElement, extension IFormattableDocument document) {
- for (colon : semanticElement.allRegionsFor.keywords(":")) {
- colon.prepend[noSpace; newLines = 0; priority = PRIO_3]
- .append[oneSpace; priority = PRIO_2];
- }
- }
-
- /**
- * Formats whitespace around already present semicolons (;) and inserts new semicolons where the parser expects them.
- */
- def void formatSemicolons(EObject script, extension IFormattableDocument document) {
- for (region : script.allRegionsFor.ruleCallsTo(semiRule)) {
- val text = region.text;
- val previous = region.previousHiddenRegion;
- if (text == ";") {
-
- // there is already a ";" so let's format it
- region.prepend[noSpace; newLines = 0; highPriority];
- } else if(region.nextSemanticRegion?.text == "}" && !region.isMultiline){
- // do nothing
- }
- else if (previous.containsComment) {
-
- // we're behind a comment - insert semicolon before the comment
- val insertAt = region.textRegionAccess.regionForOffset(previous.offset, 0)
- document.addReplacer(new InsertSemi(insertAt, ";"));
- } else if (text.trim.isEmpty) {
- // Don't eat up white space here.
- // Look for first line break and replace with ";\n":
- val lbIdx = text.indexOf("\n");
- if( lbIdx >= 0 ) {
- val replaceRegion = region.textRegionAccess.regionForOffset(region.offset, lbIdx+1 );
- document.addReplacer(new InsertSemi(replaceRegion, ";\n"));
- } else {
- // the text region only contains whitespace, e.g. so let's insert a ; and a "\n"
- document.addReplacer(new InsertSemi(region, ";"));
- }
- } else {
-
- // we probably are the comment, so let's prefix it with ;
- val insertAt = region.textRegionAccess.regionForOffset(region.offset, 0);
- document.addReplacer(new InsertSemi(insertAt, ";"));
- }
- }
- }
-
- /**
- * Format whitespace around (), [], and {}
- *
- * When multiple pairs of (), [], or {} open in the same line, indentation is only applied for the innermost pair.
- */
- def void formatParenthesisBracketsAndBraces(EObject script, extension IFormattableDocument document) {
- val all = newArrayList()
- all += script.allRegionsFor.keywordPairs("(", ")")
- all += script.allRegionsFor.keywordPairs("{", "}")
- all += script.allRegionsFor.keywordPairs("[", "]")
-
- val byLine = all.groupBy[key.lineRegions.head.offset]
-
- for (e : byLine.entrySet) {
- val bracePairsInSameLine = e.value.sortBy[key.offset]
- val outermost = bracePairsInSameLine.head
- val innermost = bracePairsInSameLine.last
-
- // keep track of lastOpen/lastClose to avoid formatting the HiddenRegion twice if that hidden region
- // is located directly between two brackets. Then, first.append[] would collide with second.prepend[].
- var IHiddenRegion lastOpen = null
- var IHiddenRegion lastClose = null
- for (pair : bracePairsInSameLine) {
- val open = pair.key
- val close = pair.value
- if (open.previousHiddenRegion != lastOpen && lastOpen !== null) { // something between last opening and this one; null-check for first opening-> don't force noSpace here
- open.prepend[noSpace; priority = PRIO_1]
- }
- if (pair !== innermost) {
- open.append[noSpace; priority = PRIO_1]
- close.prepend[noSpace; priority = PRIO_1]
- }
- if (close.nextHiddenRegion != lastClose) {
- if (pair === outermost) {
-// close.appendNewLine(document)
- } else {
- close.append[noSpace; priority = PRIO_1]
- }
- }
- lastOpen = open.nextHiddenRegion
- lastClose = close.previousHiddenRegion
- }
-
- val ISemanticRegion open = innermost.key;
- val ISemanticRegion close = innermost.value;
- if (open.nextSemanticRegion == close && !open.nextHiddenRegion.isMultiline) { // empty brace-pair
- open.append[noSpace; priority = PRIO_1];
- } // otherwise, if there is a newline before the innermost closing bracket, we want to format the surrounded tokens multiline style.
- else if (close.previousHiddenRegion.isMultiline) {
- close.prepend[newLine; priority = PRIO_1].appendNewLine(document);
- open.append[newLine; priority = PRIO_1];
- innermost.interior[indent];
- for (comma : open.semanticElement.regionFor.keywords(",")) {
- // FIXME: bug in toString: println(comma.toString);
- comma.prepend[noSpace; priority = PRIO_1]
- .append[
- // If dangling comma, then a conflict arises with new line of close.
- // Avoid here by using Prio_2
- setNewLines(1,1,2);
- priority = PRIO_2
- ];
- }
- } // otherwise, format the tokens into a single line.
- else {
- if( document.request.preferences.getPreference( N4JSFormatterPreferenceKeys.FORMAT_SURROUND_PAREN_CONTENT_WITH_SPACE ) ) { // configured way to have single space in parenthesised expression.
- close.prepend[oneSpace; priority = PRIO_1]
- open.append[oneSpace; priority = PRIO_1]
- }
- for (comma : open.semanticElement.regionFor.keywords(",")) {
- comma.prepend[noSpace; priority = PRIO_1].append[oneSpace; priority = PRIO_1]
- }
- }
- }
- }
-
- def ISemanticRegion appendNewLine(ISemanticRegion appendAfter, extension IFormattableDocument doc) {
- val semi = appendAfter.nextSemanticRegion?.grammarElement
- if (semi instanceof RuleCall && (semi as RuleCall)?.rule == semiRule) {
- // noop, handled by org.eclipse.n4js.formatting2.N4JSGenericFormatter.formatSemicolons(EObject, IFormattableDocument)
- } else {
- appendAfter.append[newLine; priority = PRIO_1]
- }
- return appendAfter
- }
-}
-
-interface InsertSemiBase extends ITextReplacer {}
-
-@Accessors class InsertSemi implements InsertSemiBase {
- val ITextSegment region
- val String text
-
- override createReplacements(ITextReplacerContext context) {
- context.addReplacement(region.replaceWith(text))
- return context;
- }
-}
-
-class InsertSemiFollowedByTextReplacer implements InsertSemiBase {
- val InsertSemiBase insertSemi;
- val ITextReplacer textReplacer;
- val ITextSegment region;
-
- new(InsertSemiBase insertSemi, ITextReplacer textReplacer) {
- this.insertSemi = insertSemi;
- this.textReplacer = textReplacer;
- this.region = insertSemi.region.merge(textReplacer.region)
- }
-
- override createReplacements(ITextReplacerContext context) {
- // First insert semicolon
- var replContext = insertSemi.createReplacements(context).withReplacer(textReplacer);
- // Then apply the text replacer
- return textReplacer.createReplacements(replContext);
- }
-
- override getRegion() {
- return this.region;
- }
-}
-
-@Log
-class IndentHandlingTextReplaceMerger extends TextReplacerMerger {
- val AbstractFormatter2 fmt
-
- new(AbstractFormatter2 formatter) {
- super(formatter)
- fmt = formatter
- }
-
- /** Overridden for special case of {@link InsertSemi} & {@link HiddenRegionReplacer} merging.
- * Calls super implementation if no InsertSemi object is involved */
- override merge(List conflicting) {
- if(conflicting.findFirst[it instanceof InsertSemiBase] === null ) {
- // standard case, but not handled as we want by super because due to ASI there can be
- // HiddenRegionReplacer that have equal offsets and length but are not identical.
- val hrf = conflicting.filter(HiddenRegionReplacer).toList
- if(hrf.size === conflicting.size) {
- val merged = fmt.createHiddenRegionFormattingMerger.merge(hrf.map[formatting])
- if(merged !== null) {
- return fmt.createHiddenRegionReplacer(hrf.head.region, merged)
- }
- }
- return super.merge(conflicting);
- }
-
- // there is an insertSemi.
- val semiReplacements = conflicting.filter[it instanceof InsertSemiBase].toList;
- val otherReplacements = conflicting.filter[!(it instanceof InsertSemiBase)].toList;
-
- if( semiReplacements.size !== 1 || otherReplacements.size !== 1 ) {
- logger.warn( '''
- Unhandled merge-case: "
- "Semis replacer («semiReplacements.size») :«semiReplacements»
- "Non-Semi replacer ( «otherReplacements.size» «otherReplacements»
- ''');
- return null; // null creates merge Exception
- }
- // exactly one:
- val semiRepl = semiReplacements.get(0) as InsertSemiBase;
- val otherRepl = otherReplacements.get(0);
-
- if( otherRepl instanceof HiddenRegionReplacer ) {
- return new InsertSemiFollowedByTextReplacer(semiRepl, otherRepl);
- }
-
- return null;
- }
-}