Merge branch 'master' into tsc

Author: mhegazy

src/compiler/checker.ts

@@ -3844,21 +3844,40 @@ module ts {
         }
 
         // The candidate list orders groups in reverse, but within a group signatures are kept in declaration order
+        // A nit here is that we reorder only signatures that belong to the same symbol,
+        // so order how inherited signatures are processed is still preserved.
+        // interface A { (x: string): void }
+        // interface B extends A { (x: 'foo'): string }
+        // var b: B;
+        // b('foo') // <- here overloads should be processed as [(x:'foo'): string, (x: string): void]
         function collectCandidates(node: CallExpression, signatures: Signature[]): Signature[]{
             var result: Signature[] = [];
             var lastParent: Node;
+            var lastSymbol: Symbol;
+            var cutoffPos: number = 0;
             var pos: number;
             for (var i = 0; i < signatures.length; i++) {
                 var signature = signatures[i];
                 if (isCandidateSignature(node, signature)) {
-                    var parent = signature.declaration ? signature.declaration.parent : undefined;
-                    if (lastParent && parent === lastParent) {
-                        pos++;
+                    var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
+                    var parent = signature.declaration && signature.declaration.parent;
+                    if (!lastSymbol || symbol === lastSymbol) {                        
+                        if (lastParent && parent === lastParent) {
+                            pos++;
+                        }
+                        else {
+                            lastParent = parent;
+                            pos = cutoffPos;
+                        }
                     }
                     else {
+                        // current declaration belongs to a different symbol
+                        // set cutoffPos so reorderings in the future won't change result set from 0 to cutoffPos
+                        pos = cutoffPos = result.length;
                         lastParent = parent;
-                        pos = 0;
                     }
+                    lastSymbol = symbol;
+
                     for (var j = result.length; j > pos; j--) {
                         result[j] = result[j - 1];
                     }

src/compiler/core.ts

@@ -174,7 +174,7 @@ module ts {
         var result: Map<T> = {};
 
         forEach(array, value => {
-            result[makeKey(value)] = value
+            result[makeKey(value)] = value;
         });
 
         return result;

src/compiler/diagnosticInformationMap.generated.ts

@@ -105,6 +105,7 @@ module ts {
         An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: { code: 1118, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple get/set accessors with the same name." },
         An_object_literal_cannot_have_property_and_accessor_with_the_same_name: { code: 1119, category: DiagnosticCategory.Error, key: "An object literal cannot have property and accessor with the same name." },
         An_export_assignment_cannot_have_modifiers: { code: 1120, category: DiagnosticCategory.Error, key: "An export assignment cannot have modifiers." },
+        Octal_literals_are_not_allowed_in_strict_mode: { code: 1121, category: DiagnosticCategory.Error, key: "Octal literals are not allowed in strict mode." },
         Duplicate_identifier_0: { code: 2000, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Extends_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 2018, category: DiagnosticCategory.Error, key: "Extends clause of exported class '{0}' has or is using private name '{1}'." },
         Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 2019, category: DiagnosticCategory.Error, key: "Implements clause of exported class '{0}' has or is using private name '{1}'." },

src/compiler/diagnosticMessages.json

@@ -412,6 +412,10 @@
         "category": "Error",
         "code": 1120
     },
+    "Octal literals are not allowed in strict mode.": {
+        "category": "Error",
+        "code": 1121
+    },
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2000

src/compiler/parser.ts

@@ -1055,8 +1055,29 @@ module ts {
         function parseLiteralNode(): LiteralExpression {
             var node = <LiteralExpression>createNode(token);
             node.text = scanner.getTokenValue();
+            var tokenPos = scanner.getTokenPos();
             nextToken();
-            return finishNode(node);
+            finishNode(node);
+            
+            // Octal literals are not allowed in strict mode or ES5
+            // Note that theoretically the following condition would hold true literals like 009,
+            // which is not octal.But because of how the scanner separates the tokens, we would
+            // never get a token like this.Instead, we would get 00 and 9 as two separate tokens.
+            // We also do not need to check for negatives because any prefix operator would be part of a
+            // parent unary expression.
+            if (node.kind === SyntaxKind.NumericLiteral
+                && sourceText.charCodeAt(tokenPos) === CharacterCodes._0
+                && isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) {
+
+                if (isInStrictMode) {
+                    grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode);
+                }
+                else if (languageVersion >= ScriptTarget.ES5) {
+                    grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
+                }
+            }
+
+            return node;
         }
 
         function parseStringLiteral(): LiteralExpression {

src/compiler/scanner.ts

@@ -300,6 +300,10 @@ module ts {
         return ch >= CharacterCodes._0 && ch <= CharacterCodes._9;
     }
 
+    export function isOctalDigit(ch: number): boolean {
+        return ch >= CharacterCodes._0 && ch <= CharacterCodes._7;
+    }
+
     export function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number {
         while (true) {
             var ch = text.charCodeAt(pos);
@@ -360,7 +364,9 @@ module ts {
         var precedingLineBreak: boolean;
 
         function error(message: DiagnosticMessage): void {
-            if (onError) onError(message);
+            if (onError) {
+                onError(message);
+            }
         }
 
         function isIdentifierStart(ch: number): boolean {
@@ -398,6 +404,14 @@ module ts {
             return +(text.substring(start, end));
         }
 
+        function scanOctalDigits(): number {
+            var start = pos;
+            while (isOctalDigit(text.charCodeAt(pos))) {
+                pos++;
+            }
+            return +(text.substring(start, pos));
+        }
+
         function scanHexDigits(count: number, exact?: boolean): number {
             var digits = 0;
             var value = 0;
@@ -681,7 +695,7 @@ module ts {
 
                             if (!commentClosed) {
                                 pos++;
-                                onError(Diagnostics.Asterisk_Slash_expected);
+                                error(Diagnostics.Asterisk_Slash_expected);
                             }
 
                             if (onComment) {
@@ -708,6 +722,14 @@ module ts {
                             tokenValue = "" + value;
                             return SyntaxKind.NumericLiteral;
                         }
+                        // Try to parse as an octal
+                        if (pos + 1 < len && isOctalDigit(text.charCodeAt(pos + 1))) {
+                            tokenValue = "" + scanOctalDigits();
+                            return SyntaxKind.NumericLiteral;
+                        }
+                        // This fall-through is a deviation from the EcmaScript grammar. The grammar says that a leading zero
+                        // can only be followed by an octal digit, a dot, or the end of the number literal. However, we are being
+                        // permissive and allowing decimal digits of the form 08* and 09* (which many browsers also do).
                     case CharacterCodes._1:
                     case CharacterCodes._2:
                     case CharacterCodes._3:

src/compiler/tsc.ts

@@ -362,8 +362,8 @@ module ts {
         var output = "";
 
         // We want to align our "syntax" and "examples" commands to a certain margin.
-        var syntaxLength = getDiagnosticText(Diagnostics.Syntax_Colon_0, "").length
-        var examplesLength = getDiagnosticText(Diagnostics.Examples_Colon_0, "").length
+        var syntaxLength = getDiagnosticText(Diagnostics.Syntax_Colon_0, "").length;
+        var examplesLength = getDiagnosticText(Diagnostics.Examples_Colon_0, "").length;
         var marginLength = Math.max(syntaxLength, examplesLength);
 
         // Build up the syntactic skeleton.

src/compiler/types.ts

@@ -635,8 +635,8 @@ module ts {
 
     export interface SymbolAccessiblityResult {
         accessibility: SymbolAccessibility;
-        errorSymbolName?: string // Optional symbol name that results in error
-        errorModuleName?: string // If the symbol is not visibile from module, module's name
+        errorSymbolName?: string; // Optional symbol name that results in error
+        errorModuleName?: string; // If the symbol is not visibile from module, module's name
     }
 
     export interface EmitResolver {

src/harness/compilerRunner.ts

@@ -365,7 +365,7 @@ class CompilerBaselineRunner extends RunnerBase {
                             walker.results.forEach(result => {
                                 var formattedLine = result.identifierName + " : " + result.type;
                                 if (!typeMap[file.unitName]) {
-                                    typeMap[file.unitName] = {}
+                                    typeMap[file.unitName] = {};
                                 }
 
                                 var typeInfo = [formattedLine];
@@ -386,7 +386,7 @@ class CompilerBaselineRunner extends RunnerBase {
                                 walker.results.forEach(result => {
                                     var formattedLine = result.identifierName + " : " + result.type;
                                     if (!typeMap[file.unitName]) {
-                                        typeMap[file.unitName] = {}
+                                        typeMap[file.unitName] = {};
                                     } else {
                                         typeLines.push('No type information for this code.');
                                     }

src/harness/exec.ts

@@ -32,7 +32,7 @@ class WindowsScriptHostExec implements IExec {
             var process = shell.Exec(fileName + ' ' + cmdLineArgs.join(' '));
         } catch(e) {
             result.stderr = e.message;
-            result.exitCode = 1
+            result.exitCode = 1;
             handleResult(result);
             return;
         }