Use 'push' and 'pop' methods instead of using array.length (microsoft#16979)

Andy · web-flow · commit 81f8151e3a28 · 2017-07-07T10:22:59.000-07:00
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -1733,7 +1733,7 @@ namespace ts {
         if (directoryComponents.length > 1 && lastOrUndefined(directoryComponents) === "") {
             // If the directory path given was of type test/cases/ then we really need components of directory to be only till its name
             // that is  ["test", "cases", ""] needs to be actually ["test", "cases"]
-            directoryComponents.length--;
+            directoryComponents.pop();
         }
 
         // Find the component that differs
diff --git a/src/server/scriptVersionCache.ts b/src/server/scriptVersionCache.ts
@@ -80,7 +80,7 @@ namespace ts.server {
             const lines = lm.lines;
             if (lines.length > 1) {
                 if (lines[lines.length - 1] === "") {
-                    lines.length--;
+                    lines.pop();
                 }
             }
             let branchParent: LineNode;
@@ -157,7 +157,7 @@ namespace ts.server {
                 this.state = CharRangeSection.End;
             }
             // always pop stack because post only called when child has been visited
-            this.stack.length--;
+            this.stack.pop();
             return undefined;
         }
 
@@ -193,20 +193,20 @@ namespace ts.server {
                     else {
                         child = fresh(lineCollection);
                         currentNode.add(child);
-                        this.startPath[this.startPath.length] = child;
+                        this.startPath.push(child);
                     }
                     break;
                 case CharRangeSection.Entire:
                     if (this.state !== CharRangeSection.End) {
                         child = fresh(lineCollection);
                         currentNode.add(child);
-                        this.startPath[this.startPath.length] = child;
+                        this.startPath.push(child);
                     }
                     else {
                         if (!lineCollection.isLeaf()) {
                             child = fresh(lineCollection);
                             currentNode.add(child);
-                            this.endBranch[this.endBranch.length] = child;
+                            this.endBranch.push(child);
                         }
                     }
                     break;
@@ -221,7 +221,7 @@ namespace ts.server {
                         if (!lineCollection.isLeaf()) {
                             child = fresh(lineCollection);
                             currentNode.add(child);
-                            this.endBranch[this.endBranch.length] = child;
+                            this.endBranch.push(child);
                         }
                     }
                     break;
@@ -233,7 +233,7 @@ namespace ts.server {
                     break;
             }
             if (this.goSubtree) {
-                this.stack[this.stack.length] = <LineNode>child;
+                this.stack.push(<LineNode>child);
             }
             return lineCollection;
         }
@@ -289,7 +289,7 @@ namespace ts.server {
 
         // REVIEW: can optimize by coalescing simple edits
         edit(pos: number, deleteLen: number, insertedText?: string) {
-            this.changes[this.changes.length] = new TextChange(pos, deleteLen, insertedText);
+            this.changes.push(new TextChange(pos, deleteLen, insertedText));
             if ((this.changes.length > ScriptVersionCache.changeNumberThreshold) ||
                 (deleteLen > ScriptVersionCache.changeLengthThreshold) ||
                 (insertedText && (insertedText.length > ScriptVersionCache.changeLengthThreshold))) {
@@ -366,7 +366,7 @@ namespace ts.server {
                     for (let i = oldVersion + 1; i <= newVersion; i++) {
                         const snap = this.versions[this.versionToIndex(i)];
                         for (const textChange of snap.changesSincePreviousVersion) {
-                            textChangeRanges[textChangeRanges.length] = textChange.getTextChangeRange();
+                            textChangeRanges.push(textChange.getTextChangeRange());
                         }
                     }
                     return ts.collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges);
@@ -623,7 +623,7 @@ namespace ts.server {
                 lines[lc] = endText;
             }
             else {
-                lines.length--;
+                lines.pop();
             }
             return { lines, lineMap };
         }
@@ -836,7 +836,7 @@ namespace ts.server {
                     this.children[i] = this.children[i + 1];
                 }
             }
-            this.children.length--;
+            this.children.pop();
         }
 
         private findChildIndex(child: LineCollection) {
@@ -884,12 +884,12 @@ namespace ts.server {
                     }
                     for (let i = splitNodes.length - 1; i >= 0; i--) {
                         if (splitNodes[i].children.length === 0) {
-                            splitNodes.length--;
+                            splitNodes.pop();
                         }
                     }
                 }
                 if (shiftNode) {
-                    splitNodes[splitNodes.length] = shiftNode;
+                    splitNodes.push(shiftNode);
                 }
                 this.updateCounts();
                 for (let i = 0; i < splitNodeCount; i++) {
@@ -901,7 +901,7 @@ namespace ts.server {
 
         // assume there is room for the item; return true if more room
         add(collection: LineCollection) {
-            this.children[this.children.length] = collection;
+            this.children.push(collection);
             return (this.children.length < lineCollectionCapacity);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1733,7 +1733,7 @@ namespace ts {`
`1733`	`1733`	`if (directoryComponents.length > 1 && lastOrUndefined(directoryComponents) === "") {`
`1734`	`1734`	`// If the directory path given was of type test/cases/ then we really need components of directory to be only till its name`
`1735`	`1735`	`// that is ["test", "cases", ""] needs to be actually ["test", "cases"]`
`1736`		`- directoryComponents.length--;`
	`1736`	`+ directoryComponents.pop();`
`1737`	`1737`	`}`
`1738`	`1738`
`1739`	`1739`	`// Find the component that differs`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ namespace ts.server {`
`80`	`80`	`const lines = lm.lines;`
`81`	`81`	`if (lines.length > 1) {`
`82`	`82`	`if (lines[lines.length - 1] === "") {`
`83`		`- lines.length--;`
	`83`	`+ lines.pop();`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`	`let branchParent: LineNode;`
`@@ -157,7 +157,7 @@ namespace ts.server {`
`157`	`157`	`this.state = CharRangeSection.End;`
`158`	`158`	`}`
`159`	`159`	`// always pop stack because post only called when child has been visited`
`160`		`- this.stack.length--;`
	`160`	`+ this.stack.pop();`
`161`	`161`	`return undefined;`
`162`	`162`	`}`
`163`	`163`
`@@ -193,20 +193,20 @@ namespace ts.server {`
`193`	`193`	`else {`
`194`	`194`	`child = fresh(lineCollection);`
`195`	`195`	`currentNode.add(child);`
`196`		`- this.startPath[this.startPath.length] = child;`
	`196`	`+ this.startPath.push(child);`
`197`	`197`	`}`
`198`	`198`	`break;`
`199`	`199`	`case CharRangeSection.Entire:`
`200`	`200`	`if (this.state !== CharRangeSection.End) {`
`201`	`201`	`child = fresh(lineCollection);`
`202`	`202`	`currentNode.add(child);`
`203`		`- this.startPath[this.startPath.length] = child;`
	`203`	`+ this.startPath.push(child);`
`204`	`204`	`}`
`205`	`205`	`else {`
`206`	`206`	`if (!lineCollection.isLeaf()) {`
`207`	`207`	`child = fresh(lineCollection);`
`208`	`208`	`currentNode.add(child);`
`209`		`- this.endBranch[this.endBranch.length] = child;`
	`209`	`+ this.endBranch.push(child);`
`210`	`210`	`}`
`211`	`211`	`}`
`212`	`212`	`break;`
`@@ -221,7 +221,7 @@ namespace ts.server {`
`221`	`221`	`if (!lineCollection.isLeaf()) {`
`222`	`222`	`child = fresh(lineCollection);`
`223`	`223`	`currentNode.add(child);`
`224`		`- this.endBranch[this.endBranch.length] = child;`
	`224`	`+ this.endBranch.push(child);`
`225`	`225`	`}`
`226`	`226`	`}`
`227`	`227`	`break;`
`@@ -233,7 +233,7 @@ namespace ts.server {`
`233`	`233`	`break;`
`234`	`234`	`}`
`235`	`235`	`if (this.goSubtree) {`
`236`		`- this.stack[this.stack.length] = <LineNode>child;`
	`236`	`+ this.stack.push(<LineNode>child);`
`237`	`237`	`}`
`238`	`238`	`return lineCollection;`
`239`	`239`	`}`
`@@ -289,7 +289,7 @@ namespace ts.server {`
`289`	`289`
`290`	`290`	`// REVIEW: can optimize by coalescing simple edits`
`291`	`291`	`edit(pos: number, deleteLen: number, insertedText?: string) {`
`292`		`- this.changes[this.changes.length] = new TextChange(pos, deleteLen, insertedText);`
	`292`	`+ this.changes.push(new TextChange(pos, deleteLen, insertedText));`
`293`	`293`	`if ((this.changes.length > ScriptVersionCache.changeNumberThreshold) \|\|`
`294`	`294`	`(deleteLen > ScriptVersionCache.changeLengthThreshold) \|\|`
`295`	`295`	`(insertedText && (insertedText.length > ScriptVersionCache.changeLengthThreshold))) {`
`@@ -366,7 +366,7 @@ namespace ts.server {`
`366`	`366`	`for (let i = oldVersion + 1; i <= newVersion; i++) {`
`367`	`367`	`const snap = this.versions[this.versionToIndex(i)];`
`368`	`368`	`for (const textChange of snap.changesSincePreviousVersion) {`
`369`		`- textChangeRanges[textChangeRanges.length] = textChange.getTextChangeRange();`
	`369`	`+ textChangeRanges.push(textChange.getTextChangeRange());`
`370`	`370`	`}`
`371`	`371`	`}`
`372`	`372`	`return ts.collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges);`
`@@ -623,7 +623,7 @@ namespace ts.server {`
`623`	`623`	`lines[lc] = endText;`
`624`	`624`	`}`
`625`	`625`	`else {`
`626`		`- lines.length--;`
	`626`	`+ lines.pop();`
`627`	`627`	`}`
`628`	`628`	`return { lines, lineMap };`
`629`	`629`	`}`
`@@ -836,7 +836,7 @@ namespace ts.server {`
`836`	`836`	`this.children[i] = this.children[i + 1];`
`837`	`837`	`}`
`838`	`838`	`}`
`839`		`- this.children.length--;`
	`839`	`+ this.children.pop();`
`840`	`840`	`}`
`841`	`841`
`842`	`842`	`private findChildIndex(child: LineCollection) {`
`@@ -884,12 +884,12 @@ namespace ts.server {`
`884`	`884`	`}`
`885`	`885`	`for (let i = splitNodes.length - 1; i >= 0; i--) {`
`886`	`886`	`if (splitNodes[i].children.length === 0) {`
`887`		`- splitNodes.length--;`
	`887`	`+ splitNodes.pop();`
`888`	`888`	`}`
`889`	`889`	`}`
`890`	`890`	`}`
`891`	`891`	`if (shiftNode) {`
`892`		`- splitNodes[splitNodes.length] = shiftNode;`
	`892`	`+ splitNodes.push(shiftNode);`
`893`	`893`	`}`
`894`	`894`	`this.updateCounts();`
`895`	`895`	`for (let i = 0; i < splitNodeCount; i++) {`
`@@ -901,7 +901,7 @@ namespace ts.server {`
`901`	`901`
`902`	`902`	`// assume there is room for the item; return true if more room`
`903`	`903`	`add(collection: LineCollection) {`
`904`		`- this.children[this.children.length] = collection;`
	`904`	`+ this.children.push(collection);`
`905`	`905`	`return (this.children.length < lineCollectionCapacity);`
`906`	`906`	`}`
`907`	`907`