add formatting options to shouldIndentChildNode

saschanaz · saschanaz · commit d72e49a7195b · 2016-12-17T14:15:42.000+09:00
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
@@ -349,6 +349,7 @@ namespace FourSlash {
                 insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
                 insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
                 insertSpaceAfterTypeAssertion: false,
+                indentInsideTernaryOperator: false,
                 placeOpenBraceOnNewLineForFunctions: false,
                 placeOpenBraceOnNewLineForControlBlocks: false,
             };
diff --git a/src/server/utilities.ts b/src/server/utilities.ts
@@ -85,8 +85,11 @@ namespace ts.server {
             insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
             insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
             insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+            insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
             insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
             insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
+            insertSpaceAfterTypeAssertion: false,
+            indentInsideTernaryOperator: false,
             placeOpenBraceOnNewLineForFunctions: false,
             placeOpenBraceOnNewLineForControlBlocks: false,
         };
diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts
@@ -303,7 +303,7 @@ namespace ts.formatting {
                 break;
             }
 
-            if (SmartIndenter.shouldIndentChildNode(n, child)) {
+            if (SmartIndenter.shouldIndentChildNode(n, options, child)) {
                 return options.indentSize;
             }
 
@@ -413,7 +413,7 @@ namespace ts.formatting {
             effectiveParentStartLine: number): Indentation {
 
             let indentation = inheritedIndentation;
-            let delta = SmartIndenter.shouldIndentChildNode(node) ? options.indentSize : 0;
+            let delta = SmartIndenter.shouldIndentChildNode(node, options) ? options.indentSize : 0;
 
             if (effectiveParentStartLine === startLine) {
                 // if node is located on the same line with the parent
@@ -504,15 +504,15 @@ namespace ts.formatting {
                 getIndentation: () => indentation,
                 getDelta: child => getEffectiveDelta(delta, child),
                 recomputeIndentation: lineAdded => {
-                    if (node.parent && SmartIndenter.shouldIndentChildNode(node.parent, node)) {
+                    if (node.parent && SmartIndenter.shouldIndentChildNode(node.parent, options, node)) {
                         if (lineAdded) {
                             indentation += options.indentSize;
                         }
                         else {
                             indentation -= options.indentSize;
                         }
 
-                        if (SmartIndenter.shouldIndentChildNode(node)) {
+                        if (SmartIndenter.shouldIndentChildNode(node, options)) {
                             delta = options.indentSize;
                         }
                         else {
@@ -524,7 +524,7 @@ namespace ts.formatting {
 
             function getEffectiveDelta(delta: number, child: TextRangeWithKind) {
                 // Delta value should be zero when the node explicitly prevents indentation of the child node
-                return SmartIndenter.nodeWillIndentChild(node, child, true) ? delta : 0;
+                return SmartIndenter.nodeWillIndentChild(node, child, true, options) ? delta : 0;
             }
         }
 
diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts
@@ -8,7 +8,7 @@ namespace ts.formatting {
             Unknown = -1
         }
 
-        export function getIndentation(position: number, sourceFile: SourceFile, options: EditorSettings): number {
+        export function getIndentation(position: number, sourceFile: SourceFile, options: FormatCodeSettings): number {
             if (position > sourceFile.text.length) {
                 return getBaseIndentation(options); // past EOF
             }
@@ -68,7 +68,7 @@ namespace ts.formatting {
             let indentationDelta: number;
 
             while (current) {
-                if (positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(current, previous)) {
+                if (positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(current, options, previous)) {
                     currentStart = getStartLineAndCharacterForNode(current, sourceFile);
 
                     if (nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile)) {
@@ -118,7 +118,7 @@ namespace ts.formatting {
             ignoreActualIndentationRange: TextRange,
             indentationDelta: number,
             sourceFile: SourceFile,
-            options: EditorSettings): number {
+            options: FormatCodeSettings): number {
 
             let parent: Node = current.parent;
             let parentStart: LineAndCharacter;
@@ -157,7 +157,7 @@ namespace ts.formatting {
                 }
 
                 // increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line
-                if (shouldIndentChildNode(parent, current) && !parentAndChildShareLine) {
+                if (shouldIndentChildNode(parent, options, current) && !parentAndChildShareLine) {
                     indentationDelta += options.indentSize;
                 }
 
@@ -474,7 +474,7 @@ namespace ts.formatting {
         }
 
         /* @internal */
-        export function nodeWillIndentChild(parent: TextRangeWithKind, child: TextRangeWithKind, indentByDefault: boolean) {
+        export function nodeWillIndentChild(parent: TextRangeWithKind, child: TextRangeWithKind, indentByDefault: boolean, options: FormatCodeSettings) {
             const childKind = child ? child.kind : SyntaxKind.Unknown;
             switch (parent.kind) {
                 case SyntaxKind.DoStatement:
@@ -492,7 +492,7 @@ namespace ts.formatting {
                 case SyntaxKind.SetAccessor:
                     return childKind !== SyntaxKind.Block;
                 case SyntaxKind.ConditionalExpression:
-                    return (parent as ConditionalExpression).whenFalse !== child;
+                    return options.indentInsideTernaryOperator || (parent as ConditionalExpression).whenFalse !== child;
                 case SyntaxKind.ExportDeclaration:
                     return childKind !== SyntaxKind.NamedExports;
                 case SyntaxKind.ImportDeclaration:
@@ -508,8 +508,8 @@ namespace ts.formatting {
         /*
         Function returns true when the parent node should indent the given child by an explicit rule
         */
-        export function shouldIndentChildNode(parent: TextRangeWithKind, child?: TextRangeWithKind): boolean {
-            return nodeContentIsAlwaysIndented(parent.kind) || nodeWillIndentChild(parent, child, /*indentByDefault*/ false);
+        export function shouldIndentChildNode(parent: TextRangeWithKind, options: FormatCodeSettings, child?: TextRangeWithKind): boolean {
+            return nodeContentIsAlwaysIndented(parent.kind) || nodeWillIndentChild(parent, child, /*indentByDefault*/ false, options);
         }
     }
 }
diff --git a/src/services/types.ts b/src/services/types.ts
@@ -233,7 +233,7 @@ namespace ts {
         getOutliningSpans(fileName: string): OutliningSpan[];
         getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
         getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
-        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | EditorSettings): number;
+        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | FormatCodeSettings): number;
 
         getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
         getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
@@ -442,6 +442,7 @@ namespace ts {
         insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
         insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
         insertSpaceAfterTypeAssertion?: boolean;
+        indentInsideTernaryOperator?: boolean;
         placeOpenBraceOnNewLineForFunctions?: boolean;
         placeOpenBraceOnNewLineForControlBlocks?: boolean;
     }
diff --git a/tests/cases/fourslash/formattingOptionsChangeTernary.ts b/tests/cases/fourslash/formattingOptionsChangeTernary.ts
@@ -0,0 +1,44 @@
+///<reference path="fourslash.ts"/>
+
+////const expectedScanAction =
+////    shouldRescanGreaterThanToken(n)
+////    ? ScanAction.RescanGreaterThanToken
+////    : shouldRescanSlashToken(n)
+////    ? ScanAction.RescanSlashToken
+////    : shouldRescanTemplateToken(n)
+////    ? ScanAction.RescanTemplateToken
+////    : shouldRescanJsxIdentifier(n)
+////    ? ScanAction.RescanJsxIdentifier
+////    : shouldRescanJsxText(n)
+////    ? ScanAction.RescanJsxText
+////    : ScanAction.Scan;
+
+format.setOption("indentInsideTernaryOperator", false);
+format.document();
+verify.currentFileContentIs(`const expectedScanAction =
+    shouldRescanGreaterThanToken(n)
+        ? ScanAction.RescanGreaterThanToken
+        : shouldRescanSlashToken(n)
+        ? ScanAction.RescanSlashToken
+        : shouldRescanTemplateToken(n)
+        ? ScanAction.RescanTemplateToken
+        : shouldRescanJsxIdentifier(n)
+        ? ScanAction.RescanJsxIdentifier
+        : shouldRescanJsxText(n)
+        ? ScanAction.RescanJsxText
+        : ScanAction.Scan;`)
+
+format.setOption("indentInsideTernaryOperator", true);
+format.document();
+verify.currentFileContentIs(`const expectedScanAction =
+    shouldRescanGreaterThanToken(n)
+        ? ScanAction.RescanGreaterThanToken
+        : shouldRescanSlashToken(n)
+            ? ScanAction.RescanSlashToken
+            : shouldRescanTemplateToken(n)
+                ? ScanAction.RescanTemplateToken
+                : shouldRescanJsxIdentifier(n)
+                    ? ScanAction.RescanJsxIdentifier
+                    : shouldRescanJsxText(n)
+                        ? ScanAction.RescanJsxText
+                        : ScanAction.Scan;`)

Original file line number	Diff line number	Diff line change
`@@ -303,7 +303,7 @@ namespace ts.formatting {`
`303`	`303`	`break;`
`304`	`304`	`}`
`305`	`305`
`306`		`- if (SmartIndenter.shouldIndentChildNode(n, child)) {`
	`306`	`+ if (SmartIndenter.shouldIndentChildNode(n, options, child)) {`
`307`	`307`	`return options.indentSize;`
`308`	`308`	`}`
`309`	`309`
`@@ -413,7 +413,7 @@ namespace ts.formatting {`
`413`	`413`	`effectiveParentStartLine: number): Indentation {`
`414`	`414`
`415`	`415`	`let indentation = inheritedIndentation;`
`416`		`- let delta = SmartIndenter.shouldIndentChildNode(node) ? options.indentSize : 0;`
	`416`	`+ let delta = SmartIndenter.shouldIndentChildNode(node, options) ? options.indentSize : 0;`
`417`	`417`
`418`	`418`	`if (effectiveParentStartLine === startLine) {`
`419`	`419`	`// if node is located on the same line with the parent`
`@@ -504,15 +504,15 @@ namespace ts.formatting {`
`504`	`504`	`getIndentation: () => indentation,`
`505`	`505`	`getDelta: child => getEffectiveDelta(delta, child),`
`506`	`506`	`recomputeIndentation: lineAdded => {`
`507`		`- if (node.parent && SmartIndenter.shouldIndentChildNode(node.parent, node)) {`
	`507`	`+ if (node.parent && SmartIndenter.shouldIndentChildNode(node.parent, options, node)) {`
`508`	`508`	`if (lineAdded) {`
`509`	`509`	`indentation += options.indentSize;`
`510`	`510`	`}`
`511`	`511`	`else {`
`512`	`512`	`indentation -= options.indentSize;`
`513`	`513`	`}`
`514`	`514`
`515`		`- if (SmartIndenter.shouldIndentChildNode(node)) {`
	`515`	`+ if (SmartIndenter.shouldIndentChildNode(node, options)) {`
`516`	`516`	`delta = options.indentSize;`
`517`	`517`	`}`
`518`	`518`	`else {`
`@@ -524,7 +524,7 @@ namespace ts.formatting {`
`524`	`524`
`525`	`525`	`function getEffectiveDelta(delta: number, child: TextRangeWithKind) {`
`526`	`526`	`// Delta value should be zero when the node explicitly prevents indentation of the child node`
`527`		`- return SmartIndenter.nodeWillIndentChild(node, child, true) ? delta : 0;`
	`527`	`+ return SmartIndenter.nodeWillIndentChild(node, child, true, options) ? delta : 0;`
`528`	`528`	`}`
`529`	`529`	`}`
`530`	`530`