Merge pull request #2996 from Microsoft/lastOrUndefinedReplacement

DanielRosenwasser · DanielRosenwasser · commit 4cc1848a174e · 2015-05-03T22:28:51.000-07:00
Replace awkward last-element selection pattern with 'lastOrUndefined'
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -3182,7 +3182,7 @@ module ts {
 
         function getRestTypeOfSignature(signature: Signature): Type {
             if (signature.hasRestParameter) {
-                let type = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
+                let type = getTypeOfSymbol(lastOrUndefined(signature.parameters));
                 if (type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayType) {
                     return (<TypeReference>type).typeArguments[0];
                 }
@@ -5666,7 +5666,7 @@ module ts {
                         // If last parameter is contextually rest parameter get its type
                         if (indexOfParameter === (func.parameters.length - 1) &&
                             funcHasRestParameters && contextualSignature.hasRestParameter && func.parameters.length >= contextualSignature.parameters.length) {
-                            return getTypeOfSymbol(contextualSignature.parameters[contextualSignature.parameters.length - 1]);
+                            return getTypeOfSymbol(lastOrUndefined(contextualSignature.parameters));
                         }
                     }
                 }
@@ -7215,9 +7215,9 @@ module ts {
                 links.type = instantiateType(getTypeAtPosition(context, i), mapper);
             }
             if (signature.hasRestParameter && context.hasRestParameter && signature.parameters.length >= context.parameters.length) {
-                let parameter = signature.parameters[signature.parameters.length - 1];
+                let parameter = lastOrUndefined(signature.parameters);
                 let links = getSymbolLinks(parameter);
-                links.type = instantiateType(getTypeOfSymbol(context.parameters[context.parameters.length - 1]), mapper);
+                links.type = instantiateType(getTypeOfSymbol(lastOrUndefined(context.parameters)), mapper);
             }
         }
 
@@ -12829,7 +12829,7 @@ module ts {
         function checkGrammarBindingElement(node: BindingElement) {
             if (node.dotDotDotToken) {
                 let elements = (<BindingPattern>node.parent).elements;
-                if (node !== elements[elements.length - 1]) {
+                if (node !== lastOrUndefined(elements)) {
                     return grammarErrorOnNode(node, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
                 }
 
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -470,7 +470,7 @@ module ts {
         let normalized: string[] = [];
         for (let part of parts) {
             if (part !== ".") {
-                if (part === ".." && normalized.length > 0 && normalized[normalized.length - 1] !== "..") {
+                if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {
                     normalized.pop();
                 }
                 else {
@@ -586,7 +586,7 @@ module ts {
     export function getRelativePathToDirectoryOrUrl(directoryPathOrUrl: string, relativeOrAbsolutePath: string, currentDirectory: string, getCanonicalFileName: (fileName: string) => string, isAbsolutePathAnUrl: boolean) {
         let pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory);
         let directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory);
-        if (directoryComponents.length > 1 && directoryComponents[directoryComponents.length - 1] === "") {
+        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--;
diff --git a/src/compiler/emitter.js b/src/compiler/emitter.js
@@ -267,7 +267,7 @@ var ts;
                 var sourceMapNameIndexMap = {};
                 var sourceMapNameIndices = [];
                 function getSourceMapNameIndex() {
-                    return sourceMapNameIndices.length ? sourceMapNameIndices[sourceMapNameIndices.length - 1] : -1;
+                    return sourceMapNameIndices.length ? lastOrUndefined(sourceMapNameIndices) : -1;
                 }
                 // Last recorded and encoded spans
                 var lastRecordedSourceMapSpan;
@@ -5084,11 +5084,11 @@ var ts;
                 }
             }
             function hasDetachedComments(pos) {
-                return detachedCommentsInfo !== undefined && detachedCommentsInfo[detachedCommentsInfo.length - 1].nodePos === pos;
+                return detachedCommentsInfo !== undefined && lastOrUndefined(detachedCommentsInfo).nodePos === pos;
             }
             function getLeadingCommentsWithoutDetachedComments() {
                 // get the leading comments from detachedPos
-                var leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, detachedCommentsInfo[detachedCommentsInfo.length - 1].detachedCommentEndPos);
+                var leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, lastOrUndefined(detachedCommentsInfo).detachedCommentEndPos);
                 if (detachedCommentsInfo.length - 1) {
                     detachedCommentsInfo.pop();
                 }
@@ -5189,13 +5189,13 @@ var ts;
                         // All comments look like they could have been part of the copyright header.  Make
                         // sure there is at least one blank line between it and the node.  If not, it's not
                         // a copyright header.
-                        var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, detachedComments[detachedComments.length - 1].end);
+                        var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, lastOrUndefined(detachedComments).end);
                         var nodeLine = ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
                         if (nodeLine >= lastCommentLine + 2) {
                             // Valid detachedComments
                             ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
                             ts.emitComments(currentSourceFile, writer, detachedComments, true, newLine, writeComment);
-                            var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: detachedComments[detachedComments.length - 1].end };
+                            var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: lastOrUndefined(detachedComments).end };
                             if (detachedCommentsInfo) {
                                 detachedCommentsInfo.push(currentDetachedCommentInfo);
                             }
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -336,7 +336,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                 let sourceMapNameIndexMap: Map<number> = {};
                 let sourceMapNameIndices: number[] = [];
                 function getSourceMapNameIndex() {
-                    return sourceMapNameIndices.length ? sourceMapNameIndices[sourceMapNameIndices.length - 1] : -1;
+                    return sourceMapNameIndices.length ? lastOrUndefined(sourceMapNameIndices) : -1;
                 }
 
                 // Last recorded and encoded spans
@@ -5890,13 +5890,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
             }
 
             function hasDetachedComments(pos: number) {
-                return detachedCommentsInfo !== undefined && detachedCommentsInfo[detachedCommentsInfo.length - 1].nodePos === pos;
+                return detachedCommentsInfo !== undefined && lastOrUndefined(detachedCommentsInfo).nodePos === pos;
             }
 
             function getLeadingCommentsWithoutDetachedComments() {
                 // get the leading comments from detachedPos
                 let leadingComments = getLeadingCommentRanges(currentSourceFile.text,
-                    detachedCommentsInfo[detachedCommentsInfo.length - 1].detachedCommentEndPos);
+                    lastOrUndefined(detachedCommentsInfo).detachedCommentEndPos);
                 if (detachedCommentsInfo.length - 1) {
                     detachedCommentsInfo.pop();
                 }
@@ -6017,13 +6017,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                         // All comments look like they could have been part of the copyright header.  Make
                         // sure there is at least one blank line between it and the node.  If not, it's not
                         // a copyright header.
-                        let lastCommentLine = getLineOfLocalPosition(currentSourceFile, detachedComments[detachedComments.length - 1].end);
+                        let lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastOrUndefined(detachedComments).end);
                         let nodeLine = getLineOfLocalPosition(currentSourceFile, skipTrivia(currentSourceFile.text, node.pos));
                         if (nodeLine >= lastCommentLine + 2) {
                             // Valid detachedComments
                             emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
                             emitComments(currentSourceFile, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
-                            let currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: detachedComments[detachedComments.length - 1].end };
+                            let currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: lastOrUndefined(detachedComments).end };
                             if (detachedCommentsInfo) {
                                 detachedCommentsInfo.push(currentDetachedCommentInfo);
                             }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -1691,7 +1691,7 @@ module ts {
             do {
                 templateSpans.push(parseTemplateSpan());
             }
-            while (templateSpans[templateSpans.length - 1].literal.kind === SyntaxKind.TemplateMiddle)
+            while (lastOrUndefined(templateSpans).literal.kind === SyntaxKind.TemplateMiddle)
 
             templateSpans.end = getNodeEnd();
             template.templateSpans = templateSpans;
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
@@ -522,7 +522,7 @@ module ts {
                     }
                     collecting = true;
                     if (result && result.length) {
-                        result[result.length - 1].hasTrailingNewLine = true;
+                        lastOrUndefined(result).hasTrailingNewLine = true;
                     }
                     continue;
                 case CharacterCodes.tab:
@@ -569,7 +569,7 @@ module ts {
                 default:
                     if (ch > CharacterCodes.maxAsciiCharacter && (isWhiteSpace(ch) || isLineBreak(ch))) {
                         if (result && result.length && isLineBreak(ch)) {
-                            result[result.length - 1].hasTrailingNewLine = true;
+                            lastOrUndefined(result).hasTrailingNewLine = true;
                         }
                         pos++;
                         continue;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -856,7 +856,7 @@ module ts {
     }
 
     export function hasRestParameters(s: SignatureDeclaration): boolean {
-        return s.parameters.length > 0 && s.parameters[s.parameters.length - 1].dotDotDotToken !== undefined;
+        return s.parameters.length > 0 && lastOrUndefined(s.parameters).dotDotDotToken !== undefined;
     }
 
     export function isLiteralKind(kind: SyntaxKind): boolean {
@@ -1362,7 +1362,7 @@ module ts {
                 let lineStartsOfS = computeLineStarts(s);
                 if (lineStartsOfS.length > 1) {
                     lineCount = lineCount + lineStartsOfS.length - 1;
-                    linePos = output.length - s.length + lineStartsOfS[lineStartsOfS.length - 1];
+                    linePos = output.length - s.length + lastOrUndefined(lineStartsOfS);
                 }
             }
         }
@@ -1727,8 +1727,8 @@ module ts {
                 output.push(((charCode >> 6) & 0B00111111) | 0B10000000);
                 output.push((charCode & 0B00111111) | 0B10000000);
             }
-            else {
-                Debug.assert(false, "Unexpected code point");
+            else {
+                Debug.assert(false, "Unexpected code point");
             }
         }
 
diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts
@@ -446,14 +446,14 @@ module ts.BreakpointResolver {
                         // fall through.
 
                     case SyntaxKind.CatchClause:
-                        return spanInNode((<Block>node.parent).statements[(<Block>node.parent).statements.length - 1]);;
+                        return spanInNode(lastOrUndefined((<Block>node.parent).statements));;
 
                     case SyntaxKind.CaseBlock:
                         // breakpoint in last statement of the last clause
                         let caseBlock = <CaseBlock>node.parent;
-                        let lastClause = caseBlock.clauses[caseBlock.clauses.length - 1];
+                        let lastClause = lastOrUndefined(caseBlock.clauses);
                         if (lastClause) {
-                            return spanInNode(lastClause.statements[lastClause.statements.length - 1]);
+                            return spanInNode(lastOrUndefined(lastClause.statements));
                         }
                         return undefined;
 
diff --git a/src/services/formatting/formattingScanner.ts b/src/services/formatting/formattingScanner.ts
@@ -51,7 +51,7 @@ module ts.formatting {
             if (isStarted) {
                 if (trailingTrivia) {
                     Debug.assert(trailingTrivia.length !== 0);
-                    wasNewLine = trailingTrivia[trailingTrivia.length - 1].kind === SyntaxKind.NewLineTrivia;
+                    wasNewLine = lastOrUndefined(trailingTrivia).kind === SyntaxKind.NewLineTrivia;
                 }
                 else {
                     wasNewLine = false;
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -4058,7 +4058,7 @@ module ts {
                     return true;
                 }
                 else if (declarations.length) {
-                    result.push(createDefinitionInfo(declarations[declarations.length - 1], symbolKind, symbolName, containerName));
+                    result.push(createDefinitionInfo(lastOrUndefined(declarations), symbolKind, symbolName, containerName));
                     return true;
                 }
 
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
@@ -200,7 +200,7 @@ module ts {
     function nodeEndsWith(n: Node, expectedLastToken: SyntaxKind, sourceFile: SourceFile): boolean {
         let children = n.getChildren(sourceFile);
         if (children.length) {
-            let last = children[children.length - 1];
+            let last = lastOrUndefined(children);
             if (last.kind === expectedLastToken) {
                 return true;
             }

Original file line number	Diff line number	Diff line change
`@@ -3182,7 +3182,7 @@ module ts {`
`3182`	`3182`
`3183`	`3183`	`function getRestTypeOfSignature(signature: Signature): Type {`
`3184`	`3184`	`if (signature.hasRestParameter) {`
`3185`		`- let type = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);`
	`3185`	`+ let type = getTypeOfSymbol(lastOrUndefined(signature.parameters));`
`3186`	`3186`	`if (type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayType) {`
`3187`	`3187`	`return (<TypeReference>type).typeArguments[0];`
`3188`	`3188`	`}`
`@@ -5666,7 +5666,7 @@ module ts {`
`5666`	`5666`	`// If last parameter is contextually rest parameter get its type`
`5667`	`5667`	`if (indexOfParameter === (func.parameters.length - 1) &&`
`5668`	`5668`	`funcHasRestParameters && contextualSignature.hasRestParameter && func.parameters.length >= contextualSignature.parameters.length) {`
`5669`		`- return getTypeOfSymbol(contextualSignature.parameters[contextualSignature.parameters.length - 1]);`
	`5669`	`+ return getTypeOfSymbol(lastOrUndefined(contextualSignature.parameters));`
`5670`	`5670`	`}`
`5671`	`5671`	`}`
`5672`	`5672`	`}`
`@@ -7215,9 +7215,9 @@ module ts {`
`7215`	`7215`	`links.type = instantiateType(getTypeAtPosition(context, i), mapper);`
`7216`	`7216`	`}`
`7217`	`7217`	`if (signature.hasRestParameter && context.hasRestParameter && signature.parameters.length >= context.parameters.length) {`
`7218`		`- let parameter = signature.parameters[signature.parameters.length - 1];`
	`7218`	`+ let parameter = lastOrUndefined(signature.parameters);`
`7219`	`7219`	`let links = getSymbolLinks(parameter);`
`7220`		`- links.type = instantiateType(getTypeOfSymbol(context.parameters[context.parameters.length - 1]), mapper);`
	`7220`	`+ links.type = instantiateType(getTypeOfSymbol(lastOrUndefined(context.parameters)), mapper);`
`7221`	`7221`	`}`
`7222`	`7222`	`}`
`7223`	`7223`
`@@ -12829,7 +12829,7 @@ module ts {`
`12829`	`12829`	`function checkGrammarBindingElement(node: BindingElement) {`
`12830`	`12830`	`if (node.dotDotDotToken) {`
`12831`	`12831`	`let elements = (<BindingPattern>node.parent).elements;`
`12832`		`- if (node !== elements[elements.length - 1]) {`
	`12832`	`+ if (node !== lastOrUndefined(elements)) {`
`12833`	`12833`	`return grammarErrorOnNode(node, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);`
`12834`	`12834`	`}`
`12835`	`12835`
Original file line number	Diff line number	Diff line change
`@@ -1691,7 +1691,7 @@ module ts {`
`1691`	`1691`	`do {`
`1692`	`1692`	`templateSpans.push(parseTemplateSpan());`
`1693`	`1693`	`}`
`1694`		`- while (templateSpans[templateSpans.length - 1].literal.kind === SyntaxKind.TemplateMiddle)`
	`1694`	`+ while (lastOrUndefined(templateSpans).literal.kind === SyntaxKind.TemplateMiddle)`
`1695`	`1695`
`1696`	`1696`	`templateSpans.end = getNodeEnd();`
`1697`	`1697`	`template.templateSpans = templateSpans;`
Original file line number	Diff line number	Diff line change
`@@ -522,7 +522,7 @@ module ts {`
`522`	`522`	`}`
`523`	`523`	`collecting = true;`
`524`	`524`	`if (result && result.length) {`
`525`		`- result[result.length - 1].hasTrailingNewLine = true;`
	`525`	`+ lastOrUndefined(result).hasTrailingNewLine = true;`
`526`	`526`	`}`
`527`	`527`	`continue;`
`528`	`528`	`case CharacterCodes.tab:`
`@@ -569,7 +569,7 @@ module ts {`
`569`	`569`	`default:`
`570`	`570`	`if (ch > CharacterCodes.maxAsciiCharacter && (isWhiteSpace(ch) \|\| isLineBreak(ch))) {`
`571`	`571`	`if (result && result.length && isLineBreak(ch)) {`
`572`		`- result[result.length - 1].hasTrailingNewLine = true;`
	`572`	`+ lastOrUndefined(result).hasTrailingNewLine = true;`
`573`	`573`	`}`
`574`	`574`	`pos++;`
`575`	`575`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -856,7 +856,7 @@ module ts {`
`856`	`856`	`}`
`857`	`857`
`858`	`858`	`export function hasRestParameters(s: SignatureDeclaration): boolean {`
`859`		`- return s.parameters.length > 0 && s.parameters[s.parameters.length - 1].dotDotDotToken !== undefined;`
	`859`	`+ return s.parameters.length > 0 && lastOrUndefined(s.parameters).dotDotDotToken !== undefined;`
`860`	`860`	`}`
`861`	`861`
`862`	`862`	`export function isLiteralKind(kind: SyntaxKind): boolean {`
`@@ -1362,7 +1362,7 @@ module ts {`
`1362`	`1362`	`let lineStartsOfS = computeLineStarts(s);`
`1363`	`1363`	`if (lineStartsOfS.length > 1) {`
`1364`	`1364`	`lineCount = lineCount + lineStartsOfS.length - 1;`
`1365`		`- linePos = output.length - s.length + lineStartsOfS[lineStartsOfS.length - 1];`
	`1365`	`+ linePos = output.length - s.length + lastOrUndefined(lineStartsOfS);`
`1366`	`1366`	`}`
`1367`	`1367`	`}`
`1368`	`1368`	`}`
`@@ -1727,8 +1727,8 @@ module ts {`
`1727`	`1727`	`output.push(((charCode >> 6) & 0B00111111) \| 0B10000000);`
`1728`	`1728`	`output.push((charCode & 0B00111111) \| 0B10000000);`
`1729`	`1729`	`}`
`1730`		`- else {`
`1731`		`- Debug.assert(false, "Unexpected code point");`
	`1730`	`+ else {`
	`1731`	`+ Debug.assert(false, "Unexpected code point");`
`1732`	`1732`	`}`
`1733`	`1733`	`}`
`1734`	`1734`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ module ts.formatting {`
`51`	`51`	`if (isStarted) {`
`52`	`52`	`if (trailingTrivia) {`
`53`	`53`	`Debug.assert(trailingTrivia.length !== 0);`
`54`		`- wasNewLine = trailingTrivia[trailingTrivia.length - 1].kind === SyntaxKind.NewLineTrivia;`
	`54`	`+ wasNewLine = lastOrUndefined(trailingTrivia).kind === SyntaxKind.NewLineTrivia;`
`55`	`55`	`}`
`56`	`56`	`else {`
`57`	`57`	`wasNewLine = false;`
Original file line number	Diff line number	Diff line change
`@@ -4058,7 +4058,7 @@ module ts {`
`4058`	`4058`	`return true;`
`4059`	`4059`	`}`
`4060`	`4060`	`else if (declarations.length) {`
`4061`		`- result.push(createDefinitionInfo(declarations[declarations.length - 1], symbolKind, symbolName, containerName));`
	`4061`	`+ result.push(createDefinitionInfo(lastOrUndefined(declarations), symbolKind, symbolName, containerName));`
`4062`	`4062`	`return true;`
`4063`	`4063`	`}`
`4064`	`4064`