JavaScriptPlugins
diff --git a/‎Jakefile‎
Lines changed: 2 additions & 0 deletions b/‎Jakefile‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎README.md‎
Lines changed: 12 additions & 10 deletions b/‎README.md‎
Lines changed: 12 additions & 10 deletions
diff --git a/‎src/compiler/checker.ts‎
Lines changed: 498 additions & 212 deletions b/‎src/compiler/checker.ts‎
Lines changed: 498 additions & 212 deletions
diff --git a/‎src/compiler/core.ts‎
Lines changed: 15 additions & 1 deletion b/‎src/compiler/core.ts‎
Lines changed: 15 additions & 1 deletion
diff --git a/‎src/compiler/emitter.ts‎
Lines changed: 67 additions & 44 deletions b/‎src/compiler/emitter.ts‎
Lines changed: 67 additions & 44 deletions
diff --git a/‎src/compiler/parser.ts‎
Lines changed: 54 additions & 32 deletions b/‎src/compiler/parser.ts‎
Lines changed: 54 additions & 32 deletions
diff --git a/‎src/compiler/scanner.ts‎
Lines changed: 4 additions & 4 deletions b/‎src/compiler/scanner.ts‎
Lines changed: 4 additions & 4 deletions
@@ -54,6 +54,8 @@ var servicesSources = [
 }).concat([
     "services.ts",
     "shims.ts",
+    "signatureHelp.ts",
+    "utilities.ts"
 ].map(function (f) {
     return path.join(servicesDirectory, f);
 }));
 
@@ -47,16 +47,18 @@ npm install
 Use one of the following to build and test:
 
 ```
-jake local           # Build the compiler into built/local 
-jake clean           # Delete the built compiler 
-jake LKG             # Replace the last known good with the built one.
-                     # Bootstrapping step to be executed when the built compiler reaches a stable state.
-jake tests           # Build the test infrastructure using the built compiler. 
-jake runtests        # Run tests using the built compiler and test infrastructure. 
-                     # You can override the host or specify a test for this command. 
-                     # Use host=<hostName> or tests=<testPath>. 
-jake baseline-accept # This replaces the baseline test results with the results obtained from jake runtests. 
-jake -T              # List the above commands. 
+jake local            # Build the compiler into built/local 
+jake clean            # Delete the built compiler 
+jake LKG              # Replace the last known good with the built one.
+                      # Bootstrapping step to be executed when the built compiler reaches a stable state.
+jake tests            # Build the test infrastructure using the built compiler. 
+jake runtests         # Run tests using the built compiler and test infrastructure. 
+                      # You can override the host or specify a test for this command. 
+                      # Use host=<hostName> or tests=<testPath>. 
+jake runtests-browser # Runs the tests using the built run.js file. Syntax is jake runtests. Optional
+                        parameters 'host=', 'tests=[regex], reporter=[list|spec|json|<more>]'.
+jake baseline-accept  # This replaces the baseline test results with the results obtained from jake runtests. 
+jake -T               # List the above commands. 
 ```
 
 
 
@@ -11,7 +11,9 @@ module ts {
         var result: U;
         if (array) {
             for (var i = 0, len = array.length; i < len; i++) {
-                if (result = callback(array[i])) break;
+                if (result = callback(array[i])) {
+                    break;
+                }
             }
         }
         return result;
@@ -39,6 +41,18 @@ module ts {
         return -1;
     }
 
+    export function countWhere<T>(array: T[], predicate: (x: T) => boolean): number {
+        var count = 0;
+        if (array) {
+            for (var i = 0, len = array.length; i < len; i++) {
+                if (predicate(array[i])) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
     export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
         if (array) {
             var result: T[] = [];
 
@@ -138,25 +138,27 @@ module ts {
         return (<Identifier>(<ExpressionStatement>node).expression).text === "use strict";
     }
 
-    export function getLeadingCommentsOfNode(node: Node, sourceFileOfNode: SourceFile) {
+    export function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode?: SourceFile) {
+        sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node);
+
         // If parameter/type parameter, the prev token trailing comments are part of this node too
         if (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) {
             // e.g.   (/** blah */ a, /** blah */ b);
-            return concatenate(getTrailingComments(sourceFileOfNode.text, node.pos),
+            return concatenate(getTrailingCommentRanges(sourceFileOfNode.text, node.pos),
                 // e.g.:     (
                 //            /** blah */ a,
                 //            /** blah */ b);
-                getLeadingComments(sourceFileOfNode.text, node.pos));
+                getLeadingCommentRanges(sourceFileOfNode.text, node.pos));
         }
         else {
-            return getLeadingComments(sourceFileOfNode.text, node.pos);
+            return getLeadingCommentRanges(sourceFileOfNode.text, node.pos);
         }
     }
 
     export function getJsDocComments(node: Declaration, sourceFileOfNode: SourceFile) {
-        return filter(getLeadingCommentsOfNode(node, sourceFileOfNode), comment => isJsDocComment(comment));
+        return filter(getLeadingCommentRangesOfNode(node, sourceFileOfNode), comment => isJsDocComment(comment));
 
-        function isJsDocComment(comment: Comment) {
+        function isJsDocComment(comment: CommentRange) {
             // True if the comment starts with '/**' but not if it is '/**/'
             return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk &&
                 sourceFileOfNode.text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk &&
@@ -626,12 +628,6 @@ module ts {
         Parameters,              // Parameters in parameter list
     }
 
-    enum TrailingCommaBehavior {
-        Disallow,
-        Allow,
-        Preserve
-    }
-
     // Tracks whether we nested (directly or indirectly) in a certain control block.
     // Used for validating break and continue statements.
     enum ControlBlockContext {
@@ -1203,7 +1199,7 @@ module ts {
         }
 
         // Parses a comma-delimited list of elements
-        function parseDelimitedList<T extends Node>(kind: ParsingContext, parseElement: () => T, trailingCommaBehavior: TrailingCommaBehavior): NodeArray<T> {
+        function parseDelimitedList<T extends Node>(kind: ParsingContext, parseElement: () => T, allowTrailingComma: boolean): NodeArray<T> {
             var saveParsingContext = parsingContext;
             parsingContext |= 1 << kind;
             var result = <NodeArray<T>>[];
@@ -1228,15 +1224,14 @@ module ts {
                 else if (isListTerminator(kind)) {
                     // Check if the last token was a comma.
                     if (commaStart >= 0) {
-                        if (trailingCommaBehavior === TrailingCommaBehavior.Disallow) {
+                        if (!allowTrailingComma) {
                             if (file.syntacticErrors.length === errorCountBeforeParsingList) {
                                 // Report a grammar error so we don't affect lookahead
                                 grammarErrorAtPos(commaStart, scanner.getStartPos() - commaStart, Diagnostics.Trailing_comma_not_allowed);
                             }
                         }
-                        else if (trailingCommaBehavior === TrailingCommaBehavior.Preserve) {
-                            result.push(<T>createNode(SyntaxKind.OmittedExpression));
-                        }
+                        // Always preserve a trailing comma by marking it on the NodeArray
+                        result.hasTrailingComma = true;
                     }
 
                     break;
@@ -1271,7 +1266,7 @@ module ts {
 
         function parseBracketedList<T extends Node>(kind: ParsingContext, parseElement: () => T, startToken: SyntaxKind, endToken: SyntaxKind): NodeArray<T> {
             if (parseExpected(startToken)) {
-                var result = parseDelimitedList(kind, parseElement, TrailingCommaBehavior.Disallow);
+                var result = parseDelimitedList(kind, parseElement, /*allowTrailingComma*/ false);
                 parseExpected(endToken);
                 return result;
             }
@@ -2172,10 +2167,10 @@ module ts {
                         // The identifier eval or arguments may not appear as the LeftHandSideExpression of an 
                         // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression 
                         // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator
-                        if ((token === SyntaxKind.PlusPlusToken || token === SyntaxKind.MinusMinusToken) && isEvalOrArgumentsIdentifier(operand)) {
+                        if ((operator === SyntaxKind.PlusPlusToken || operator === SyntaxKind.MinusMinusToken) && isEvalOrArgumentsIdentifier(operand)) {
                             reportInvalidUseInStrictMode(<Identifier>operand);
                         }
-                        else if (token === SyntaxKind.DeleteKeyword && operand.kind === SyntaxKind.Identifier) {
+                        else if (operator === SyntaxKind.DeleteKeyword && operand.kind === SyntaxKind.Identifier) {
                             // When a delete operator occurs within strict mode code, a SyntaxError is thrown if its 
                             // UnaryExpression is a direct reference to a variable, function argument, or function name
                             grammarErrorOnNode(operand, Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode);
@@ -2307,7 +2302,11 @@ module ts {
                     else {
                         parseExpected(SyntaxKind.OpenParenToken);
                     }
-                    callExpr.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions, parseAssignmentExpression, TrailingCommaBehavior.Disallow);
+                    // It is an error to have a trailing comma in an argument list. However, the checker
+                    // needs evidence of a trailing comma in order to give good results for signature help.
+                    // That is why we do not allow a trailing comma, but we "preserve" a trailing comma.
+                    callExpr.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions,
+                        parseArgumentExpression, /*allowTrailingComma*/ false);
                     parseExpected(SyntaxKind.CloseParenToken);
                     expr = finishNode(callExpr);
                     continue;
@@ -2376,15 +2375,33 @@ module ts {
             return finishNode(node);
         }
 
+        function parseAssignmentExpressionOrOmittedExpression(omittedExpressionDiagnostic: DiagnosticMessage): Expression {
+            if (token === SyntaxKind.CommaToken) {
+                if (omittedExpressionDiagnostic) {
+                    var errorStart = scanner.getTokenPos();
+                    var errorLength = scanner.getTextPos() - errorStart;
+                    grammarErrorAtPos(errorStart, errorLength, omittedExpressionDiagnostic);
+                }
+                return createNode(SyntaxKind.OmittedExpression);
+            }
+            
+            return parseAssignmentExpression();
+        }
+
         function parseArrayLiteralElement(): Expression {
-            return token === SyntaxKind.CommaToken ? createNode(SyntaxKind.OmittedExpression) : parseAssignmentExpression();
+            return parseAssignmentExpressionOrOmittedExpression(/*omittedExpressionDiagnostic*/ undefined);
+        }
+
+        function parseArgumentExpression(): Expression {
+            return parseAssignmentExpressionOrOmittedExpression(Diagnostics.Argument_expression_expected);
         }
 
         function parseArrayLiteral(): ArrayLiteral {
             var node = <ArrayLiteral>createNode(SyntaxKind.ArrayLiteral);
             parseExpected(SyntaxKind.OpenBracketToken);
             if (scanner.hasPrecedingLineBreak()) node.flags |= NodeFlags.MultiLine;
-            node.elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, parseArrayLiteralElement, TrailingCommaBehavior.Preserve);
+            node.elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, 
+                parseArrayLiteralElement, /*allowTrailingComma*/ true);
             parseExpected(SyntaxKind.CloseBracketToken);
             return finishNode(node);
         }
@@ -2426,10 +2443,7 @@ module ts {
                 node.flags |= NodeFlags.MultiLine;
             }
 
-            // ES3 itself does not accept a trailing comma in an object literal, however, we'd like to preserve it in ES5.
-            var trailingCommaBehavior = languageVersion === ScriptTarget.ES3 ? TrailingCommaBehavior.Allow : TrailingCommaBehavior.Preserve;
-
-            node.properties = parseDelimitedList(ParsingContext.ObjectLiteralMembers, parseObjectLiteralMember, trailingCommaBehavior);
+            node.properties = parseDelimitedList(ParsingContext.ObjectLiteralMembers, parseObjectLiteralMember, /*allowTrailingComma*/ true);
             parseExpected(SyntaxKind.CloseBraceToken);
 
             var seen: Map<SymbolFlags> = {};
@@ -2518,7 +2532,11 @@ module ts {
             parseExpected(SyntaxKind.NewKeyword);
             node.func = parseCallAndAccess(parsePrimaryExpression(), /* inNewExpression */ true);
             if (parseOptional(SyntaxKind.OpenParenToken) || token === SyntaxKind.LessThanToken && (node.typeArguments = tryParse(parseTypeArgumentsAndOpenParen))) {
-                node.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions, parseAssignmentExpression, TrailingCommaBehavior.Disallow);
+                // It is an error to have a trailing comma in an argument list. However, the checker
+                // needs evidence of a trailing comma in order to give good results for signature help.
+                // That is why we do not allow a trailing comma, but we "preserve" a trailing comma.
+                node.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions,
+                    parseArgumentExpression, /*allowTrailingComma*/ false);
                 parseExpected(SyntaxKind.CloseParenToken);
             }
             return finishNode(node);
@@ -3087,7 +3105,8 @@ module ts {
         }
 
         function parseVariableDeclarationList(flags: NodeFlags, noIn?: boolean): NodeArray<VariableDeclaration> {
-            return parseDelimitedList(ParsingContext.VariableDeclarations, () => parseVariableDeclaration(flags, noIn), TrailingCommaBehavior.Disallow);
+            return parseDelimitedList(ParsingContext.VariableDeclarations,
+                () => parseVariableDeclaration(flags, noIn), /*allowTrailingComma*/ false);
         }
 
         function parseVariableStatement(pos?: number, flags?: NodeFlags): VariableStatement {
@@ -3486,7 +3505,8 @@ module ts {
             var implementsKeywordLength: number;
             if (parseOptional(SyntaxKind.ImplementsKeyword)) {
                 implementsKeywordLength = scanner.getStartPos() - implementsKeywordStart;
-                node.implementedTypes = parseDelimitedList(ParsingContext.BaseTypeReferences, parseTypeReference, TrailingCommaBehavior.Disallow);
+                node.implementedTypes = parseDelimitedList(ParsingContext.BaseTypeReferences,
+                    parseTypeReference, /*allowTrailingComma*/ false);
             }
             var errorCountBeforeClassBody = file.syntacticErrors.length;
             if (parseExpected(SyntaxKind.OpenBraceToken)) {
@@ -3514,7 +3534,8 @@ module ts {
             var extendsKeywordLength: number;
             if (parseOptional(SyntaxKind.ExtendsKeyword)) {
                 extendsKeywordLength = scanner.getStartPos() - extendsKeywordStart;
-                node.baseTypes = parseDelimitedList(ParsingContext.BaseTypeReferences, parseTypeReference, TrailingCommaBehavior.Disallow);
+                node.baseTypes = parseDelimitedList(ParsingContext.BaseTypeReferences,
+                    parseTypeReference, /*allowTrailingComma*/ false);
             }
             var errorCountBeforeInterfaceBody = file.syntacticErrors.length;
             node.members = parseTypeLiteral().members;
@@ -3578,7 +3599,8 @@ module ts {
             parseExpected(SyntaxKind.EnumKeyword);
             node.name = parseIdentifier();
             if (parseExpected(SyntaxKind.OpenBraceToken)) {
-                node.members = parseDelimitedList(ParsingContext.EnumMembers, parseAndCheckEnumMember, TrailingCommaBehavior.Allow);
+                node.members = parseDelimitedList(ParsingContext.EnumMembers,
+                    parseAndCheckEnumMember, /*allowTrailingComma*/ true);
                 parseExpected(SyntaxKind.CloseBraceToken);
             }
             else {
 
@@ -371,8 +371,8 @@ module ts {
     // between the given position and the next line break are returned. The return value is an array containing a TextRange for each
     // comment. Single-line comment ranges include the beginning '//' characters but not the ending line break. Multi-line comment
     // ranges include the beginning '/* and ending '*/' characters. The return value is undefined if no comments were found.
-    function getCommentRanges(text: string, pos: number, trailing: boolean): Comment[] {
-        var result: Comment[];
+    function getCommentRanges(text: string, pos: number, trailing: boolean): CommentRange[] {
+        var result: CommentRange[];
         var collecting = trailing || pos === 0;
         while (true) {
             var ch = text.charCodeAt(pos);
@@ -440,11 +440,11 @@ module ts {
         }
     }
 
-    export function getLeadingComments(text: string, pos: number): Comment[] {
+    export function getLeadingCommentRanges(text: string, pos: number): CommentRange[] {
         return getCommentRanges(text, pos, /*trailing*/ false);
     }
 
-    export function getTrailingComments(text: string, pos: number): Comment[] {
+    export function getTrailingCommentRanges(text: string, pos: number): CommentRange[] {
         return getCommentRanges(text, pos, /*trailing*/ true);
     }
Original file line number	Diff line number	Diff line change
`@@ -371,8 +371,8 @@ module ts {`
`371`	`371`	`// between the given position and the next line break are returned. The return value is an array containing a TextRange for each`
`372`	`372`	`// comment. Single-line comment ranges include the beginning '//' characters but not the ending line break. Multi-line comment`
`373`	`373`	`// ranges include the beginning '/* and ending '*/' characters. The return value is undefined if no comments were found.`
`374`		`- function getCommentRanges(text: string, pos: number, trailing: boolean): Comment[] {`
`375`		`- var result: Comment[];`
	`374`	`+ function getCommentRanges(text: string, pos: number, trailing: boolean): CommentRange[] {`
	`375`	`+ var result: CommentRange[];`
`376`	`376`	`var collecting = trailing \|\| pos === 0;`
`377`	`377`	`while (true) {`
`378`	`378`	`var ch = text.charCodeAt(pos);`
`@@ -440,11 +440,11 @@ module ts {`
`440`	`440`	`}`
`441`	`441`	`}`
`442`	`442`
`443`		`- export function getLeadingComments(text: string, pos: number): Comment[] {`
	`443`	`+ export function getLeadingCommentRanges(text: string, pos: number): CommentRange[] {`
`444`	`444`	`return getCommentRanges(text, pos, /trailing/ false);`
`445`	`445`	`}`
`446`	`446`
`447`		`- export function getTrailingComments(text: string, pos: number): Comment[] {`
	`447`	`+ export function getTrailingCommentRanges(text: string, pos: number): CommentRange[] {`
`448`	`448`	`return getCommentRanges(text, pos, /trailing/ true);`
`449`	`449`	`}`
`450`	`450`