Move the smart indenter over to zero based math.

CyrusNajmabadi · CyrusNajmabadi · commit f4da5d724fb0 · 2015-02-16T18:00:43.000-08:00
diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts
@@ -24,7 +24,7 @@ module ts.formatting {
                 return 0;
             }
 
-            var lineAtPosition = sourceFile.getOneBasedLineAndCharacterOfPosition(position).line;
+            var lineAtPosition = sourceFile.getZeroBasedLineAndCharacterOfPosition(position).line;
 
             if (precedingToken.kind === SyntaxKind.CommaToken && precedingToken.parent.kind !== SyntaxKind.BinaryExpression) {
                 // previous token is comma that separates items in list - find the previous item and try to derive indentation from it
@@ -43,7 +43,7 @@ module ts.formatting {
 
             while (current) {
                 if (positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(current.kind, previous ? previous.kind : SyntaxKind.Unknown)) {
-                    currentStart = getOneBasedStartLineAndCharacterForNode(current, sourceFile);
+                    currentStart = getZeroBasedStartLineAndCharacterForNode(current, sourceFile);
 
                     if (nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile)) {
                         indentationDelta = 0;
@@ -74,7 +74,7 @@ module ts.formatting {
         }
 
         export function getIndentationForNode(n: Node, ignoreActualIndentationRange: TextRange, sourceFile: SourceFile, options: FormatCodeOptions): number {
-            var start = sourceFile.getOneBasedLineAndCharacterOfPosition(n.getStart(sourceFile));
+            var start = sourceFile.getZeroBasedLineAndCharacterOfPosition(n.getStart(sourceFile));
             return getIndentationForNodeWorker(n, start, ignoreActualIndentationRange, /*indentationDelta*/ 0, sourceFile, options);
         }
 
@@ -135,10 +135,10 @@ module ts.formatting {
         function getParentStart(parent: Node, child: Node, sourceFile: SourceFile): LineAndCharacter {
             var containingList = getContainingList(child, sourceFile);
             if (containingList) {
-                return sourceFile.getOneBasedLineAndCharacterOfPosition(containingList.pos);
+                return sourceFile.getZeroBasedLineAndCharacterOfPosition(containingList.pos);
             }
 
-            return sourceFile.getOneBasedLineAndCharacterOfPosition(parent.getStart(sourceFile));
+            return sourceFile.getZeroBasedLineAndCharacterOfPosition(parent.getStart(sourceFile));
         }
 
         /*
@@ -196,15 +196,15 @@ module ts.formatting {
                 // class A {
                 // $}
 
-                var nextTokenStartLine = getOneBasedStartLineAndCharacterForNode(nextToken, sourceFile).line;
+                var nextTokenStartLine = getZeroBasedStartLineAndCharacterForNode(nextToken, sourceFile).line;
                 return lineAtPosition === nextTokenStartLine;
             }
 
             return false;
         }
 
-        function getOneBasedStartLineAndCharacterForNode(n: Node, sourceFile: SourceFile): LineAndCharacter {
-            return sourceFile.getOneBasedLineAndCharacterOfPosition(n.getStart(sourceFile));
+        function getZeroBasedStartLineAndCharacterForNode(n: Node, sourceFile: SourceFile): LineAndCharacter {
+            return sourceFile.getZeroBasedLineAndCharacterOfPosition(n.getStart(sourceFile));
         }
 
         function positionBelongsToNode(candidate: Node, position: number, sourceFile: SourceFile): boolean {
@@ -216,7 +216,7 @@ module ts.formatting {
                 var elseKeyword = findChildOfKind(parent, SyntaxKind.ElseKeyword, sourceFile);
                 Debug.assert(elseKeyword !== undefined);
 
-                var elseKeywordStartLine = getOneBasedStartLineAndCharacterForNode(elseKeyword, sourceFile).line;
+                var elseKeywordStartLine = getZeroBasedStartLineAndCharacterForNode(elseKeyword, sourceFile).line;
                 return elseKeywordStartLine === childStartLine;
             }
 
@@ -279,31 +279,30 @@ module ts.formatting {
             }
         }
 
-
         function deriveActualIndentationFromList(list: Node[], index: number, sourceFile: SourceFile, options: EditorOptions): number {
             Debug.assert(index >= 0 && index < list.length);
             var node = list[index];
 
             // walk toward the start of the list starting from current node and check if the line is the same for all items.
             // if end line for item [i - 1] differs from the start line for item [i] - find column of the first non-whitespace character on the line of item [i]
-            var lineAndCharacter = getOneBasedStartLineAndCharacterForNode(node, sourceFile);
+            var lineAndCharacter = getZeroBasedStartLineAndCharacterForNode(node, sourceFile);
             for (var i = index - 1; i >= 0; --i) {
                 if (list[i].kind === SyntaxKind.CommaToken) {
                     continue;
                 }
                 // skip list items that ends on the same line with the current list element
-                var prevEndLine = sourceFile.getOneBasedLineAndCharacterOfPosition(list[i].end).line;
+                var prevEndLine = sourceFile.getZeroBasedLineAndCharacterOfPosition(list[i].end).line;
                 if (prevEndLine !== lineAndCharacter.line) {
                     return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options);
                 }
 
-                lineAndCharacter = getOneBasedStartLineAndCharacterForNode(list[i], sourceFile);
+                lineAndCharacter = getZeroBasedStartLineAndCharacterForNode(list[i], sourceFile);
             }
             return -1;
         }
 
         function findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter: LineAndCharacter, sourceFile: SourceFile, options: EditorOptions): number {
-            var lineStart = sourceFile.getPositionOfOneBasedLineAndCharacter(lineAndCharacter.line, 1);
+            var lineStart = sourceFile.getPositionOfZeroBasedLineAndCharacter(lineAndCharacter.line, 0);
             return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options);
         }
 
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -64,6 +64,7 @@ module ts {
         getZeroBasedLineAndCharacterOfPosition(pos: number): LineAndCharacter;
         getOneBasedLineAndCharacterOfPosition(pos: number): LineAndCharacter;
         getLineStarts(): number[];
+        getPositionOfZeroBasedLineAndCharacter(line: number, character: number): number;
         getPositionOfOneBasedLineAndCharacter(line: number, character: number): number;
         update(newText: string, textChangeRange: TextChangeRange): SourceFile;
     }
@@ -770,6 +771,10 @@ module ts {
             return ts.getPositionOfOneBasedLineAndCharacter(this, line, character);
         }
 
+        public getPositionOfZeroBasedLineAndCharacter(line: number, character: number): number {
+            return ts.getPositionOfZeroBasedLineAndCharacter(this, line, character);
+        }
+
         public getNamedDeclarations() {
             if (!this.namedDeclarations) {
                 var sourceFile = this;

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ module ts.formatting {`
`24`	`24`	`return 0;`
`25`	`25`	`}`
`26`	`26`
`27`		`- var lineAtPosition = sourceFile.getOneBasedLineAndCharacterOfPosition(position).line;`
	`27`	`+ var lineAtPosition = sourceFile.getZeroBasedLineAndCharacterOfPosition(position).line;`
`28`	`28`
`29`	`29`	`if (precedingToken.kind === SyntaxKind.CommaToken && precedingToken.parent.kind !== SyntaxKind.BinaryExpression) {`
`30`	`30`	`// previous token is comma that separates items in list - find the previous item and try to derive indentation from it`
`@@ -43,7 +43,7 @@ module ts.formatting {`
`43`	`43`
`44`	`44`	`while (current) {`
`45`	`45`	`if (positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(current.kind, previous ? previous.kind : SyntaxKind.Unknown)) {`
`46`		`- currentStart = getOneBasedStartLineAndCharacterForNode(current, sourceFile);`
	`46`	`+ currentStart = getZeroBasedStartLineAndCharacterForNode(current, sourceFile);`
`47`	`47`
`48`	`48`	`if (nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile)) {`
`49`	`49`	`indentationDelta = 0;`
`@@ -74,7 +74,7 @@ module ts.formatting {`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`export function getIndentationForNode(n: Node, ignoreActualIndentationRange: TextRange, sourceFile: SourceFile, options: FormatCodeOptions): number {`
`77`		`- var start = sourceFile.getOneBasedLineAndCharacterOfPosition(n.getStart(sourceFile));`
	`77`	`+ var start = sourceFile.getZeroBasedLineAndCharacterOfPosition(n.getStart(sourceFile));`
`78`	`78`	`return getIndentationForNodeWorker(n, start, ignoreActualIndentationRange, /indentationDelta/ 0, sourceFile, options);`
`79`	`79`	`}`
`80`	`80`
`@@ -135,10 +135,10 @@ module ts.formatting {`
`135`	`135`	`function getParentStart(parent: Node, child: Node, sourceFile: SourceFile): LineAndCharacter {`
`136`	`136`	`var containingList = getContainingList(child, sourceFile);`
`137`	`137`	`if (containingList) {`
`138`		`- return sourceFile.getOneBasedLineAndCharacterOfPosition(containingList.pos);`
	`138`	`+ return sourceFile.getZeroBasedLineAndCharacterOfPosition(containingList.pos);`
`139`	`139`	`}`
`140`	`140`
`141`		`- return sourceFile.getOneBasedLineAndCharacterOfPosition(parent.getStart(sourceFile));`
	`141`	`+ return sourceFile.getZeroBasedLineAndCharacterOfPosition(parent.getStart(sourceFile));`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`/*`
`@@ -196,15 +196,15 @@ module ts.formatting {`
`196`	`196`	`// class A {`
`197`	`197`	`// $}`
`198`	`198`
`199`		`- var nextTokenStartLine = getOneBasedStartLineAndCharacterForNode(nextToken, sourceFile).line;`
	`199`	`+ var nextTokenStartLine = getZeroBasedStartLineAndCharacterForNode(nextToken, sourceFile).line;`
`200`	`200`	`return lineAtPosition === nextTokenStartLine;`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`return false;`
`204`	`204`	`}`
`205`	`205`
`206`		`- function getOneBasedStartLineAndCharacterForNode(n: Node, sourceFile: SourceFile): LineAndCharacter {`
`207`		`- return sourceFile.getOneBasedLineAndCharacterOfPosition(n.getStart(sourceFile));`
	`206`	`+ function getZeroBasedStartLineAndCharacterForNode(n: Node, sourceFile: SourceFile): LineAndCharacter {`
	`207`	`+ return sourceFile.getZeroBasedLineAndCharacterOfPosition(n.getStart(sourceFile));`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`function positionBelongsToNode(candidate: Node, position: number, sourceFile: SourceFile): boolean {`
`@@ -216,7 +216,7 @@ module ts.formatting {`
`216`	`216`	`var elseKeyword = findChildOfKind(parent, SyntaxKind.ElseKeyword, sourceFile);`
`217`	`217`	`Debug.assert(elseKeyword !== undefined);`
`218`	`218`
`219`		`- var elseKeywordStartLine = getOneBasedStartLineAndCharacterForNode(elseKeyword, sourceFile).line;`
	`219`	`+ var elseKeywordStartLine = getZeroBasedStartLineAndCharacterForNode(elseKeyword, sourceFile).line;`
`220`	`220`	`return elseKeywordStartLine === childStartLine;`
`221`	`221`	`}`
`222`	`222`
`@@ -279,31 +279,30 @@ module ts.formatting {`
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`
`282`		`-`
`283`	`282`	`function deriveActualIndentationFromList(list: Node[], index: number, sourceFile: SourceFile, options: EditorOptions): number {`
`284`	`283`	`Debug.assert(index >= 0 && index < list.length);`
`285`	`284`	`var node = list[index];`
`286`	`285`
`287`	`286`	`// walk toward the start of the list starting from current node and check if the line is the same for all items.`
`288`	`287`	`// if end line for item [i - 1] differs from the start line for item [i] - find column of the first non-whitespace character on the line of item [i]`
`289`		`- var lineAndCharacter = getOneBasedStartLineAndCharacterForNode(node, sourceFile);`
	`288`	`+ var lineAndCharacter = getZeroBasedStartLineAndCharacterForNode(node, sourceFile);`
`290`	`289`	`for (var i = index - 1; i >= 0; --i) {`
`291`	`290`	`if (list[i].kind === SyntaxKind.CommaToken) {`
`292`	`291`	`continue;`
`293`	`292`	`}`
`294`	`293`	`// skip list items that ends on the same line with the current list element`
`295`		`- var prevEndLine = sourceFile.getOneBasedLineAndCharacterOfPosition(list[i].end).line;`
	`294`	`+ var prevEndLine = sourceFile.getZeroBasedLineAndCharacterOfPosition(list[i].end).line;`
`296`	`295`	`if (prevEndLine !== lineAndCharacter.line) {`
`297`	`296`	`return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options);`
`298`	`297`	`}`
`299`	`298`
`300`		`- lineAndCharacter = getOneBasedStartLineAndCharacterForNode(list[i], sourceFile);`
	`299`	`+ lineAndCharacter = getZeroBasedStartLineAndCharacterForNode(list[i], sourceFile);`
`301`	`300`	`}`
`302`	`301`	`return -1;`
`303`	`302`	`}`
`304`	`303`
`305`	`304`	`function findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter: LineAndCharacter, sourceFile: SourceFile, options: EditorOptions): number {`
`306`		`- var lineStart = sourceFile.getPositionOfOneBasedLineAndCharacter(lineAndCharacter.line, 1);`
	`305`	`+ var lineStart = sourceFile.getPositionOfZeroBasedLineAndCharacter(lineAndCharacter.line, 0);`
`307`	`306`	`return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options);`
`308`	`307`	`}`
`309`	`308`