Perform error reporting in checker

Author: caitp

src/compiler/checker.ts

@@ -157,6 +157,7 @@ module ts {
         Catch_clause_variable_cannot_have_an_initializer: { code: 1197, category: DiagnosticCategory.Error, key: "Catch clause variable cannot have an initializer." },
         An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: { code: 1198, category: DiagnosticCategory.Error, key: "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive." },
         Unterminated_Unicode_escape_sequence: { code: 1199, category: DiagnosticCategory.Error, key: "Unterminated Unicode escape sequence." },
+        Line_terminator_not_permitted_before_arrow: { code: 1200, category: DiagnosticCategory.Error, key: "Line terminator not permitted before arrow." },
         Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },

src/compiler/diagnosticInformationMap.generated.ts

@@ -619,6 +619,10 @@
         "category": "Error",
         "code":  1199
     },
+    "Line terminator not permitted before arrow.": {
+        "category": "Error",
+        "code": 1200
+    },
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300

src/compiler/diagnosticMessages.json

@@ -2916,7 +2916,7 @@ module ts {
             // To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
             // identifier and the current token is an arrow.
-            if (expr.kind === SyntaxKind.Identifier && token === SyntaxKind.EqualsGreaterThanToken && !scanner.hasPrecedingLineBreak()) {
+            if (expr.kind === SyntaxKind.Identifier && token === SyntaxKind.EqualsGreaterThanToken) {
                 return parseSimpleArrowFunctionExpression(<Identifier>expr);
             }
 
@@ -2998,7 +2998,7 @@ module ts {
         function parseSimpleArrowFunctionExpression(identifier: Identifier): Expression {
             Debug.assert(token === SyntaxKind.EqualsGreaterThanToken, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
 
-            var node = <FunctionExpression>createNode(SyntaxKind.ArrowFunction, identifier.pos);
+            var node = <ArrowFunctionExpression>createNode(SyntaxKind.ArrowFunction, identifier.pos);
 
             var parameter = <ParameterDeclaration>createNode(SyntaxKind.Parameter, identifier.pos);
             parameter.name = identifier;
@@ -3008,6 +3008,7 @@ module ts {
             node.parameters.pos = parameter.pos;
             node.parameters.end = parameter.end;
 
+            node.lineTerminatorBeforeArrow = scanner.hasPrecedingLineBreak();
             parseExpected(SyntaxKind.EqualsGreaterThanToken);
             node.body = parseArrowFunctionExpressionBody();
 
@@ -3132,7 +3133,7 @@ module ts {
         }
 
         function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): FunctionExpression {
-            var node = <FunctionExpression>createNode(SyntaxKind.ArrowFunction);
+            var node = <ArrowFunctionExpression>createNode(SyntaxKind.ArrowFunction);
             // Arrow functions are never generators.
             //
             // If we're speculatively parsing a signature for a parenthesized arrow function, then
@@ -3160,10 +3161,7 @@ module ts {
                 return undefined;
             }
 
-            // Must be no line terminator before token `=>`.
-            if (scanner.hasPrecedingLineBreak()) {
-                return undefined;
-            }
+            node.lineTerminatorBeforeArrow = scanner.hasPrecedingLineBreak();
 
             return node;
         }

src/compiler/parser.ts

@@ -328,15 +328,15 @@ module ts {
 
         // If the parser encountered an error when parsing the code that created this node.  Note
         // the parser only sets this directly on the node it creates right after encountering the
-        // error.  
+        // error.
         ThisNodeHasError = 1 << 4,
 
         // Context flags set directly by the parser.
         ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | ThisNodeHasError,
 
         // Context flags computed by aggregating child flags upwards.
 
-        // Used during incremental parsing to determine if this node or any of its children had an 
+        // Used during incremental parsing to determine if this node or any of its children had an
         // error.  Computed only once and then cached.
         ThisNodeOrAnySubNodesHasError = 1 << 5,
 
@@ -353,7 +353,7 @@ module ts {
     export interface Node extends TextRange {
         kind: SyntaxKind;
         flags: NodeFlags;
-        // Specific context the parser was in when this node was created.  Normally undefined. 
+        // Specific context the parser was in when this node was created.  Normally undefined.
         // Only set when the parser was in some interesting context (like async/yield).
         parserContextFlags?: ParserContextFlags;
         modifiers?: ModifiersArray;   // Array of modifiers
@@ -523,7 +523,7 @@ module ts {
         body?: Block;
     }
 
-    // See the comment on MethodDeclaration for the intuition behind AccessorDeclaration being a 
+    // See the comment on MethodDeclaration for the intuition behind AccessorDeclaration being a
     // ClassElement and an ObjectLiteralElement.
     export interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
         _accessorDeclarationBrand: any;
@@ -574,12 +574,12 @@ module ts {
 
     export interface StringLiteralTypeNode extends LiteralExpression, TypeNode { }
 
-    // Note: 'brands' in our syntax nodes serve to give us a small amount of nominal typing.  
+    // Note: 'brands' in our syntax nodes serve to give us a small amount of nominal typing.
     // Consider 'Expression'.  Without the brand, 'Expression' is actually no different
     // (structurally) than 'Node'.  Because of this you can pass any Node to a function that
     // takes an Expression without any error.  By using the 'brands' we ensure that the type
-    // checker actually thinks you have something of the right type.  Note: the brands are 
-    // never actually given values.  At runtime they have zero cost. 
+    // checker actually thinks you have something of the right type.  Note: the brands are
+    // never actually given values.  At runtime they have zero cost.
 
     export interface Expression extends Node {
         _expressionBrand: any;
@@ -652,6 +652,10 @@ module ts {
         body: Block | Expression;  // Required, whereas the member inherited from FunctionDeclaration is optional
     }
 
+    export interface ArrowFunctionExpression extends FunctionExpression {
+        lineTerminatorBeforeArrow: boolean;
+    }
+
     // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,
     // or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.
     // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
@@ -734,7 +738,7 @@ module ts {
     }
 
     export interface VariableStatement extends Statement {
-        declarationList: VariableDeclarationList; 
+        declarationList: VariableDeclarationList;
     }
 
     export interface ExpressionStatement extends Statement {
@@ -898,7 +902,7 @@ module ts {
         moduleSpecifier: Expression;
     }
 
-    // In case of: 
+    // In case of:
     // import d from "mod" => name = d, namedBinding = undefined
     // import * as ns from "mod" => name = undefined, namedBinding: NamespaceImport = { name: ns }
     // import d, * as ns from "mod" => name = d, namedBinding: NamespaceImport = { name: ns }
@@ -964,18 +968,18 @@ module ts {
         externalModuleIndicator: Node;
         languageVersion: ScriptTarget;
         identifiers: Map<string>;
-        
+
         /* @internal */ nodeCount: number;
         /* @internal */ identifierCount: number;
         /* @internal */ symbolCount: number;
 
         // File level diagnostics reported by the parser (includes diagnostics about /// references
         // as well as code diagnostics).
         /* @internal */ parseDiagnostics: Diagnostic[];
-        
+
         // File level diagnostics reported by the binder.
         /* @internal */ bindDiagnostics: Diagnostic[];
-        
+
         // Stores a line map for the file.
         // This field should never be used directly to obtain line map, use getLineMap function instead.
         /* @internal */ lineMap: number[];
@@ -995,10 +999,10 @@ module ts {
         getSourceFiles(): SourceFile[];
 
         /**
-         * Emits the javascript and declaration files.  If targetSourceFile is not specified, then 
+         * Emits the javascript and declaration files.  If targetSourceFile is not specified, then
          * the javascript and declaration files will be produced for all the files in this program.
          * If targetSourceFile is specified, then only the javascript and declaration for that
-         * specific file will be generated.  
+         * specific file will be generated.
          *
          * If writeFile is not specified then the writeFile callback from the compiler host will be
          * used for writing the javascript and declaration files.  Otherwise, the writeFile parameter
@@ -1016,7 +1020,7 @@ module ts {
 
         getCommonSourceDirectory(): string;
 
-        // For testing purposes only.  Should not be used by any other consumers (including the 
+        // For testing purposes only.  Should not be used by any other consumers (including the
         // language service).
         /* @internal */ getDiagnosticsProducingTypeChecker(): TypeChecker;
 
@@ -1053,7 +1057,7 @@ module ts {
         // when -version or -help was provided, or this was a normal compilation, no diagnostics
         // were produced, and all outputs were generated successfully.
         Success = 0,
-        
+
         // Diagnostics were produced and because of them no code was generated.
         DiagnosticsPresent_OutputsSkipped = 1,
 
@@ -1163,12 +1167,12 @@ module ts {
 
         // Write symbols's type argument if it is instantiated symbol
         // eg. class C<T> { p: T }   <-- Show p as C<T>.p here
-        //     var a: C<number>; 
+        //     var a: C<number>;
         //     var p = a.p;  <--- Here p is property of C<number> so show it as C<number>.p instead of just C.p
-        WriteTypeParametersOrArguments = 0x00000001, 
+        WriteTypeParametersOrArguments = 0x00000001,
 
         // Use only external alias information to get the symbol name in the given context
-        // eg.  module m { export class c { } } import x = m.c; 
+        // eg.  module m { export class c { } } import x = m.c;
         // When this flag is specified m.c will be used to refer to the class instead of alias symbol x
         UseOnlyExternalAliasing = 0x00000002,
     }
@@ -1772,7 +1776,7 @@ module ts {
         // Gets a count of how many times this collection has been modified.  This value changes
         // each time 'add' is called (regardless of whether or not an equivalent diagnostic was
         // already in the collection).  As such, it can be used as a simple way to tell if any
-        // operation caused diagnostics to be returned by storing and comparing the return value 
+        // operation caused diagnostics to be returned by storing and comparing the return value
         // of this method before/after the operation is performed.
         getModificationCount(): number;
     }

src/compiler/types.ts

@@ -552,6 +552,9 @@ declare module "typescript" {
         name?: Identifier;
         body: Block | Expression;
     }
+    interface ArrowFunctionExpression extends FunctionExpression {
+        lineTerminatorBeforeArrow: boolean;
+    }
     interface LiteralExpression extends PrimaryExpression {
         text: string;
         isUnterminated?: boolean;

tests/baselines/reference/APISample_compile.js

@@ -1665,6 +1665,13 @@ declare module "typescript" {
 >body : Expression | Block
 >Block : Block
 >Expression : Expression
+    }
+    interface ArrowFunctionExpression extends FunctionExpression {
+>ArrowFunctionExpression : ArrowFunctionExpression
+>FunctionExpression : FunctionExpression
+
+        lineTerminatorBeforeArrow: boolean;
+>lineTerminatorBeforeArrow : boolean
     }
     interface LiteralExpression extends PrimaryExpression {
 >LiteralExpression : LiteralExpression

tests/baselines/reference/APISample_compile.types

@@ -583,6 +583,9 @@ declare module "typescript" {
         name?: Identifier;
         body: Block | Expression;
     }
+    interface ArrowFunctionExpression extends FunctionExpression {
+        lineTerminatorBeforeArrow: boolean;
+    }
     interface LiteralExpression extends PrimaryExpression {
         text: string;
         isUnterminated?: boolean;

tests/baselines/reference/APISample_linter.js

@@ -1811,6 +1811,13 @@ declare module "typescript" {
 >body : Expression | Block
 >Block : Block
 >Expression : Expression
+    }
+    interface ArrowFunctionExpression extends FunctionExpression {
+>ArrowFunctionExpression : ArrowFunctionExpression
+>FunctionExpression : FunctionExpression
+
+        lineTerminatorBeforeArrow: boolean;
+>lineTerminatorBeforeArrow : boolean
     }
     interface LiteralExpression extends PrimaryExpression {
 >LiteralExpression : LiteralExpression

tests/baselines/reference/APISample_linter.types

@@ -584,6 +584,9 @@ declare module "typescript" {
         name?: Identifier;
         body: Block | Expression;
     }
+    interface ArrowFunctionExpression extends FunctionExpression {
+        lineTerminatorBeforeArrow: boolean;
+    }
     interface LiteralExpression extends PrimaryExpression {
         text: string;
         isUnterminated?: boolean;

tests/baselines/reference/APISample_transform.js

@@ -1761,6 +1761,13 @@ declare module "typescript" {
 >body : Expression | Block
 >Block : Block
 >Expression : Expression
+    }
+    interface ArrowFunctionExpression extends FunctionExpression {
+>ArrowFunctionExpression : ArrowFunctionExpression
+>FunctionExpression : FunctionExpression
+
+        lineTerminatorBeforeArrow: boolean;
+>lineTerminatorBeforeArrow : boolean
     }
     interface LiteralExpression extends PrimaryExpression {
 >LiteralExpression : LiteralExpression

tests/baselines/reference/APISample_transform.types

@@ -621,6 +621,9 @@ declare module "typescript" {
         name?: Identifier;
         body: Block | Expression;
     }
+    interface ArrowFunctionExpression extends FunctionExpression {
+        lineTerminatorBeforeArrow: boolean;
+    }
     interface LiteralExpression extends PrimaryExpression {
         text: string;
         isUnterminated?: boolean;

tests/baselines/reference/APISample_watcher.js

@@ -1934,6 +1934,13 @@ declare module "typescript" {
 >body : Expression | Block
 >Block : Block
 >Expression : Expression
+    }
+    interface ArrowFunctionExpression extends FunctionExpression {
+>ArrowFunctionExpression : ArrowFunctionExpression
+>FunctionExpression : FunctionExpression
+
+        lineTerminatorBeforeArrow: boolean;
+>lineTerminatorBeforeArrow : boolean
     }
     interface LiteralExpression extends PrimaryExpression {
 >LiteralExpression : LiteralExpression