From dd1f982bded5c9fd51175be9ce569ac9e97551c3 Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 30 Apr 2015 17:40:35 +0200 Subject: [PATCH 001/309] Parse abstract keyword --- src/compiler/scanner.ts | 1 + src/compiler/types.ts | 22 ++++++++++++---------- src/compiler/utilities.ts | 2 ++ 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index f7224e619bb..94cb784ca88 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -43,6 +43,7 @@ module ts { } let textToToken: Map = { + "abstract": SyntaxKind.AbstractKeyword, "any": SyntaxKind.AnyKeyword, "as": SyntaxKind.AsKeyword, "boolean": SyntaxKind.BooleanKeyword, diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 4799f314063..1185b949e9c 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -131,6 +131,7 @@ module ts { StaticKeyword, YieldKeyword, // Contextual keywords + AbstractKeyword, AsKeyword, AnyKeyword, BooleanKeyword, @@ -307,17 +308,18 @@ module ts { Private = 0x00000020, // Property/Method Protected = 0x00000040, // Property/Method Static = 0x00000080, // Property/Method - Default = 0x00000100, // Function/Class (export default declaration) - MultiLine = 0x00000200, // Multi-line array or object literal - Synthetic = 0x00000400, // Synthetic node (for full fidelity) - DeclarationFile = 0x00000800, // Node is a .d.ts file - Let = 0x00001000, // Variable declaration - Const = 0x00002000, // Variable declaration - OctalLiteral = 0x00004000, // Octal numeric literal - Namespace = 0x00008000, // Namespace declaration - ExportContext = 0x00010000, // Export context (initialized by binding) + Abstract = 0x00000100, + Default = 0x00000200, // Function/Class (export default declaration) + MultiLine = 0x00000400, // Multi-line array or object literal + Synthetic = 0x00000800, // Synthetic node (for full fidelity) + DeclarationFile = 0x00001000, // Node is a .d.ts file + Let = 0x00002000, // Variable declaration + Const = 0x00004000, // Variable declaration + OctalLiteral = 0x00008000, // Octal numeric literal + Namespace = 0x00010000, // Namespace declaration + ExportContext = 0x00020000, // Export context (initialized by binding) - Modifier = Export | Ambient | Public | Private | Protected | Static | Default, + Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default, AccessibilityModifier = Public | Private | Protected, BlockScoped = Let | Const } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 5296f063a94..7dd89e9d99e 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1141,6 +1141,7 @@ module ts { case SyntaxKind.PrivateKeyword: case SyntaxKind.ProtectedKeyword: case SyntaxKind.StaticKeyword: + case SyntaxKind.AbstractKeyword: case SyntaxKind.ExportKeyword: case SyntaxKind.DeclareKeyword: case SyntaxKind.ConstKeyword: @@ -1626,6 +1627,7 @@ module ts { case SyntaxKind.PublicKeyword: return NodeFlags.Public; case SyntaxKind.ProtectedKeyword: return NodeFlags.Protected; case SyntaxKind.PrivateKeyword: return NodeFlags.Private; + case SyntaxKind.AbstractKeyword: return NodeFlags.Abstract; case SyntaxKind.ExportKeyword: return NodeFlags.Export; case SyntaxKind.DeclareKeyword: return NodeFlags.Ambient; case SyntaxKind.ConstKeyword: return NodeFlags.Const; From 0e72677fd2b2ad8414d193953939cc0b180eda05 Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 30 Apr 2015 17:43:07 +0200 Subject: [PATCH 002/309] Accept baseline changes --- tests/baselines/reference/APISample_linter.js | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js index cd2df23ffbf..d034b7ebd80 100644 --- a/tests/baselines/reference/APISample_linter.js +++ b/tests/baselines/reference/APISample_linter.js @@ -75,26 +75,26 @@ function delint(sourceFile) { delintNode(sourceFile); function delintNode(node) { switch (node.kind) { - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 186 /* WhileStatement */: - case 185 /* DoStatement */: - if (node.statement.kind !== 180 /* Block */) { + case 188 /* ForStatement */: + case 189 /* ForInStatement */: + case 187 /* WhileStatement */: + case 186 /* DoStatement */: + if (node.statement.kind !== 181 /* Block */) { report(node, "A looping statement's contents should be wrapped in a block body."); } break; - case 184 /* IfStatement */: + case 185 /* IfStatement */: var ifStatement = node; - if (ifStatement.thenStatement.kind !== 180 /* Block */) { + if (ifStatement.thenStatement.kind !== 181 /* Block */) { report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); } if (ifStatement.elseStatement && - ifStatement.elseStatement.kind !== 180 /* Block */ && - ifStatement.elseStatement.kind !== 184 /* IfStatement */) { + ifStatement.elseStatement.kind !== 181 /* Block */ && + ifStatement.elseStatement.kind !== 185 /* IfStatement */) { report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); } break; - case 170 /* BinaryExpression */: + case 171 /* BinaryExpression */: var op = node.operatorToken.kind; if (op === 28 /* EqualsEqualsToken */ || op == 29 /* ExclamationEqualsToken */) { report(node, "Use '===' and '!=='."); From b42e447df8b5716561fe833d4c2a57dc4660cd5f Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 30 Apr 2015 17:51:16 +0200 Subject: [PATCH 003/309] Error on creating a new instance of an abstract class --- src/compiler/checker.ts | 5 +++++ src/compiler/diagnosticInformationMap.generated.ts | 1 + src/compiler/diagnosticMessages.json | 4 ++++ 3 files changed, 10 insertions(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 469ecf80c84..eecd469d5a0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7084,6 +7084,11 @@ module ts { return resolveErrorCall(node); } + var valueDecl = (expressionType.symbol ? expressionType.symbol.valueDeclaration : undefined); + if (valueDecl && valueDecl.flags & NodeFlags.Abstract) { + error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declarationNameToString(valueDecl.name)); + } + // Technically, this signatures list may be incomplete. We are taking the apparent type, // but we are not including construct signatures that may have been added to the Object or // Function interface, since they have none by default. This is a bit of a leap of faith diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 98b5a170ae6..19c8e945346 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -363,6 +363,7 @@ module ts { An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." }, A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." }, A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." }, + Cannot_create_an_instance_of_the_abstract_class_0: { code: 2502, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'" }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 60d8e8e6515..68ca54990b9 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1440,6 +1440,10 @@ "category": "Error", "code": 2501 }, + "Cannot create an instance of the abstract class '{0}'": { + "category": "Error", + "code": 2502 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", From 3aeae55fc3e7733a2fc667d90ee26010b4bbc46c Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 30 Apr 2015 17:53:39 +0200 Subject: [PATCH 004/309] Output abstract keyword in declaration files (for classes) --- src/compiler/declarationEmitter.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index 5c705f18190..3082c12e2d6 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -908,6 +908,10 @@ module ts { emitJsDocComments(node); emitModuleElementDeclarationFlags(node); + if (node.flags & NodeFlags.Abstract) { + write("abstract "); + } + write("class "); writeTextOfNode(currentSourceFile, node.name); let prevEnclosingDeclaration = enclosingDeclaration; From 9436934aa58a7b172d5f5df4ef0e76fecaa9e944 Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 30 Apr 2015 18:34:06 +0200 Subject: [PATCH 005/309] Added test for abstract-classes --- tests/cases/compiler/abstractClass1.ts | 36 +++++++++++++++++++ .../compiler/abstractClassIdentifierName.ts | 4 +++ .../compiler/abstractIdentifierNameStrict.ts | 6 ++++ .../abstractInterfaceIdentifierName.ts | 4 +++ 4 files changed, 50 insertions(+) create mode 100644 tests/cases/compiler/abstractClass1.ts create mode 100644 tests/cases/compiler/abstractClassIdentifierName.ts create mode 100644 tests/cases/compiler/abstractIdentifierNameStrict.ts create mode 100644 tests/cases/compiler/abstractInterfaceIdentifierName.ts diff --git a/tests/cases/compiler/abstractClass1.ts b/tests/cases/compiler/abstractClass1.ts new file mode 100644 index 00000000000..1590ee907f0 --- /dev/null +++ b/tests/cases/compiler/abstractClass1.ts @@ -0,0 +1,36 @@ +// @declaration: true + +abstract class Foo { + constructor(f: any) { } + public static bar(): void { } + + public empty() { } +} + +class Bar extends Foo { + constructor(f: any) { + super(f); + } +} + +var a = new Foo(1); // Error +var b = new Foo(); // Error because of invalid constructor arguments + +module baz { + export abstract class Qux { + } + export class Quz extends Qux { + } +} + +new baz.Qux(); + +// Valid +var c = new Bar(1); +c.empty(); + +// Calling a static method on a abstract class is valid +Foo.bar(); + +var Copy = Foo; +new Copy(); diff --git a/tests/cases/compiler/abstractClassIdentifierName.ts b/tests/cases/compiler/abstractClassIdentifierName.ts new file mode 100644 index 00000000000..09d07f16fb8 --- /dev/null +++ b/tests/cases/compiler/abstractClassIdentifierName.ts @@ -0,0 +1,4 @@ +class abstract { + + abstract(): void { } +} diff --git a/tests/cases/compiler/abstractIdentifierNameStrict.ts b/tests/cases/compiler/abstractIdentifierNameStrict.ts new file mode 100644 index 00000000000..c75fbf43043 --- /dev/null +++ b/tests/cases/compiler/abstractIdentifierNameStrict.ts @@ -0,0 +1,6 @@ +var abstract = true; + +function foo() { + "use strict"; + var abstract = true; +} \ No newline at end of file diff --git a/tests/cases/compiler/abstractInterfaceIdentifierName.ts b/tests/cases/compiler/abstractInterfaceIdentifierName.ts new file mode 100644 index 00000000000..c7bdc100ccf --- /dev/null +++ b/tests/cases/compiler/abstractInterfaceIdentifierName.ts @@ -0,0 +1,4 @@ + +interface abstract { + abstract(): void; +} From 0ed7898f9f4cde41743c1cbf82040cf102406d0c Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 30 Apr 2015 18:35:57 +0200 Subject: [PATCH 006/309] Accepted baselines --- .../reference/abstractClass1.errors.txt | 57 ++++++++++ tests/baselines/reference/abstractClass1.js | 107 ++++++++++++++++++ .../reference/abstractClassIdentifierName.js | 14 +++ .../abstractClassIdentifierName.symbols | 8 ++ .../abstractClassIdentifierName.types | 8 ++ .../reference/abstractIdentifierNameStrict.js | 14 +++ .../abstractIdentifierNameStrict.symbols | 11 ++ .../abstractIdentifierNameStrict.types | 15 +++ .../abstractInterfaceIdentifierName.js | 8 ++ .../abstractInterfaceIdentifierName.symbols | 9 ++ .../abstractInterfaceIdentifierName.types | 9 ++ 11 files changed, 260 insertions(+) create mode 100644 tests/baselines/reference/abstractClass1.errors.txt create mode 100644 tests/baselines/reference/abstractClass1.js create mode 100644 tests/baselines/reference/abstractClassIdentifierName.js create mode 100644 tests/baselines/reference/abstractClassIdentifierName.symbols create mode 100644 tests/baselines/reference/abstractClassIdentifierName.types create mode 100644 tests/baselines/reference/abstractIdentifierNameStrict.js create mode 100644 tests/baselines/reference/abstractIdentifierNameStrict.symbols create mode 100644 tests/baselines/reference/abstractIdentifierNameStrict.types create mode 100644 tests/baselines/reference/abstractInterfaceIdentifierName.js create mode 100644 tests/baselines/reference/abstractInterfaceIdentifierName.symbols create mode 100644 tests/baselines/reference/abstractInterfaceIdentifierName.types diff --git a/tests/baselines/reference/abstractClass1.errors.txt b/tests/baselines/reference/abstractClass1.errors.txt new file mode 100644 index 00000000000..5892f542663 --- /dev/null +++ b/tests/baselines/reference/abstractClass1.errors.txt @@ -0,0 +1,57 @@ +tests/cases/compiler/abstractClass1.ts(15,9): error TS2502: Cannot create an instance of the abstract class 'Foo' +tests/cases/compiler/abstractClass1.ts(16,9): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/abstractClass1.ts(16,9): error TS2502: Cannot create an instance of the abstract class 'Foo' +tests/cases/compiler/abstractClass1.ts(25,1): error TS2502: Cannot create an instance of the abstract class 'Qux' +tests/cases/compiler/abstractClass1.ts(35,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/abstractClass1.ts(35,1): error TS2502: Cannot create an instance of the abstract class 'Foo' + + +==== tests/cases/compiler/abstractClass1.ts (6 errors) ==== + + abstract class Foo { + constructor(f: any) { } + public static bar(): void { } + + public empty() { } + } + + class Bar extends Foo { + constructor(f: any) { + super(f); + } + } + + var a = new Foo(1); // Error + ~~~~~~~~~~ +!!! error TS2502: Cannot create an instance of the abstract class 'Foo' + var b = new Foo(); // Error because of invalid constructor arguments + ~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + ~~~~~~~~~ +!!! error TS2502: Cannot create an instance of the abstract class 'Foo' + + module baz { + export abstract class Qux { + } + export class Quz extends Qux { + } + } + + new baz.Qux(); + ~~~~~~~~~~~~~ +!!! error TS2502: Cannot create an instance of the abstract class 'Qux' + + // Valid + var c = new Bar(1); + c.empty(); + + // Calling a static method on a abstract class is valid + Foo.bar(); + + var Copy = Foo; + new Copy(); + ~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + ~~~~~~~~~~ +!!! error TS2502: Cannot create an instance of the abstract class 'Foo' + \ No newline at end of file diff --git a/tests/baselines/reference/abstractClass1.js b/tests/baselines/reference/abstractClass1.js new file mode 100644 index 00000000000..4cb36d91ae1 --- /dev/null +++ b/tests/baselines/reference/abstractClass1.js @@ -0,0 +1,107 @@ +//// [abstractClass1.ts] + +abstract class Foo { + constructor(f: any) { } + public static bar(): void { } + + public empty() { } +} + +class Bar extends Foo { + constructor(f: any) { + super(f); + } +} + +var a = new Foo(1); // Error +var b = new Foo(); // Error because of invalid constructor arguments + +module baz { + export abstract class Qux { + } + export class Quz extends Qux { + } +} + +new baz.Qux(); + +// Valid +var c = new Bar(1); +c.empty(); + +// Calling a static method on a abstract class is valid +Foo.bar(); + +var Copy = Foo; +new Copy(); + + +//// [abstractClass1.js] +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Foo = (function () { + function Foo(f) { + } + Foo.bar = function () { }; + Foo.prototype.empty = function () { }; + return Foo; +})(); +var Bar = (function (_super) { + __extends(Bar, _super); + function Bar(f) { + _super.call(this, f); + } + return Bar; +})(Foo); +var a = new Foo(1); // Error +var b = new Foo(); // Error because of invalid constructor arguments +var baz; +(function (baz) { + var Qux = (function () { + function Qux() { + } + return Qux; + })(); + baz.Qux = Qux; + var Quz = (function (_super) { + __extends(Quz, _super); + function Quz() { + _super.apply(this, arguments); + } + return Quz; + })(Qux); + baz.Quz = Quz; +})(baz || (baz = {})); +new baz.Qux(); +// Valid +var c = new Bar(1); +c.empty(); +// Calling a static method on a abstract class is valid +Foo.bar(); +var Copy = Foo; +new Copy(); + + +//// [abstractClass1.d.ts] +declare abstract class Foo { + constructor(f: any); + static bar(): void; + empty(): void; +} +declare class Bar extends Foo { + constructor(f: any); +} +declare var a: Foo; +declare var b: any; +declare module baz { + abstract class Qux { + } + class Quz extends Qux { + } +} +declare var c: Bar; +declare var Copy: typeof Foo; diff --git a/tests/baselines/reference/abstractClassIdentifierName.js b/tests/baselines/reference/abstractClassIdentifierName.js new file mode 100644 index 00000000000..71827d2cb5b --- /dev/null +++ b/tests/baselines/reference/abstractClassIdentifierName.js @@ -0,0 +1,14 @@ +//// [abstractClassIdentifierName.ts] +class abstract { + + abstract(): void { } +} + + +//// [abstractClassIdentifierName.js] +var abstract = (function () { + function abstract() { + } + abstract.prototype.abstract = function () { }; + return abstract; +})(); diff --git a/tests/baselines/reference/abstractClassIdentifierName.symbols b/tests/baselines/reference/abstractClassIdentifierName.symbols new file mode 100644 index 00000000000..41c46649c43 --- /dev/null +++ b/tests/baselines/reference/abstractClassIdentifierName.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/abstractClassIdentifierName.ts === +class abstract { +>abstract : Symbol(abstract, Decl(abstractClassIdentifierName.ts, 0, 0)) + + abstract(): void { } +>abstract : Symbol(abstract, Decl(abstractClassIdentifierName.ts, 0, 16)) +} + diff --git a/tests/baselines/reference/abstractClassIdentifierName.types b/tests/baselines/reference/abstractClassIdentifierName.types new file mode 100644 index 00000000000..ef152979f13 --- /dev/null +++ b/tests/baselines/reference/abstractClassIdentifierName.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/abstractClassIdentifierName.ts === +class abstract { +>abstract : abstract + + abstract(): void { } +>abstract : () => void +} + diff --git a/tests/baselines/reference/abstractIdentifierNameStrict.js b/tests/baselines/reference/abstractIdentifierNameStrict.js new file mode 100644 index 00000000000..8544019c4d1 --- /dev/null +++ b/tests/baselines/reference/abstractIdentifierNameStrict.js @@ -0,0 +1,14 @@ +//// [abstractIdentifierNameStrict.ts] +var abstract = true; + +function foo() { + "use strict"; + var abstract = true; +} + +//// [abstractIdentifierNameStrict.js] +var abstract = true; +function foo() { + "use strict"; + var abstract = true; +} diff --git a/tests/baselines/reference/abstractIdentifierNameStrict.symbols b/tests/baselines/reference/abstractIdentifierNameStrict.symbols new file mode 100644 index 00000000000..f983ddccdc9 --- /dev/null +++ b/tests/baselines/reference/abstractIdentifierNameStrict.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/abstractIdentifierNameStrict.ts === +var abstract = true; +>abstract : Symbol(abstract, Decl(abstractIdentifierNameStrict.ts, 0, 3)) + +function foo() { +>foo : Symbol(foo, Decl(abstractIdentifierNameStrict.ts, 0, 20)) + + "use strict"; + var abstract = true; +>abstract : Symbol(abstract, Decl(abstractIdentifierNameStrict.ts, 4, 7)) +} diff --git a/tests/baselines/reference/abstractIdentifierNameStrict.types b/tests/baselines/reference/abstractIdentifierNameStrict.types new file mode 100644 index 00000000000..e43207007e0 --- /dev/null +++ b/tests/baselines/reference/abstractIdentifierNameStrict.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/abstractIdentifierNameStrict.ts === +var abstract = true; +>abstract : boolean +>true : boolean + +function foo() { +>foo : () => void + + "use strict"; +>"use strict" : string + + var abstract = true; +>abstract : boolean +>true : boolean +} diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.js b/tests/baselines/reference/abstractInterfaceIdentifierName.js new file mode 100644 index 00000000000..c3913ae5cdf --- /dev/null +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.js @@ -0,0 +1,8 @@ +//// [abstractInterfaceIdentifierName.ts] + +interface abstract { + abstract(): void; +} + + +//// [abstractInterfaceIdentifierName.js] diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.symbols b/tests/baselines/reference/abstractInterfaceIdentifierName.symbols new file mode 100644 index 00000000000..db2ad0aceba --- /dev/null +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/abstractInterfaceIdentifierName.ts === + +interface abstract { +>abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 0, 0)) + + abstract(): void; +>abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 1, 20)) +} + diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.types b/tests/baselines/reference/abstractInterfaceIdentifierName.types new file mode 100644 index 00000000000..3a5c6024f4c --- /dev/null +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/abstractInterfaceIdentifierName.ts === + +interface abstract { +>abstract : abstract + + abstract(): void; +>abstract : () => void +} + From d19a200750ab16720d0a383b3cc1c85d3c38ddb4 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 5 May 2015 17:57:21 -0700 Subject: [PATCH 007/309] Added types, scan, parse, and check for async functions --- src/compiler/checker.ts | 447 +++++++++++++++++- .../diagnosticInformationMap.generated.ts | 29 +- src/compiler/diagnosticMessages.json | 101 +++- src/compiler/parser.ts | 425 +++++++++++------ src/compiler/scanner.ts | 2 + src/compiler/types.ts | 54 ++- src/compiler/utilities.ts | 19 + src/lib/core.d.ts | 12 + src/lib/es6.d.ts | 10 - 9 files changed, 906 insertions(+), 193 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 04766f22c4e..13f527bd9f8 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -89,7 +89,7 @@ module ts { let nullType = createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsUndefinedOrNull, "null"); let unknownType = createIntrinsicType(TypeFlags.Any, "unknown"); let resolvingType = createIntrinsicType(TypeFlags.Any, "__resolving__"); - + let emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); let anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); let noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); @@ -101,6 +101,8 @@ module ts { let globalArraySymbol: Symbol; let globalESSymbolConstructorSymbol: Symbol; + + let getGlobalPromiseSymbol: () => Symbol; let globalObjectType: ObjectType; let globalFunctionType: ObjectType; @@ -118,6 +120,11 @@ module ts { let getGlobalParameterDecoratorType: () => ObjectType; let getGlobalPropertyDecoratorType: () => ObjectType; let getGlobalMethodDecoratorType: () => ObjectType; + let getGlobalPromiseType: () => ObjectType; + let getGlobalPromiseLikeType: () => ObjectType; + let getInstantiatedGlobalPromiseLikeType: () => ObjectType; + let getGlobalPromiseConstructorLikeType: () => ObjectType; + let getGlobalThenableType: () => ObjectType; let tupleTypes: Map = {}; let unionTypes: Map = {}; @@ -125,11 +132,14 @@ module ts { let emitExtends = false; let emitDecorate = false; let emitParam = false; + let emitAwaiter = false; + let emitGenerator = false; let mergedSymbols: Symbol[] = []; let symbolLinks: SymbolLinks[] = []; let nodeLinks: NodeLinks[] = []; let potentialThisCollisions: Node[] = []; + var potentialArgumentsCollisions: Node[] = []; let diagnostics = createDiagnosticCollection(); @@ -5146,9 +5156,11 @@ module ts { case SyntaxKind.ParenthesizedExpression: case SyntaxKind.PrefixUnaryExpression: case SyntaxKind.DeleteExpression: + case SyntaxKind.AwaitExpression: case SyntaxKind.TypeOfExpression: case SyntaxKind.VoidExpression: case SyntaxKind.PostfixUnaryExpression: + case SyntaxKind.YieldExpression: case SyntaxKind.ConditionalExpression: case SyntaxKind.SpreadElementExpression: case SyntaxKind.Block: @@ -5406,8 +5418,14 @@ module ts { // will be bound to non-arrow function that contain this arrow function. This results in inconsistent behavior. // To avoid that we will give an error to users if they use arguments objects in arrow function so that they // can explicitly bound arguments objects - if (symbol === argumentsSymbol && getContainingFunction(node).kind === SyntaxKind.ArrowFunction && languageVersion < ScriptTarget.ES6) { - error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); + let container = getContainingFunction(node); + if (symbol === argumentsSymbol) { + if (container.kind === SyntaxKind.ArrowFunction && languageVersion < ScriptTarget.ES6) { + error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); + } + else if (node.parserContextFlags & ParserContextFlags.Await) { + captureLexicalArguments(node, container); + } } if (symbol.flags & SymbolFlags.Alias && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { @@ -5416,6 +5434,7 @@ module ts { checkCollisionWithCapturedSuperVariable(node, node); checkCollisionWithCapturedThisVariable(node, node); + checkCollisionWithCapturedArgumentsVariable(node, node); checkBlockScopedBindingCapturedInLoop(node, symbol); return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node); @@ -5497,6 +5516,11 @@ module ts { // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES6); } + + if (node.parserContextFlags & ParserContextFlags.Await) { + // if 'this' is part of an async function, we will need to capture 'this' + needToCaptureLexicalThis = true; + } switch (container.kind) { case SyntaxKind.ModuleDeclaration: @@ -5537,6 +5561,14 @@ module ts { return anyType; } + function captureLexicalArguments(node: Node, container: Node): void { + if (node.parent.kind !== SyntaxKind.Parameter) { + getNodeLinks(node).flags |= NodeCheckFlags.LexicalArguments; + } + + getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments; + } + function isInConstructorArgumentInitializer(node: Node, constructorDecl: Node): boolean { for (let n = node; n && n !== constructorDecl; n = n.parent) { if (n.kind === SyntaxKind.Parameter) { @@ -7220,22 +7252,42 @@ module ts { links.type = instantiateType(getTypeOfSymbol(lastOrUndefined(context.parameters)), mapper); } } + + function createPromiseType(promisedType: Type, location: Node): Type { + // creates a `Promise` type where `T` is the promisedType argument + let globalPromiseType = getGlobalPromiseType(); + if (globalPromiseType !== emptyObjectType) { + // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type + promisedType = getAwaitedType(promisedType); + return createTypeReference(globalPromiseType, [promisedType]); + } + + error(location, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return unknownType; + } function getReturnTypeFromBody(func: FunctionLikeDeclaration, contextualMapper?: TypeMapper): Type { let contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func); if (!func.body) { return unknownType; } + + let isAsync = isAsyncFunctionLike(func); let type: Type; if (func.body.kind !== SyntaxKind.Block) { - type = checkExpressionCached(func.body, contextualMapper); + type = isAsync + ? checkAwaitedExpressionCached(func.body, contextualMapper) + : checkExpressionCached(func.body, contextualMapper); } else { // Aggregate the types of expressions within all the return statements. let types = checkAndAggregateReturnExpressionTypes(func.body, contextualMapper); if (types.length === 0) { - return voidType; + return isAsync + ? createPromiseType(voidType, func) + : voidType; } + // When return statements are contextually typed we allow the return type to be a union type. Otherwise we require the // return expressions to have a best common supertype. type = contextualSignature ? getUnionType(types) : getCommonSupertype(types); @@ -7247,17 +7299,23 @@ module ts { if (!contextualSignature) { reportErrorsFromWidening(func, type); } - return getWidenedType(type); + + let widenedType = getWidenedType(type); + return isAsync + ? createPromiseType(widenedType, func) + : type; } /// Returns a set of types relating to every return expression relating to a function block. - function checkAndAggregateReturnExpressionTypes(body: Block, contextualMapper?: TypeMapper): Type[] { + function checkAndAggregateReturnExpressionTypes(body: Block, contextualMapper?: TypeMapper, isAsync?: boolean): Type[] { let aggregatedTypes: Type[] = []; forEachReturnStatement(body, returnStatement => { let expr = returnStatement.expression; if (expr) { - let type = checkExpressionCached(expr, contextualMapper); + let type = isAsync + ? checkAwaitedExpressionCached(expr, contextualMapper) + : checkExpressionCached(expr, contextualMapper); if (!contains(aggregatedTypes, type)) { aggregatedTypes.push(type); } @@ -7327,6 +7385,12 @@ module ts { if (contextualMapper === identityMapper && isContextSensitive(node)) { return anyFunctionType; } + + let isAsync = isAsyncFunctionLike(node); + if (isAsync) { + emitAwaiter = true; + } + let links = getNodeLinks(node); let type = getTypeOfSymbol(node.symbol); // Check if function expression is contextually typed and assign parameter types if so @@ -7357,6 +7421,7 @@ module ts { if (produceDiagnostics && node.kind !== SyntaxKind.MethodDeclaration && node.kind !== SyntaxKind.MethodSignature) { checkCollisionWithCapturedSuperVariable(node, (node).name); checkCollisionWithCapturedThisVariable(node, (node).name); + checkCollisionWithCapturedArgumentsVariable(node, (node).name); } return type; @@ -7364,8 +7429,21 @@ module ts { function checkFunctionExpressionOrObjectLiteralMethodBody(node: FunctionExpression | MethodDeclaration) { Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node)); - if (node.type && !node.asteriskToken) { - checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); + + let isAsync = isAsyncFunctionLike(node); + let returnType = node.type && getTypeFromTypeNode(node.type); + let promisedType: Type; + if (returnType && isAsync) { + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so we + // should not be checking assignability of a promise to the return type. Instead, we need to + // check assignability of the awaited type of the concise body against the promised type of + // its return type annotation. + promisedType = checkAsyncFunctionReturnType(node, returnType); + } + + if (returnType && !node.asteriskToken) { + checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); } if (node.body) { @@ -7374,8 +7452,11 @@ module ts { } else { let exprType = checkExpression(node.body); - if (node.type) { - checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, /*headMessage*/ undefined); + if (returnType) { + checkTypeAssignableTo( + isAsync ? getAwaitedType(exprType) : exprType, + isAsync ? promisedType : returnType, + node.body); } checkFunctionExpressionBodies(node.body); } @@ -7490,6 +7571,22 @@ module ts { return undefinedType; } + function checkAwaitExpression(node: AwaitExpression): Type { + // Grammar checking + if (!(node.parserContextFlags & ParserContextFlags.Await)) { + var parameter = getContainingParameter(node); + if (parameter && parameter.parserContextFlags & ParserContextFlags.Await) { + grammarErrorAfterFirstToken(node, Diagnostics._0_expression_is_not_allowed_in_an_initializer, "await"); + } + else { + grammarErrorOnFirstToken(node, Diagnostics.await_expression_must_be_contained_within_an_async_function); + } + } + + var operandType = checkExpression(node.expression); + return getAwaitedType(operandType); + } + function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type { // Grammar checking // The identifier eval or arguments may not appear as the LeftHandSideExpression of an @@ -7897,7 +7994,13 @@ module ts { function checkYieldExpression(node: YieldExpression): void { // Grammar checking if (!(node.parserContextFlags & ParserContextFlags.Yield)) { - grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration); + let parameter = getContainingParameter(node); + if (parameter && (parameter.parserContextFlags & ParserContextFlags.GeneratorParameter)) { + grammarErrorAfterFirstToken(node, Diagnostics._0_expression_is_not_allowed_in_an_initializer, "yield"); + } + else { + grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration); + } } else { grammarErrorOnFirstToken(node, Diagnostics.yield_expressions_are_not_currently_supported); @@ -7931,6 +8034,15 @@ module ts { node.contextualType = saveContextualType; return result; } + + function checkAwaitedExpressionCached(node: Expression, contextualMapper?: TypeMapper): Type { + let links = getNodeLinks(node); + if (!links.resolvedAwaitedType) { + links.resolvedAwaitedType = getAwaitedType(checkExpressionCached(node, contextualMapper)); + } + + return links.resolvedAwaitedType; + } function checkExpressionCached(node: Expression, contextualMapper?: TypeMapper): Type { let links = getNodeLinks(node); @@ -8078,6 +8190,8 @@ module ts { return checkDeleteExpression(node); case SyntaxKind.VoidExpression: return checkVoidExpression(node); + case SyntaxKind.AwaitExpression: + return checkAwaitExpression(node); case SyntaxKind.PrefixUnaryExpression: return checkPrefixUnaryExpression(node); case SyntaxKind.PostfixUnaryExpression: @@ -8166,6 +8280,7 @@ module ts { } if (produceDiagnostics) { + checkCollisionWithAwaiterVariablesInGeneratedCode(node, node.name); checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { @@ -8177,6 +8292,22 @@ module ts { break; } } + if (isAsyncFunctionLike(node)) { + var promiseConstructor = getPromiseConstructor(node); + if (promiseConstructor) { + var promiseIdentifier = getFirstIdentifier(promiseConstructor); + var promiseName = promiseIdentifier.text; + var typeSymbol = resolveName(node, promiseName, SymbolFlags.Type | SymbolFlags.Module, undefined, undefined); + var valueSymbol = resolveName(node, promiseName, SymbolFlags.Value, undefined, undefined); + if (typeSymbol !== valueSymbol) { + var valueLinks = getNodeLinks(valueSymbol.valueDeclaration); + if (!(valueLinks.flags & NodeCheckFlags.PromiseCollision)) { + valueLinks.flags |= NodeCheckFlags.PromiseCollision; + error(valueSymbol.valueDeclaration, Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, promiseName, getTextOfNode(promiseConstructor)); + } + } + } + } } checkSpecializedSignatureDeclaration(node); @@ -8772,6 +8903,113 @@ module ts { } } + function getPromisedType(type: Type): Type { + // the "promised type" of a type is the type of the "value" argument of the "onfulfilled" callback. + let globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType(); + if (globalPromiseLikeType !== emptyObjectType && isTypeAssignableTo(type, globalPromiseLikeType)) { + let awaitedTypes: Type[] = []; + let thenProp = getPropertyOfType(type, "then"); + let thenType = getTypeOfSymbol(thenProp); + let thenSignatures = getSignaturesOfType(thenType, SignatureKind.Call); + for (let thenSignature of thenSignatures) { + thenSignature = getErasedSignature(thenSignature); + let onfulfilledParameterType = getTypeAtPosition(thenSignature, 0); + let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call); + for (let onfulfilledParameterSignature of onfulfilledParameterSignatures) { + let valueParameterType = getTypeAtPosition(onfulfilledParameterSignature, 0); + if (valueParameterType !== type) { + awaitedTypes.push(valueParameterType); + } + } + } + + return getUnionType(awaitedTypes); + } + + return emptyObjectType; + } + + function getAwaitedType(type: Type): Type { + // The "awaited type" of an expression is its "promised type" if the expression is a `Promise`; otherwise, it is the type of the expression. + + let promisedType = getPromisedType(type); + if (promisedType === emptyObjectType) { + return type; + } + + // if we have a bad actor in the form of a promise whose promised type is the same promise, return the empty type. + // if this were the actual case in the JavaScript, this Promise would never resolve. + if (promisedType === type) { + return emptyObjectType; + } + + // unwrap any nested promises + let seen: boolean[]; + while (true) { + let nestedPromisedType = getPromisedType(promisedType); + if (nestedPromisedType === emptyObjectType) { + // if this could not be unwrapped further, return the promised type + return promisedType; + } + + if (!seen) { + // `seen` keeps track of types we've tried to await to avoid cycles + seen = []; + seen[type.id] = true; + seen[promisedType.id] = true; + } + else if (seen[nestedPromisedType.id]) { + // if we've already seen this type, this is a promise that would never resolve. As above, we return the empty type. + return emptyObjectType; + } + + seen[nestedPromisedType.id] = true; + promisedType = nestedPromisedType; + } + + return promisedType; + + // if we didn't get a promised type, check the type does not have a callable then member. + if (isTypeAssignableTo(type, getGlobalThenableType())) { + error(null, Diagnostics.Type_for_await_does_not_have_a_valid_callable_then_member); + return emptyObjectType; + } + + // if the type was not a "promise" or a "thenable", return the type. + return type; + } + + function checkAsyncFunctionReturnType(node: SignatureDeclaration, returnType: Type): Type { + // This checks that an async function has a valid Promise-compatible return type, and returns the *awaited type* of the promise. + // An async function has a valid Promise-compatible return type if the resolved value of the return type has a construct + // signature that takes in an `initializer` function that in turn supplies a `resolve` function as one of its arguments + // and results in an object with a callable `then` signature. + let globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(); + if (globalPromiseConstructorLikeType !== emptyObjectType) { + if (!returnType) { + returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(node)); + } + + // get the constructor type of the return type + var declaredType = returnType.symbol ? getTypeOfSymbol(returnType.symbol) : emptyObjectType; + if (isTypeAssignableTo(declaredType, globalPromiseConstructorLikeType)) { + var promisedType = getPromisedType(returnType); + if (promisedType !== emptyObjectType) { + // unwrap the promised type + var promiseConstructor = getPromiseConstructor(node); + if (promiseConstructor) { + emitAwaiter = true; + checkExpressionOrQualifiedName(promiseConstructor); + return getAwaitedType(promisedType); + } + } + } + } + + error(node, ts.Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return emptyObjectType; + } + /** Check a decorator */ function checkDecorator(node: Decorator): void { let expression: Expression = node.expression; @@ -8904,6 +9142,7 @@ module ts { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); + checkCollisionWithCapturedArgumentsVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); } } @@ -8946,7 +9185,14 @@ module ts { checkSourceElement(node.body); if (node.type && !isAccessor(node.kind) && !node.asteriskToken) { - checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); + let returnType = getTypeFromTypeNode(node.type); + let isAsync = isAsyncFunctionLike(node); + let promisedType: Type; + if (isAsync) { + promisedType = checkAsyncFunctionReturnType(node, returnType); + } + + checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); } // Report an implicit any error if there is no body, no explicit return type, and node is not a private method @@ -9016,6 +9262,12 @@ module ts { } } + function checkCollisionWithCapturedArgumentsVariable(node: Node, name: Identifier): void { + if (needCollisionCheckForIdentifier(node, name, "_arguments")) { + potentialArgumentsCollisions.push(node); + } + } + // this function will run after checking the source file so 'CaptureThis' is correct for all nodes function checkIfThisIsCapturedInEnclosingScope(node: Node): void { let current = node; @@ -9034,6 +9286,25 @@ module ts { } } + function checkIfArgumentsIsCapturedInEnclosingScope(node: Node): void { + let current = node; + while (current) { + if (getNodeCheckFlags(current) & NodeCheckFlags.CaptureArguments) { + let isDeclaration = node.kind !== SyntaxKind.Identifier; + if (isDeclaration) { + error((node).name, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_variable_declaration_arguments_to_capture_arguments_reference); + } + else { + error(node, Diagnostics.Expression_resolves_to_variable_declaration_arguments_that_compiler_uses_to_capture_arguments_reference); + } + + return; + } + + current = current.parent; + } + } + function checkCollisionWithCapturedSuperVariable(node: Node, name: Identifier) { if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; @@ -9149,6 +9420,34 @@ module ts { } } + function getPromiseConstructor(node: SignatureDeclaration): EntityName { + if (node.type && node.type.kind === SyntaxKind.TypeReference) { + return (node.type).typeName; + } + + let globalPromiseSymbol = getGlobalPromiseSymbol(); + if (globalPromiseSymbol && globalPromiseSymbol === resolveName(node, "Promise", SymbolFlags.Value, undefined, undefined)) { + return globalPromiseSymbol.valueDeclaration.name; + } + + return undefined; + } + + function checkCollisionWithAwaiterVariablesInGeneratedCode(node: Node, name: DeclarationName): void { + if (!name || name.kind !== SyntaxKind.Identifier || isTypeNode(name)) { + return; + } + + let identifier = name; + let container = getContainingFunction(name); + if (container && isAsyncFunctionLike(container) && node.kind !== SyntaxKind.Identifier) { + var promiseConstructor = getPromiseConstructor(container); + if (promiseConstructor && promiseConstructor.kind === SyntaxKind.Identifier && (promiseConstructor).text === identifier.text) { + error(node, Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, identifier.text, getTextOfNode(promiseConstructor)); + } + } + } + function isParameterDeclaration(node: VariableLikeDeclaration) { while (node.kind === SyntaxKind.BindingElement) { node = node.parent.parent; @@ -9251,8 +9550,14 @@ module ts { } checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); + checkCollisionWithCapturedArgumentsVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); } + + if (symbol === argumentsSymbol && (node.parserContextFlags & ParserContextFlags.Await)) { + let container = getContainingFunction(node); + captureLexicalArguments(node.name, container); + } } function checkVariableDeclaration(node: VariableDeclaration) { @@ -9275,7 +9580,10 @@ module ts { function checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node: Node) { if (node.modifiers) { if (inBlockOrObjectLiteralExpression(node)) { - return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); + // disallow all but the `async` modifier here + if (isAccessor(node.kind) || !isFunctionLike(node) || (node.modifiers.flags & ~NodeFlags.Async)) { + return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); + } } } } @@ -9288,6 +9596,8 @@ module ts { node = node.parent; } + + return false; } function checkExpressionStatement(node: ExpressionStatement) { @@ -9667,8 +9977,11 @@ module ts { error(node.expression, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } } + else if (func.type && !isAccessor(func.kind) && isAsyncFunctionLike(func)) { + checkTypeAssignableTo(getAwaitedType(exprType), getPromisedType(returnType), node.expression); + } else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) { - checkTypeAssignableTo(exprType, returnType, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(exprType, returnType, node.expression); } } } @@ -9943,6 +10256,7 @@ module ts { checkTypeNameIsReserved(node.name, Diagnostics.Class_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkCollisionWithAwaiterVariablesInGeneratedCode(node, node.name); } checkTypeParameters(node.typeParameters); checkExportsOnMergedDeclarations(node); @@ -10386,6 +10700,7 @@ module ts { checkTypeNameIsReserved(node.name, Diagnostics.Enum_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkCollisionWithAwaiterVariablesInGeneratedCode(node, node.name); checkExportsOnMergedDeclarations(node); computeEnumMemberValues(node); @@ -10885,12 +11200,14 @@ module ts { case SyntaxKind.ParenthesizedExpression: case SyntaxKind.TypeOfExpression: case SyntaxKind.VoidExpression: + case SyntaxKind.AwaitExpression: case SyntaxKind.DeleteExpression: case SyntaxKind.PrefixUnaryExpression: case SyntaxKind.PostfixUnaryExpression: case SyntaxKind.BinaryExpression: case SyntaxKind.ConditionalExpression: case SyntaxKind.SpreadElementExpression: + case SyntaxKind.YieldExpression: case SyntaxKind.Block: case SyntaxKind.ModuleBlock: case SyntaxKind.VariableStatement: @@ -10941,6 +11258,7 @@ module ts { emitDecorate = false; emitParam = false; potentialThisCollisions.length = 0; + potentialArgumentsCollisions.length = 0; forEach(node.statements, checkSourceElement); checkFunctionExpressionBodies(node); @@ -10953,6 +11271,11 @@ module ts { forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope); potentialThisCollisions.length = 0; } + + if (potentialArgumentsCollisions.length) { + forEach(potentialArgumentsCollisions, checkIfArgumentsIsCapturedInEnclosingScope); + potentialArgumentsCollisions.length = 0; + } if (emitExtends) { links.flags |= NodeCheckFlags.EmitExtends; @@ -10965,6 +11288,14 @@ module ts { if (emitParam) { links.flags |= NodeCheckFlags.EmitParam; } + + if (emitAwaiter) { + links.flags |= NodeCheckFlags.EmitAwaiter; + } + + if (emitGenerator || (emitAwaiter && languageVersion < ScriptTarget.ES6)) { + links.flags |= NodeCheckFlags.EmitGenerator; + } links.flags |= NodeCheckFlags.TypeChecked; } @@ -11982,6 +12313,12 @@ module ts { getGlobalPropertyDecoratorType = memoize(() => getGlobalType("PropertyDecorator")); getGlobalMethodDecoratorType = memoize(() => getGlobalType("MethodDecorator")); getGlobalParameterDecoratorType = memoize(() => getGlobalType("ParameterDecorator")); + getGlobalPromiseSymbol = memoize(() => getGlobalTypeSymbol("Promise")); + getGlobalPromiseType = memoize(() => getTypeOfGlobalSymbol(getGlobalPromiseSymbol(), /*arity*/ 1)); + getGlobalPromiseLikeType = memoize(() => getGlobalType("PromiseLike", /*arity*/ 1)); + getInstantiatedGlobalPromiseLikeType = memoize(createInstantiatedPromiseLikeType); + getGlobalPromiseConstructorLikeType = memoize(() => getGlobalType("PromiseConstructorLike")); + getGlobalThenableType = memoize(createThenableType); // If we're in ES6 mode, load the TemplateStringsArray. // Otherwise, default to 'unknown' for the purposes of type checking in LS scenarios. @@ -12003,6 +12340,26 @@ module ts { anyArrayType = createArrayType(anyType); } + + function createInstantiatedPromiseLikeType(): ObjectType { + let promiseLikeType = getGlobalPromiseLikeType(); + if (promiseLikeType !== emptyObjectType) { + return createTypeReference(promiseLikeType, [anyType]); + } + + return emptyObjectType; + } + + function createThenableType() { + // build the thenable type that is used to verify against a non-promise "thenable" operand to `await`. + let thenPropertySymbol = createSymbol(SymbolFlags.Transient | SymbolFlags.Property, "then"); + getSymbolLinks(thenPropertySymbol).type = globalFunctionType; + + let thenableType = createObjectType(TypeFlags.ObjectType); + thenableType.properties = [thenPropertySymbol]; + thenableType.members = createSymbolTable(thenableType.properties); + return thenableType; + } // GRAMMAR CHECKING function isReservedWordInStrictMode(node: Identifier): boolean { @@ -12203,7 +12560,7 @@ module ts { return; } - let lastStatic: Node, lastPrivate: Node, lastProtected: Node, lastDeclare: Node; + let lastStatic: Node, lastPrivate: Node, lastProtected: Node, lastDeclare: Node, lastAsync: Node; let flags = 0; for (let modifier of node.modifiers) { switch (modifier.kind) { @@ -12229,6 +12586,9 @@ module ts { else if (flags & NodeFlags.Static) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } + else if (flags & NodeFlags.Async) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "async"); + } else if (node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } @@ -12239,6 +12599,9 @@ module ts { if (flags & NodeFlags.Static) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "static"); } + else if (flags & NodeFlags.Async) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "async"); + } else if (node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } @@ -12256,6 +12619,9 @@ module ts { else if (flags & NodeFlags.Ambient) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } + else if (flags & NodeFlags.Async) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "async"); + } else if (node.parent.kind === SyntaxKind.ClassDeclaration) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } @@ -12269,6 +12635,9 @@ module ts { if (flags & NodeFlags.Ambient) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "declare"); } + else if (flags & NodeFlags.Async) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async"); + } else if (node.parent.kind === SyntaxKind.ClassDeclaration) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } @@ -12281,6 +12650,20 @@ module ts { flags |= NodeFlags.Ambient; lastDeclare = modifier break; + + case SyntaxKind.AsyncKeyword: + if (flags & NodeFlags.Async) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "async"); + } + else if (flags & NodeFlags.Ambient || isInAmbientContext(node.parent)) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async"); + } + else if (node.kind === SyntaxKind.Parameter) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async"); + } + flags |= NodeFlags.Async; + lastAsync = modifier; + break; } } @@ -12294,16 +12677,42 @@ module ts { else if (flags & NodeFlags.Private) { return grammarErrorOnNode(lastPrivate, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } + else if (flags & NodeFlags.Async) { + return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async"); + } + return; } else if ((node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration) && flags & NodeFlags.Ambient) { - return grammarErrorOnNode(lastDeclare, Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); + return grammarErrorOnNode(lastDeclare, Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare"); } else if (node.kind === SyntaxKind.InterfaceDeclaration && flags & NodeFlags.Ambient) { - return grammarErrorOnNode(lastDeclare, Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare"); + return grammarErrorOnNode(lastDeclare, Diagnostics.A_0_modifier_cannot_be_used_with_an_interface_declaration, "declare"); } else if (node.kind === SyntaxKind.Parameter && (flags & NodeFlags.AccessibilityModifier) && isBindingPattern((node).name)) { return grammarErrorOnNode(node, Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } + if (flags & NodeFlags.Async) { + return checkGrammarAsyncModifier(node, lastAsync); + } + } + + function checkGrammarAsyncModifier(node: Node, asyncModifier: Node): boolean { + if (languageVersion < ScriptTarget.ES6) { + return grammarErrorOnNode(asyncModifier, Diagnostics.Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher); + } + + switch (node.kind) { + case SyntaxKind.MethodDeclaration: + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + if (!(node).asteriskToken) { + return false; + } + break; + } + + return grammarErrorOnNode(asyncModifier, Diagnostics._0_modifier_cannot_be_used_here, "async"); } function checkGrammarForDisallowedTrailingComma(list: NodeArray): boolean { diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 14163e81195..091cabb4480 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -34,8 +34,12 @@ module ts { Statements_are_not_allowed_in_ambient_contexts: { code: 1036, category: DiagnosticCategory.Error, key: "Statements are not allowed in ambient contexts." }, A_declare_modifier_cannot_be_used_in_an_already_ambient_context: { code: 1038, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used in an already ambient context." }, Initializers_are_not_allowed_in_ambient_contexts: { code: 1039, category: DiagnosticCategory.Error, key: "Initializers are not allowed in ambient contexts." }, + _0_modifier_cannot_be_used_in_an_ambient_context: { code: 1040, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used in an ambient context." }, + _0_modifier_cannot_be_used_with_a_class_declaration: { code: 1041, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a class declaration." }, + _0_modifier_cannot_be_used_here: { code: 1042, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used here." }, + _0_modifier_cannot_appear_on_a_data_property: { code: 1043, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a data property." }, _0_modifier_cannot_appear_on_a_module_element: { code: 1044, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a module element." }, - A_declare_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an interface declaration." }, + A_0_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: DiagnosticCategory.Error, key: "A '{0}' modifier cannot be used with an interface declaration." }, A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file: { code: 1046, category: DiagnosticCategory.Error, key: "A 'declare' modifier is required for a top level declaration in a .d.ts file." }, A_rest_parameter_cannot_be_optional: { code: 1047, category: DiagnosticCategory.Error, key: "A rest parameter cannot be optional." }, A_rest_parameter_cannot_have_an_initializer: { code: 1048, category: DiagnosticCategory.Error, key: "A rest parameter cannot have an initializer." }, @@ -45,11 +49,13 @@ module ts { A_set_accessor_cannot_have_rest_parameter: { code: 1053, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have rest parameter." }, A_get_accessor_cannot_have_parameters: { code: 1054, category: DiagnosticCategory.Error, key: "A 'get' accessor cannot have parameters." }, Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." }, + An_async_function_or_method_must_have_a_valid_awaitable_return_type: { code: 1057, category: DiagnosticCategory.Error, key: "An async function or method must have a valid awaitable return type." }, + Type_for_await_does_not_have_a_valid_callable_then_member: { code: 1058, category: DiagnosticCategory.Error, key: "Type for 'await' does not have a valid callable 'then' member." }, Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." }, An_export_assignment_cannot_be_used_in_a_namespace: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a namespace." }, Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." }, Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: DiagnosticCategory.Error, key: "Unexpected token. A constructor, method, accessor, or property was expected." }, - A_declare_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an import declaration." }, + A_0_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: DiagnosticCategory.Error, key: "A '{0}' modifier cannot be used with an import declaration." }, Invalid_reference_directive_syntax: { code: 1084, category: DiagnosticCategory.Error, key: "Invalid 'reference' directive syntax." }, Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: { code: 1085, category: DiagnosticCategory.Error, key: "Octal literals are not available when targeting ECMAScript 5 and higher." }, An_accessor_cannot_be_declared_in_an_ambient_context: { code: 1086, category: DiagnosticCategory.Error, key: "An accessor cannot be declared in an ambient context." }, @@ -120,7 +126,7 @@ module ts { Unterminated_template_literal: { code: 1160, category: DiagnosticCategory.Error, key: "Unterminated template literal." }, Unterminated_regular_expression_literal: { code: 1161, category: DiagnosticCategory.Error, key: "Unterminated regular expression literal." }, An_object_member_cannot_be_declared_optional: { code: 1162, category: DiagnosticCategory.Error, key: "An object member cannot be declared optional." }, - yield_expression_must_be_contained_within_a_generator_declaration: { code: 1163, category: DiagnosticCategory.Error, key: "'yield' expression must be contained_within a generator declaration." }, + yield_expression_must_be_contained_within_a_generator_declaration: { code: 1163, category: DiagnosticCategory.Error, key: "'yield' expression must be contained within a generator declaration." }, Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in enums." }, A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol: { code: 1165, category: DiagnosticCategory.Error, key: "A computed property name in an ambient context must directly refer to a built-in symbol." }, A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol: { code: 1166, category: DiagnosticCategory.Error, key: "A computed property name in a class property declaration must directly refer to a built-in symbol." }, @@ -174,6 +180,18 @@ module ts { Type_expected_0_is_a_reserved_word_in_strict_mode: { code: 1215, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode" }, Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, + with_statements_are_not_allowed_in_an_async_function_block: { code: 1300, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in an async function block." }, + _0_modifier_cannot_be_used_with_a_generator: { code: 1301, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a generator." }, + _0_modifier_cannot_be_used_with_a_module_declaration: { code: 1302, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a module declaration." }, + _0_modifier_cannot_be_used_with_an_enum_declaration: { code: 1303, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with an enum declaration." }, + _0_modifier_cannot_be_used_with_an_export_assignment_declaration: { code: 1304, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with an export assignment declaration." }, + _0_modifier_cannot_be_used_on_a_variable_statement: { code: 1305, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used on a variable statement." }, + _0_modifier_cannot_be_used_with_a_type_declaration: { code: 1306, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a type declaration." }, + _0_modifier_cannot_be_used_with_a_parameter_declaration: { code: 1307, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a parameter declaration." }, + await_expression_must_be_contained_within_an_async_function: { code: 1308, category: DiagnosticCategory.Error, key: "'await' expression must be contained within an async function." }, + _0_modifier_cannot_be_used_on_an_object_literal_element: { code: 1309, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used on an object literal element." }, + _0_expression_is_not_allowed_in_an_initializer: { code: 1310, category: DiagnosticCategory.Error, key: "'{0}' expression is not allowed in an initializer." }, + Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: DiagnosticCategory.Error, key: "Async functions are only available when targeting ECMAScript 6 and higher." }, 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." }, @@ -363,6 +381,10 @@ module ts { An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." }, A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." }, A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." }, + Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." }, + Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." }, + Duplicate_identifier_arguments_Compiler_uses_variable_declaration_arguments_to_capture_arguments_reference: { code: 2522, category: DiagnosticCategory.Error, key: "Duplicate identifier '_arguments'. Compiler uses variable declaration '_arguments' to capture 'arguments' reference." }, + Expression_resolves_to_variable_declaration_arguments_that_compiler_uses_to_capture_arguments_reference: { code: 2523, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '_arguments' that compiler uses to capture 'arguments' reference." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -505,6 +527,7 @@ module ts { Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." }, NEWLINE: { code: 6061, category: DiagnosticCategory.Message, key: "NEWLINE" }, Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." }, + Emit_async_functions_when_ECMAScript_target_version_is_lower_than_ES6: { code: 6063, category: DiagnosticCategory.Message, key: "Emit async functions when ECMAScript target version is lower than 'ES6'." }, Variable_0_implicitly_has_an_1_type: { code: 7005, category: DiagnosticCategory.Error, key: "Variable '{0}' implicitly has an '{1}' type." }, Parameter_0_implicitly_has_an_1_type: { code: 7006, category: DiagnosticCategory.Error, key: "Parameter '{0}' implicitly has an '{1}' type." }, Member_0_implicitly_has_an_1_type: { code: 7008, category: DiagnosticCategory.Error, key: "Member '{0}' implicitly has an '{1}' type." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 18c98928dda..431aec3f531 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -123,11 +123,27 @@ "category": "Error", "code": 1039 }, + "'{0}' modifier cannot be used in an ambient context.": { + "category": "Error", + "code": 1040 + }, + "'{0}' modifier cannot be used with a class declaration.": { + "category": "Error", + "code": 1041 + }, + "'{0}' modifier cannot be used here.": { + "category": "Error", + "code": 1042 + }, + "'{0}' modifier cannot appear on a data property.": { + "category": "Error", + "code": 1043 + }, "'{0}' modifier cannot appear on a module element.": { "category": "Error", "code": 1044 }, - "A 'declare' modifier cannot be used with an interface declaration.": { + "A '{0}' modifier cannot be used with an interface declaration.": { "category": "Error", "code": 1045 }, @@ -167,6 +183,14 @@ "category": "Error", "code": 1056 }, + "An async function or method must have a valid awaitable return type.": { + "category": "Error", + "code": 1057 + }, + "Type for 'await' does not have a valid callable 'then' member.": { + "category": "Error", + "code": 1058 + }, "Enum member must have initializer.": { "category": "Error", "code": 1061 @@ -183,7 +207,7 @@ "category": "Error", "code": 1068 }, - "A 'declare' modifier cannot be used with an import declaration.": { + "A '{0}' modifier cannot be used with an import declaration.": { "category": "Error", "code": 1079 }, @@ -467,7 +491,7 @@ "category": "Error", "code": 1162 }, - "'yield' expression must be contained_within a generator declaration.": { + "'yield' expression must be contained within a generator declaration.": { "category": "Error", "code": 1163 }, @@ -684,6 +708,55 @@ "code": 1218 }, + "'with' statements are not allowed in an async function block.": { + "category": "Error", + "code": 1300 + }, + "'{0}' modifier cannot be used with a generator.": { + "category": "Error", + "code": 1301 + }, + "'{0}' modifier cannot be used with a module declaration.": { + "category": "Error", + "code": 1302 + }, + "'{0}' modifier cannot be used with an enum declaration.": { + "category": "Error", + "code": 1303 + }, + "'{0}' modifier cannot be used with an export assignment declaration.": { + "category": "Error", + "code": 1304 + }, + "'{0}' modifier cannot be used on a variable statement.": { + "category": "Error", + "code": 1305 + }, + "'{0}' modifier cannot be used with a type declaration.": { + "category": "Error", + "code": 1306 + }, + "'{0}' modifier cannot be used with a parameter declaration.": { + "category": "Error", + "code": 1307 + }, + "'await' expression must be contained within an async function.": { + "category": "Error", + "code": 1308 + }, + "'{0}' modifier cannot be used on an object literal element.": { + "category": "Error", + "code": 1309 + }, + "'{0}' expression is not allowed in an initializer.": { + "category": "Error", + "code": 1310 + }, + "Async functions are only available when targeting ECMAScript 6 and higher.": { + "category": "Error", + "code": 1311 + }, + "Duplicate identifier '{0}'.": { "category": "Error", "code": 2300 @@ -1441,6 +1514,23 @@ "code": 2501 }, + "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions.": { + "category": "Error", + "code": 2520 + }, + "Expression resolves to variable declaration '{0}' that compiler uses to support async functions.": { + "category": "Error", + "code": 2521 + }, + "Duplicate identifier '_arguments'. Compiler uses variable declaration '_arguments' to capture 'arguments' reference.": { + "category": "Error", + "code": 2522 + }, + "Expression resolves to variable declaration '_arguments' that compiler uses to capture 'arguments' reference.": { + "category": "Error", + "code": 2523 + }, + "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 @@ -2010,7 +2100,10 @@ "category": "Error", "code": 6062 }, - + "Emit async functions when ECMAScript target version is lower than 'ES6'.": { + "category": "Message", + "code": 6063 + }, "Variable '{0}' implicitly has an '{1}' type.": { "category": "Error", diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 055fc1b6f74..db958087178 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -153,6 +153,8 @@ module ts { case SyntaxKind.YieldExpression: return visitNode(cbNode, (node).asteriskToken) || visitNode(cbNode, (node).expression); + case SyntaxKind.AwaitExpression: + return visitNode(cbNode, (node).expression); case SyntaxKind.PostfixUnaryExpression: return visitNode(cbNode, (node).operand); case SyntaxKind.BinaryExpression: @@ -556,9 +558,17 @@ module ts { function setDecoratorContext(val: boolean) { setContextFlag(val, ParserContextFlags.Decorator); } - - function doOutsideOfContext(flags: ParserContextFlags, func: () => T): T { - let currentContextFlags = contextFlags & flags; + + function setAwaitContext(val: boolean) { + setContextFlag(val, ParserContextFlags.Await); + } + + function setAsyncParameterContext(val: boolean) { + setContextFlag(val, ParserContextFlags.AsyncParameter); + } + + function doOutsideOfContext(context: ParserContextFlags, func: () => T): T { + let currentContextFlags = contextFlags & context; if (currentContextFlags) { setContextFlag(false, currentContextFlags); let result = func(); @@ -569,85 +579,86 @@ module ts { // no need to do anything special as we are not in any of the requested contexts return func(); } - - function allowInAnd(func: () => T): T { - if (contextFlags & ParserContextFlags.DisallowIn) { - setDisallowInContext(false); + + function doInsideOfContext(context: ParserContextFlags, func: () => T): T { + let unsetContextFlags = context & ~contextFlags; + if (!unsetContextFlags) { + setContextFlag(true, unsetContextFlags); let result = func(); - setDisallowInContext(true); + setContextFlag(false, unsetContextFlags); return result; } - - // no need to do anything special if 'in' is already allowed. + + // no need to do anything special as we are already in all of the requested contexts return func(); } + function allowInAnd(func: () => T): T { + return doInsideOfContext(ParserContextFlags.DisallowIn, func); + } + function disallowInAnd(func: () => T): T { - if (contextFlags & ParserContextFlags.DisallowIn) { - // no need to do anything special if 'in' is already disallowed. - return func(); - } - - setDisallowInContext(true); - let result = func(); - setDisallowInContext(false); - return result; + return doOutsideOfContext(ParserContextFlags.DisallowIn, func); } - + function doInYieldContext(func: () => T): T { - if (contextFlags & ParserContextFlags.Yield) { - // no need to do anything special if we're already in the [Yield] context. - return func(); - } - - setYieldContext(true); - let result = func(); - setYieldContext(false); - return result; + return doInsideOfContext(ParserContextFlags.Yield, func); } function doOutsideOfYieldContext(func: () => T): T { - if (contextFlags & ParserContextFlags.Yield) { - setYieldContext(false); - let result = func(); - setYieldContext(true); - return result; - } - - // no need to do anything special if we're not in the [Yield] context. - return func(); + return doOutsideOfContext(ParserContextFlags.Yield, func); } function doInDecoratorContext(func: () => T): T { - if (contextFlags & ParserContextFlags.Decorator) { - // no need to do anything special if we're already in the [Decorator] context. - return func(); - } - - setDecoratorContext(true); - let result = func(); - setDecoratorContext(false); - return result; + return doInsideOfContext(ParserContextFlags.Decorator, func); + } + + function doInAwaitContext(func: () => T): T { + return doInsideOfContext(ParserContextFlags.Await, func); + } + + function doOutsideOfAwaitContext(func: () => T): T { + return doOutsideOfContext(ParserContextFlags.Await, func); + } + + function doOutsideOfYieldAndAwaitContext(func: () => T): T { + return doOutsideOfContext(ParserContextFlags.Yield | ParserContextFlags.Await, func); + } + + function inContext(flags: ParserContextFlags) { + return (contextFlags & flags) === flags; } function inYieldContext() { - return (contextFlags & ParserContextFlags.Yield) !== 0; + return inContext(ParserContextFlags.Yield); } function inStrictModeContext() { - return (contextFlags & ParserContextFlags.StrictMode) !== 0; + return inContext(ParserContextFlags.StrictMode); } function inGeneratorParameterContext() { - return (contextFlags & ParserContextFlags.GeneratorParameter) !== 0; + return inContext(ParserContextFlags.GeneratorParameter); } function inDisallowInContext() { - return (contextFlags & ParserContextFlags.DisallowIn) !== 0; + return inContext(ParserContextFlags.DisallowIn); } function inDecoratorContext() { - return (contextFlags & ParserContextFlags.Decorator) !== 0; + return inContext(ParserContextFlags.Decorator); + } + + function inAwaitContext() { + return inContext(ParserContextFlags.Await); + } + + function inAsyncParameterContext() { + return inContext(ParserContextFlags.AsyncParameter); + } + + function inGeneratorParameterOrAsyncParameterContext() { + return inContext(ParserContextFlags.GeneratorParameter | ParserContextFlags.AsyncParameter); } function parseErrorAtCurrentToken(message: DiagnosticMessage, arg0?: any): void { @@ -927,7 +938,8 @@ module ts { // PropertyName[Yield,GeneratorParameter] : // LiteralPropertyName // [+GeneratorParameter] ComputedPropertyName - // [~GeneratorParameter] ComputedPropertyName[?Yield] + // [+AsyncParameter] ComputedPropertyName + // [~GeneratorParameter,~AsyncParameter] ComputedPropertyName[?Yield,?Await] // // ComputedPropertyName[Yield] : // [ AssignmentExpression[In, ?Yield] ] @@ -938,34 +950,40 @@ module ts { // We parse any expression (including a comma expression). But the grammar // says that only an assignment expression is allowed, so the grammar checker // will error if it sees a comma expression. - let yieldContext = inYieldContext(); - if (inGeneratorParameterContext()) { - setYieldContext(false); - } - - node.expression = allowInAnd(parseExpression); - if (inGeneratorParameterContext()) { - setYieldContext(yieldContext); - } + node.expression = inGeneratorParameterOrAsyncParameterContext() + ? doOutsideOfYieldAndAwaitContext(parseExpression) + : parseExpression(); parseExpected(SyntaxKind.CloseBracketToken); return finishNode(node); } - function parseContextualModifier(t: SyntaxKind): boolean { - return token === t && tryParse(nextTokenCanFollowModifier); + function parseContextualModifier(t: SyntaxKind, isArrowFunction?: boolean): boolean { + return token === t && tryParse(isArrowFunction + ? nextTokenCanFollowModifierForArrowFunction + : nextTokenCanFollowModifier); + } + + function nextTokenCanFollowModifierForArrowFunction() { + return nextTokenCanFollowModifier(/*isArrowFunction*/ true); } - function nextTokenCanFollowModifier() { + function nextTokenCanFollowModifier(isArrowFunction?: boolean) { nextToken(); - return canFollowModifier(); + return canFollowModifier(isArrowFunction); } - function parseAnyContextualModifier(): boolean { - return isModifier(token) && tryParse(nextTokenCanFollowContextualModifier); + function parseAnyContextualModifier(isArrowFunction?: boolean): boolean { + return isModifier(token) && tryParse(isArrowFunction + ? nextTokenCanFollowContextualModifierForArrowFunction + : nextTokenCanFollowContextualModifier); + } + + function nextTokenCanFollowContextualModifierForArrowFunction() { + return nextTokenCanFollowContextualModifier(/*isArrowFunction*/ true); } - function nextTokenCanFollowContextualModifier() { + function nextTokenCanFollowContextualModifier(isArrowFunction?: boolean) { if (token === SyntaxKind.ConstKeyword) { // 'const' is only a modifier if followed by 'enum'. return nextToken() === SyntaxKind.EnumKeyword; @@ -981,10 +999,19 @@ module ts { return nextTokenIsClassOrFunction(); } nextToken(); - return canFollowModifier(); + return canFollowModifier(isArrowFunction); } - function canFollowModifier(): boolean { + function canFollowModifier(isArrowFunction?: boolean): boolean { + if (isArrowFunction) { + if (scanner.hasPrecedingLineBreak()) { + return false; + } + + return token === SyntaxKind.OpenParenToken + || token === SyntaxKind.LessThanToken; + } + return token === SyntaxKind.OpenBracketToken || token === SyntaxKind.OpenBraceToken || token === SyntaxKind.AsteriskToken @@ -1827,11 +1854,10 @@ module ts { setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); - // SingleNameBinding[Yield,GeneratorParameter] : See 13.2.3 - // [+GeneratorParameter]BindingIdentifier[Yield]Initializer[In]opt - // [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt + // FormalParameter[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 14.1 + // BindingElement[?Yield,?GeneratorParameter,?Await,?AsyncParameter] - node.name = inGeneratorParameterContext() ? doInYieldContext(parseIdentifierOrPattern) : parseIdentifierOrPattern(); + node.name = parseIdentifierOrPattern(); if (getFullWidth(node.name) === 0 && node.flags === 0 && isModifier(token)) { // in cases like @@ -1847,7 +1873,7 @@ module ts { node.questionToken = parseOptionalToken(SyntaxKind.QuestionToken); node.type = parseParameterType(); - node.initializer = inGeneratorParameterContext() ? doOutsideOfYieldContext(parseParameterInitializer) : parseParameterInitializer(); + node.initializer = parseBindingElementInitializer(/*inParameter*/ true); // Do not check for initializers in an ambient context for parameters. This is not // a grammar error because the grammar allows arbitrary call signatures in @@ -1859,19 +1885,36 @@ module ts { // ambient contexts. return finishNode(node); } + + function parseBindingElementInitializer(inParameter: boolean) { + // BindingElement[Yield,GeneratorParameter,Await,AsyncParameter] : + // [+GeneratorParameter] BindingPattern[?Yield,?Await,GeneratorParameter] Initializer[In]opt + // [+AsyncParameter] BindingPattern[?Yield,?Await,AsyncParameter] Initializer[In]opt + // [~GeneratorParameter,~AsyncParameter] BindingPattern[?Yield,?Await] Initializer[In,?Yield,?Await]opt + // SingleNameBinding[Yield,GeneratorParameter,Await,AsyncParameter] : + // [+GeneratorParameter] BindingIdentifier[Yield] Initializer[In]opt + // [+AsyncParameter] BindingIdentifier[Await] Initializer[In]opt + // [~GeneratorParameter,~AsyncParameter] BindingIdentifier[?Yield,?Await] Initializer[In,?Yield,?Await]opt + + let parseInitializer = inParameter ? parseParameterInitializer : parseNonParameterInitializer; + return inGeneratorParameterOrAsyncParameterContext() + ? doOutsideOfYieldAndAwaitContext(parseInitializer) + : parseInitializer(); + } function parseParameterInitializer() { return parseInitializer(/*inParameter*/ true); } - + function fillSignature( returnToken: SyntaxKind, yieldAndGeneratorParameterContext: boolean, + awaitAndAsyncParameterContext: boolean, requireCompleteParameterList: boolean, signature: SignatureDeclaration): void { let returnTokenRequired = returnToken === SyntaxKind.EqualsGreaterThanToken; signature.typeParameters = parseTypeParameters(); - signature.parameters = parseParameterList(yieldAndGeneratorParameterContext, requireCompleteParameterList); + signature.parameters = parseParameterList(yieldAndGeneratorParameterContext, awaitAndAsyncParameterContext, requireCompleteParameterList); if (returnTokenRequired) { parseExpected(returnToken); @@ -1886,32 +1929,48 @@ module ts { // have 'Yield' And 'GeneratorParameter' not in sync. i.e. any production calling // this FormalParameters production either always sets both to true, or always sets // both to false. As such we only have a single parameter to represent both. - function parseParameterList(yieldAndGeneratorParameterContext: boolean, requireCompleteParameterList: boolean) { - // FormalParameters[Yield,GeneratorParameter] : + function parseParameterList(yieldAndGeneratorParameterContext: boolean, awaitAndAsyncParameterContext: boolean, requireCompleteParameterList: boolean) { + // FormalParameters[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) // ... // - // FormalParameter[Yield,GeneratorParameter] : - // BindingElement[?Yield, ?GeneratorParameter] + // FormalParameter[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) + // BindingElement[?Yield,?GeneratorParameter,?Await,?AsyncParameter] // - // BindingElement[Yield, GeneratorParameter ] : See 13.2.3 - // SingleNameBinding[?Yield, ?GeneratorParameter] - // [+GeneratorParameter]BindingPattern[?Yield, GeneratorParameter]Initializer[In]opt - // [~GeneratorParameter]BindingPattern[?Yield]Initializer[In, ?Yield]opt + // BindingElement[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 13.2.3 + // SingleNameBinding[?Yield,?GeneratorParameter,?Await,?AsyncParameter] + // [+GeneratorParameter]BindingPattern[?Yield,?Await,?AsyncParameter,GeneratorParameter] Initializer[In]opt + // [+AsyncParameter]BindingPattern[?Yield,?Await,?GeneratorParameter,AsyncParameter] Initializer[In]opt + // [~GeneratorParameter,~AsyncParameter]BindingPattern[?Yield,?Await]Initializer[In,?Yield,?Await]opt // - // SingleNameBinding[Yield, GeneratorParameter] : See 13.2.3 + // SingleNameBinding[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 13.2.3 // [+GeneratorParameter]BindingIdentifier[Yield]Initializer[In]opt - // [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt + // [+AsyncParameter]BindingIdentifier[Await]Initializer[In]opt + // [~GeneratorParameter,~AsyncParameter]BindingIdentifier[?Yield,?Await]Initializer[In,?Yield,?Await]opt if (parseExpected(SyntaxKind.OpenParenToken)) { let savedYieldContext = inYieldContext(); let savedGeneratorParameterContext = inGeneratorParameterContext(); + let savedAwaitContext = inAwaitContext(); + let savedAsyncParameterContext = inAsyncParameterContext(); - setYieldContext(yieldAndGeneratorParameterContext); + if (yieldAndGeneratorParameterContext) { + setYieldContext(true); + } + setGeneratorParameterContext(yieldAndGeneratorParameterContext); + + if (awaitAndAsyncParameterContext) { + setAwaitContext(true); + } + + setAsyncParameterContext(awaitAndAsyncParameterContext); let result = parseDelimitedList(ParsingContext.Parameters, parseParameter); setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); + + setAwaitContext(savedAwaitContext); + setAsyncParameterContext(savedAsyncParameterContext); if (!parseExpected(SyntaxKind.CloseParenToken) && requireCompleteParameterList) { // Caller insisted that we had to end with a ) We didn't. So just return @@ -1944,7 +2003,7 @@ module ts { if (kind === SyntaxKind.ConstructSignature) { parseExpected(SyntaxKind.NewKeyword); } - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node); + fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList:*/ false, node); parseTypeMemberSemicolon(); return finishNode(node); } @@ -2034,7 +2093,7 @@ module ts { // Method signatues don't exist in expression contexts. So they have neither // [Yield] nor [GeneratorParameter] - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, method); + fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList:*/ false, method); parseTypeMemberSemicolon(); return finishNode(method); } @@ -2173,7 +2232,7 @@ module ts { if (kind === SyntaxKind.ConstructorType) { parseExpected(SyntaxKind.NewKeyword); } - fillSignature(SyntaxKind.EqualsGreaterThanToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node); + fillSignature(SyntaxKind.EqualsGreaterThanToken, /*yieldAndGeneratorParameterContext:*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList:*/ false, node); return finishNode(node); } @@ -2302,19 +2361,8 @@ module ts { function parseType(): TypeNode { // The rules about 'yield' only apply to actual code/expression contexts. They don't - // apply to 'type' contexts. So we disable these parameters here before moving on. - let savedYieldContext = inYieldContext(); - let savedGeneratorParameterContext = inGeneratorParameterContext(); - - setYieldContext(false); - setGeneratorParameterContext(false); - - let result = parseTypeWorker(); - - setYieldContext(savedYieldContext); - setGeneratorParameterContext(savedGeneratorParameterContext); - - return result; + // apply to 'type' contexts. So we disable these parameters here before moving on. + return doOutsideOfContext(ParserContextFlags.ContextParameterFlags, parseTypeWorker); } function parseTypeWorker(): TypeNode { @@ -2374,6 +2422,7 @@ module ts { case SyntaxKind.PlusPlusToken: case SyntaxKind.MinusMinusToken: case SyntaxKind.LessThanToken: + case SyntaxKind.AwaitKeyword: case SyntaxKind.YieldKeyword: // Yield always starts an expression. Either it is an identifier (in which case // it is definitely an expression). Or it's a keyword (either because we're in @@ -2586,7 +2635,7 @@ module ts { node.parameters.end = parameter.end; node.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, false, Diagnostics._0_expected, "=>"); - node.body = parseArrowFunctionExpressionBody(); + node.body = parseArrowFunctionExpressionBody(/*isAsync*/ false); return finishNode(node); } @@ -2617,7 +2666,7 @@ module ts { var lastToken = token; arrowFunction.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, /*reportAtCurrentPosition:*/false, Diagnostics._0_expected, "=>"); arrowFunction.body = (lastToken === SyntaxKind.EqualsGreaterThanToken || lastToken === SyntaxKind.OpenBraceToken) - ? parseArrowFunctionExpressionBody() + ? parseArrowFunctionExpressionBody(/*isAsync*/ isAsyncFunctionLike(arrowFunction)) : parseIdentifier(); return finishNode(arrowFunction); @@ -2628,7 +2677,7 @@ module ts { // Unknown -> There *might* be a parenthesized arrow function here. // Speculatively look ahead to be sure, and rollback if not. function isParenthesizedArrowFunctionExpression(): Tristate { - if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) { + if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken || token === SyntaxKind.AsyncKeyword) { return lookAhead(isParenthesizedArrowFunctionExpressionWorker); } @@ -2643,6 +2692,10 @@ module ts { } function isParenthesizedArrowFunctionExpressionWorker() { + if (token === SyntaxKind.AsyncKeyword && !parseContextualModifier(SyntaxKind.AsyncKeyword, /*isArrowFunction*/ true)) { + return Tristate.False; + } + let first = token; let second = nextToken(); @@ -2718,6 +2771,9 @@ module ts { function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): ArrowFunction { let node = createNode(SyntaxKind.ArrowFunction); + setModifiers(node, parseModifiers(/*isArrowFunction*/ true)); + let isAsync = isAsyncFunctionLike(node); + // Arrow functions are never generators. // // If we're speculatively parsing a signature for a parenthesized arrow function, then @@ -2725,7 +2781,7 @@ module ts { // a => (b => c) // And think that "(b =>" was actually a parenthesized arrow function with a missing // close paren. - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ !allowAmbiguity, node); + fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList:*/ !allowAmbiguity, node); // If we couldn't get parameters, we definitely could not parse out an arrow function. if (!node.parameters) { @@ -2748,9 +2804,9 @@ module ts { return node; } - function parseArrowFunctionExpressionBody(): Block | Expression { + function parseArrowFunctionExpressionBody(isAsync: boolean): Block | Expression { if (token === SyntaxKind.OpenBraceToken) { - return parseFunctionBlock(/*allowYield:*/ false, /* ignoreMissingOpenBrace */ false); + return parseFunctionBlock(/*allowYield*/ false, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ false); } if (isStartOfStatement(/*inErrorRecovery:*/ true) && @@ -2772,10 +2828,12 @@ module ts { // up preemptively closing the containing construct. // // Note: even when 'ignoreMissingOpenBrace' is passed as true, parseBody will still error. - return parseFunctionBlock(/*allowYield:*/ false, /* ignoreMissingOpenBrace */ true); + return parseFunctionBlock(/*allowYield*/ false, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ true); } - - return parseAssignmentExpressionOrHigher(); + + return isAsync + ? doInAwaitContext(parseAssignmentExpressionOrHigher) + : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher); } function parseConditionalExpressionRest(leftOperand: Expression): Expression { @@ -2915,8 +2973,32 @@ module ts { node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } + + function isAwaitExpression(): boolean { + if (token === SyntaxKind.AwaitKeyword) { + if (inAwaitContext()) { + return true; + } + + // here we are using similar heuristics as 'isYieldExpression' + return lookAhead(nextTokenIsIdentifierOnSameLine); + } + + return false; + } + + function parseAwaitExpression() { + var node = createNode(SyntaxKind.AwaitExpression); + nextToken(); + node.expression = parseUnaryExpressionOrHigher(); + return finishNode(node); + } function parseUnaryExpressionOrHigher(): UnaryExpression { + if (isAwaitExpression()) { + return parseAwaitExpression(); + } + switch (token) { case SyntaxKind.PlusToken: case SyntaxKind.MinusToken: @@ -3230,6 +3312,11 @@ module ts { return parseArrayLiteralExpression(); case SyntaxKind.OpenBraceToken: return parseObjectLiteralExpression(); + case SyntaxKind.AsyncKeyword: + if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) { + break; + } + return parseFunctionExpression(); case SyntaxKind.ClassKeyword: return parseClassExpression(); case SyntaxKind.FunctionKeyword: @@ -3353,15 +3440,32 @@ module ts { if (saveDecoratorContext) { setDecoratorContext(false); } + let node = createNode(SyntaxKind.FunctionExpression); + setModifiers(node, parseModifiers()); parseExpected(SyntaxKind.FunctionKeyword); - node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); - node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ !!node.asteriskToken, /*requireCompleteParameterList:*/ false, node); - node.body = parseFunctionBlock(/*allowYield:*/ !!node.asteriskToken, /* ignoreMissingOpenBrace */ false); + node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); + + let savedYieldContext = inYieldContext(); + let isGenerator = node.asteriskToken != undefined; + setYieldContext(isGenerator); + + let savedAwaitContext = inAwaitContext(); + let isAsync = isAsyncFunctionLike(node); + setAwaitContext(isAsync); + + node.name = parseOptionalIdentifier(); + + setYieldContext(savedYieldContext); + setAwaitContext(savedAwaitContext); + + fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList*/ false, node); + node.body = parseFunctionBlock(/*allowYield*/ isGenerator, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ false); + if (saveDecoratorContext) { setDecoratorContext(true); } + return finishNode(node); } @@ -3394,9 +3498,12 @@ module ts { return finishNode(node); } - function parseFunctionBlock(allowYield: boolean, ignoreMissingOpenBrace: boolean, diagnosticMessage?: DiagnosticMessage): Block { + function parseFunctionBlock(allowYield: boolean, allowAwait: boolean, ignoreMissingOpenBrace: boolean, diagnosticMessage?: DiagnosticMessage): Block { let savedYieldContext = inYieldContext(); setYieldContext(allowYield); + + let savedAwaitContext = inAwaitContext(); + setAwaitContext(allowAwait); // We may be in a [Decorator] context when parsing a function expression or // arrow function. The body of the function is not in [Decorator] context. @@ -3412,6 +3519,7 @@ module ts { } setYieldContext(savedYieldContext); + setAwaitContext(savedAwaitContext); return block; } @@ -3702,6 +3810,15 @@ module ts { // In ES 6 'enum' is a future reserved keyword, so it should not be used as identifier let isConstEnum = lookAhead(nextTokenIsEnumKeyword); return !isConstEnum; + + case SyntaxKind.AsyncKeyword: + // When followed by the function keyword on the same line, this is a statement + if (lookAhead(nextTokenIsFunctionKeywordOnSameLine)) { + return true; + } + + return isStartOfExpression(); + case SyntaxKind.InterfaceKeyword: case SyntaxKind.ModuleKeyword: case SyntaxKind.NamespaceKeyword: @@ -3835,13 +3952,13 @@ module ts { return undefined; } - function parseFunctionBlockOrSemicolon(isGenerator: boolean, diagnosticMessage?: DiagnosticMessage): Block { + function parseFunctionBlockOrSemicolon(isGenerator: boolean, isAsync: boolean, diagnosticMessage?: DiagnosticMessage): Block { if (token !== SyntaxKind.OpenBraceToken && canParseSemicolon()) { parseSemicolon(); return; } - return parseFunctionBlock(isGenerator, /*ignoreMissingOpenBrace:*/ false, diagnosticMessage); + return parseFunctionBlock(isGenerator, isAsync, /*ignoreMissingOpenBrace:*/ false, diagnosticMessage); } // DECLARATIONS @@ -3853,7 +3970,7 @@ module ts { let node = createNode(SyntaxKind.BindingElement); node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); node.name = parseIdentifierOrPattern(); - node.initializer = parseInitializer(/*inParameter*/ false); + node.initializer = parseBindingElementInitializer(/*inParameter*/ false); return finishNode(node); } @@ -3870,7 +3987,7 @@ module ts { node.propertyName = propertyName; node.name = parseIdentifierOrPattern(); } - node.initializer = parseInitializer(/*inParameter*/ false); + node.initializer = parseBindingElementInitializer(/*inParameter*/ false); return finishNode(node); } @@ -3976,8 +4093,10 @@ module ts { parseExpected(SyntaxKind.FunctionKeyword); node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier(); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ !!node.asteriskToken, /*requireCompleteParameterList:*/ false, node); - node.body = parseFunctionBlockOrSemicolon(!!node.asteriskToken, Diagnostics.or_expected); + let isGenerator = node.asteriskToken != undefined; + let isAsync = isAsyncFunctionLike(node); + fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList:*/ false, node); + node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, Diagnostics.or_expected); return finishNode(node); } @@ -3986,8 +4105,8 @@ module ts { node.decorators = decorators; setModifiers(node, modifiers); parseExpected(SyntaxKind.ConstructorKeyword); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node); - node.body = parseFunctionBlockOrSemicolon(/*isGenerator:*/ false, Diagnostics.or_expected); + fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList*/ false, node); + node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, /*isAsync*/ false, Diagnostics.or_expected); return finishNode(node); } @@ -3998,8 +4117,10 @@ module ts { method.asteriskToken = asteriskToken; method.name = name; method.questionToken = questionToken; - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ !!asteriskToken, /*requireCompleteParameterList:*/ false, method); - method.body = parseFunctionBlockOrSemicolon(!!asteriskToken, diagnosticMessage); + let isGenerator = asteriskToken != undefined; + let isAsync = isAsyncFunctionLike(method); + fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList:*/ false, method); + method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage); return finishNode(method); } @@ -4039,8 +4160,8 @@ module ts { node.decorators = decorators; setModifiers(node, modifiers); node.name = parsePropertyName(); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node); - node.body = parseFunctionBlockOrSemicolon(/*isGenerator:*/ false); + fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList*/ false, node); + node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, /*isAsync*/ false); return finishNode(node); } @@ -4147,14 +4268,14 @@ module ts { return decorators; } - function parseModifiers(): ModifiersArray { + function parseModifiers(isArrowFunction?: boolean): ModifiersArray { let flags = 0; let modifiers: ModifiersArray; while (true) { let modifierStart = scanner.getStartPos(); let modifierKind = token; - if (!parseAnyContextualModifier()) { + if (!parseAnyContextualModifier(isArrowFunction)) { break; } @@ -4228,7 +4349,7 @@ module ts { function parseClassDeclaration(fullStart: number, decorators: NodeArray, modifiers: ModifiersArray): ClassDeclaration { return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, SyntaxKind.ClassDeclaration); } - + function parseClassDeclarationOrExpression(fullStart: number, decorators: NodeArray, modifiers: ModifiersArray, kind: SyntaxKind): ClassLikeDeclaration { // In ES6 specification, All parts of a ClassDeclaration or a ClassExpression are strict mode code let savedStrictModeContext = inStrictModeContext(); @@ -4243,13 +4364,15 @@ module ts { node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause:*/ true); if (parseExpected(SyntaxKind.OpenBraceToken)) { - // ClassTail[Yield,GeneratorParameter] : See 14.5 - // [~GeneratorParameter]ClassHeritage[?Yield]opt { ClassBody[?Yield]opt } + // ClassTail[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 14.5 + // [~GeneratorParameter,~AsyncParameter]ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } // [+GeneratorParameter] ClassHeritageopt { ClassBodyopt } - - node.members = inGeneratorParameterContext() - ? doOutsideOfYieldContext(parseClassMembers) + // [+AsyncParameter] ClassHeritageopt { ClassBodyopt } + + node.members = inGeneratorParameterOrAsyncParameterContext() + ? doOutsideOfYieldAndAwaitContext(parseClassMembers) : parseClassMembers(); + parseExpected(SyntaxKind.CloseBraceToken); } else { @@ -4262,13 +4385,14 @@ module ts { } function parseHeritageClauses(isClassHeritageClause: boolean): NodeArray { - // ClassTail[Yield,GeneratorParameter] : See 14.5 - // [~GeneratorParameter]ClassHeritage[?Yield]opt { ClassBody[?Yield]opt } + // ClassTail[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 14.5 + // [~GeneratorParameter,~AsyncParameter]ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } // [+GeneratorParameter] ClassHeritageopt { ClassBodyopt } + // [+AsyncParameter] ClassHeritageopt { ClassBodyopt } if (isHeritageClause()) { - return isClassHeritageClause && inGeneratorParameterContext() - ? doOutsideOfYieldContext(parseHeritageClausesWorker) + return isClassHeritageClause && inGeneratorParameterOrAsyncParameterContext() + ? doOutsideOfYieldAndAwaitContext(parseHeritageClausesWorker) : parseHeritageClausesWorker(); } @@ -4652,6 +4776,11 @@ module ts { case SyntaxKind.StaticKeyword: // Check for modifier on source element return lookAhead(nextTokenIsDeclarationStart); + + case SyntaxKind.AsyncKeyword: + // Check for modifier on source element + return lookAhead(nextTokenIsDeclarationStartOnSameLine); + case SyntaxKind.AtToken: // a lookahead here is too costly, and decorators are only valid on a declaration. // We will assume we are parsing a declaration here and report an error later @@ -4690,6 +4819,16 @@ module ts { return isDeclarationStart(/*followsModifier*/ true); } + function nextTokenIsDeclarationStartOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && isDeclarationStart(); + } + + function nextTokenIsFunctionKeywordOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && token === SyntaxKind.FunctionKeyword; + } + function nextTokenIsAsKeyword() { return nextToken() === SyntaxKind.AsKeyword; } diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 1fc8bff92e6..2dc85174cd9 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -101,6 +101,8 @@ module ts { "while": SyntaxKind.WhileKeyword, "with": SyntaxKind.WithKeyword, "yield": SyntaxKind.YieldKeyword, + "async": SyntaxKind.AsyncKeyword, + "await": SyntaxKind.AwaitKeyword, "of": SyntaxKind.OfKeyword, "{": SyntaxKind.OpenBraceToken, "}": SyntaxKind.CloseBraceToken, diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 86e680ca8b0..b23b46bc9bd 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -133,6 +133,8 @@ module ts { // Contextual keywords AsKeyword, AnyKeyword, + AsyncKeyword, + AwaitKeyword, BooleanKeyword, ConstructorKeyword, DeclareKeyword, @@ -197,6 +199,7 @@ module ts { DeleteExpression, TypeOfExpression, VoidExpression, + AwaitExpression, PrefixUnaryExpression, PostfixUnaryExpression, BinaryExpression, @@ -316,8 +319,9 @@ module ts { OctalLiteral = 0x00004000, // Octal numeric literal Namespace = 0x00008000, // Namespace declaration ExportContext = 0x00010000, // Export context (initialized by binding) + Async = 0x00020000, // Property/Method/Function - Modifier = Export | Ambient | Public | Private | Protected | Static | Default, + Modifier = Export | Ambient | Public | Private | Protected | Static | Default | Async, AccessibilityModifier = Public | Private | Protected, BlockScoped = Let | Const } @@ -345,17 +349,29 @@ module ts { // error. ThisNodeHasError = 1 << 5, - // Context flags set directly by the parser. - ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | Decorator | ThisNodeHasError, + // If this node was parsed in the parameters of an async function. + AsyncParameter = 1 << 6, + // If this node was parsed in the 'await' context created when parsing an async function. + Await = 1 << 7, + + // Context flags set directly by the parser. + ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | Decorator | ThisNodeHasError | AsyncParameter | Await, + + // Context flags passed as part of the modified ES6 grammar. + ContextParameterFlags = Yield | GeneratorParameter | AsyncParameter | Await, + // Context flags computed by aggregating child flags upwards. // 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 << 6, + ThisNodeOrAnySubNodesHasError = 1 << 8, + + // Used to know if we've computed whether any children of this node are or contain an 'await' or 'yield' expression. + ThisNodeOrAnySubNodesHasAwaitOrYield = 1 << 9, // Used to know if we've computed data from children and cached it in this node. - HasAggregatedChildData = 1 << 7 + HasAggregatedChildData = 1 << 10 } /* @internal */ @@ -658,6 +674,10 @@ module ts { expression: UnaryExpression; } + export interface AwaitExpression extends UnaryExpression { + expression: UnaryExpression; + } + export interface YieldExpression extends Expression { asteriskToken?: Node; expression: Expression; @@ -1403,22 +1423,28 @@ module ts { TypeChecked = 0x00000001, // Node has been type checked LexicalThis = 0x00000002, // Lexical 'this' reference CaptureThis = 0x00000004, // Lexical 'this' used in body - EmitExtends = 0x00000008, // Emit __extends - SuperInstance = 0x00000010, // Instance 'super' reference - SuperStatic = 0x00000020, // Static 'super' reference - ContextChecked = 0x00000040, // Contextual types have been assigned + LexicalArguments = 0x00000008, // Lexical 'arguments' reference + CaptureArguments = 0x00000010, // Lexical 'arguments' used in body + EmitExtends = 0x00000020, // Emit __extends + EmitDecorate = 0x00000040, // Emit __decorate + EmitParam = 0x00000080, // Emit __param helper for decorators + EmitAwaiter = 0x00000100, // Emit __awaiter + EmitGenerator = 0x00000200, // Emit __generator + SuperInstance = 0x00000400, // Instance 'super' reference + SuperStatic = 0x00000800, // Static 'super' reference + ContextChecked = 0x00001000, // Contextual types have been assigned + PromiseCollision = 0x00002000, // Declaration collides with the global 'Promise' // Values for enum members have been computed, and any errors have been reported for them. - EnumValuesComputed = 0x00000080, - BlockScopedBindingInLoop = 0x00000100, - EmitDecorate = 0x00000200, // Emit __decorate - EmitParam = 0x00000400, // Emit __param helper for decorators - LexicalModuleMergesWithClass = 0x00000800, // Instantiated lexical module declaration is merged with a previous class declaration. + EnumValuesComputed = 0x00004000, + BlockScopedBindingInLoop = 0x00008000, + LexicalModuleMergesWithClass= 0x00010000, // Instantiated lexical module declaration is merged with a previous class declaration. } /* @internal */ export interface NodeLinks { resolvedType?: Type; // Cached type of type node + resolvedAwaitedType?: Type; // Cached awaited type of type node resolvedSignature?: Signature; // Cached signature of signature node or call expression resolvedSymbol?: Symbol; // Cached name resolution result flags?: NodeCheckFlags; // Set of flags specific to Node diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 3e825c6802c..e5856077edc 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -511,6 +511,19 @@ module ts { } } + export function getContainingParameter(node: Node): ParameterDeclaration { + while (true) { + node = node.parent; + if (!node || isFunctionLike(node)) { + return undefined; + } + + if (node.kind === SyntaxKind.Parameter) { + return node; + } + } + } + export function getThisContainer(node: Node, includeArrowFunctions: boolean): Node { while (true) { node = node.parent; @@ -1087,6 +1100,10 @@ module ts { return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken; } + export function isAsyncFunctionLike(node: Node): boolean { + return isFunctionLike(node) && !isAccessor(node) && (node.flags & NodeFlags.Async) === NodeFlags.Async; + } + /** * A declaration has a dynamic name if both of the following are true: * 1. The declaration has a computed property name @@ -1145,6 +1162,7 @@ module ts { case SyntaxKind.DeclareKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.DefaultKeyword: + case SyntaxKind.AsyncKeyword: return true; } return false; @@ -1630,6 +1648,7 @@ module ts { case SyntaxKind.DeclareKeyword: return NodeFlags.Ambient; case SyntaxKind.ConstKeyword: return NodeFlags.Const; case SyntaxKind.DefaultKeyword: return NodeFlags.Default; + case SyntaxKind.AsyncKeyword: return NodeFlags.Async; } return 0; } diff --git a/src/lib/core.d.ts b/src/lib/core.d.ts index c03ab344ab2..0405774d99d 100644 --- a/src/lib/core.d.ts +++ b/src/lib/core.d.ts @@ -1169,3 +1169,15 @@ declare type ClassDecorator = (target: TFunction) => declare type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void; declare type MethodDecorator = (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor | void; declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void; + +declare type PromiseConstructorLike = new (executor: (resolve: (value?: T | PromiseLike) => void, reject: (reason?: any) => void) => void) => PromiseLike; + +interface PromiseLike { + /** + * Attaches callbacks for the resolution and/or rejection of the Promise. + * @param onfulfilled The callback to execute when the Promise is resolved. + * @param onrejected The callback to execute when the Promise is rejected. + * @returns A Promise for the completion of which ever callback is executed. + */ + then(onfulfilled?: (value: T) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): PromiseLike; +} \ No newline at end of file diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts index fb0c64f8495..ff3c517fe45 100644 --- a/src/lib/es6.d.ts +++ b/src/lib/es6.d.ts @@ -3572,16 +3572,6 @@ declare module Reflect { function setPrototypeOf(target: any, proto: any): boolean; } -interface PromiseLike { - /** - * Attaches callbacks for the resolution and/or rejection of the Promise. - * @param onfulfilled The callback to execute when the Promise is resolved. - * @param onrejected The callback to execute when the Promise is rejected. - * @returns A Promise for the completion of which ever callback is executed. - */ - then(onfulfilled?: (value: T) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): PromiseLike; -} - /** * Represents the completion of an asynchronous operation */ From e82e8419c275325fab6e6e40abce980a5b4fcfca Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 6 May 2015 17:33:58 -0700 Subject: [PATCH 008/309] Added emit for async functions in ES6 --- src/compiler/checker.ts | 139 +++----- .../diagnosticInformationMap.generated.ts | 3 +- src/compiler/diagnosticMessages.json | 6 +- src/compiler/emitter.ts | 144 +++++++- src/compiler/parser.ts | 23 +- src/compiler/types.ts | 28 +- src/compiler/utilities.ts | 2 +- .../FunctionDeclaration10_es6.errors.txt | 20 +- .../FunctionDeclaration6_es6.errors.txt | 4 +- .../FunctionDeclaration7_es6.errors.txt | 4 +- .../YieldExpression12_es6.errors.txt | 4 +- .../YieldExpression14_es6.errors.txt | 4 +- .../YieldExpression15_es6.errors.txt | 4 +- .../YieldExpression16_es6.errors.txt | 4 +- .../YieldExpression17_es6.errors.txt | 4 +- .../YieldExpression18_es6.errors.txt | 4 +- .../reference/YieldExpression2_es6.errors.txt | 4 +- .../reference/arrayLiterals2ES6.symbols | 6 +- .../asyncArrowFunction10_es6.errors.txt | 24 ++ .../reference/asyncArrowFunction10_es6.js | 13 + .../reference/asyncArrowFunction1_es6.js | 8 + .../reference/asyncArrowFunction1_es6.symbols | 7 + .../reference/asyncArrowFunction1_es6.types | 8 + .../reference/asyncArrowFunction2_es6.js | 7 + .../reference/asyncArrowFunction2_es6.symbols | 5 + .../reference/asyncArrowFunction2_es6.types | 6 + .../asyncArrowFunction3_es6.errors.txt | 8 + .../reference/asyncArrowFunction3_es6.js | 7 + .../reference/asyncArrowFunction4_es6.js | 7 + .../reference/asyncArrowFunction4_es6.symbols | 4 + .../reference/asyncArrowFunction4_es6.types | 5 + .../asyncArrowFunction5_es6.errors.txt | 24 ++ .../reference/asyncArrowFunction5_es6.js | 9 + .../asyncArrowFunction6_es6.errors.txt | 9 + .../reference/asyncArrowFunction6_es6.js | 8 + .../asyncArrowFunction7_es6.errors.txt | 12 + .../reference/asyncArrowFunction7_es6.js | 14 + .../asyncArrowFunction8_es6.errors.txt | 10 + .../reference/asyncArrowFunction8_es6.js | 10 + .../asyncArrowFunction9_es6.errors.txt | 23 ++ .../reference/asyncArrowFunction9_es6.js | 8 + ...owFunctionCapturesArguments_es6.errors.txt | 13 + ...asyncArrowFunctionCapturesArguments_es6.js | 16 + .../asyncArrowFunctionCapturesThis_es6.js | 14 + ...asyncArrowFunctionCapturesThis_es6.symbols | 13 + .../asyncArrowFunctionCapturesThis_es6.types | 14 + .../reference/asyncClass_es6.errors.txt | 8 + tests/baselines/reference/asyncClass_es6.js | 7 + .../reference/asyncConstructor_es6.errors.txt | 10 + .../reference/asyncConstructor_es6.js | 11 + .../reference/asyncDeclare_es6.errors.txt | 7 + tests/baselines/reference/asyncDeclare_es6.js | 4 + .../reference/asyncEnum_es6.errors.txt | 9 + tests/baselines/reference/asyncEnum_es6.js | 10 + .../asyncFunctionDeclaration10_es6.errors.txt | 26 ++ .../asyncFunctionDeclaration10_es6.js | 7 + .../asyncFunctionDeclaration11_es6.js | 9 + .../asyncFunctionDeclaration11_es6.symbols | 5 + .../asyncFunctionDeclaration11_es6.types | 5 + .../asyncFunctionDeclaration12_es6.errors.txt | 16 + .../asyncFunctionDeclaration12_es6.js | 5 + .../asyncFunctionDeclaration13_es6.errors.txt | 11 + .../asyncFunctionDeclaration13_es6.js | 14 + .../asyncFunctionDeclaration14_es6.js | 11 + .../asyncFunctionDeclaration14_es6.symbols | 7 + .../asyncFunctionDeclaration14_es6.types | 7 + .../asyncFunctionDeclaration1_es6.js | 9 + .../asyncFunctionDeclaration1_es6.symbols | 5 + .../asyncFunctionDeclaration1_es6.types | 5 + .../asyncFunctionDeclaration2_es6.js | 7 + .../asyncFunctionDeclaration2_es6.symbols | 5 + .../asyncFunctionDeclaration2_es6.types | 5 + .../asyncFunctionDeclaration3_es6.errors.txt | 8 + .../asyncFunctionDeclaration3_es6.js | 7 + .../asyncFunctionDeclaration4_es6.js | 7 + .../asyncFunctionDeclaration4_es6.symbols | 4 + .../asyncFunctionDeclaration4_es6.types | 4 + .../asyncFunctionDeclaration5_es6.errors.txt | 20 ++ .../asyncFunctionDeclaration5_es6.js | 7 + .../asyncFunctionDeclaration6_es6.errors.txt | 8 + .../asyncFunctionDeclaration6_es6.js | 9 + .../asyncFunctionDeclaration7_es6.errors.txt | 11 + .../asyncFunctionDeclaration7_es6.js | 17 + .../asyncFunctionDeclaration8_es6.errors.txt | 10 + .../asyncFunctionDeclaration8_es6.js | 5 + .../asyncFunctionDeclaration9_es6.errors.txt | 9 + .../asyncFunctionDeclaration9_es6.js | 11 + .../reference/asyncGetter_es6.errors.txt | 13 + tests/baselines/reference/asyncGetter_es6.js | 11 + .../reference/asyncInterface_es6.errors.txt | 8 + .../baselines/reference/asyncInterface_es6.js | 5 + .../reference/asyncModule_es6.errors.txt | 8 + tests/baselines/reference/asyncModule_es6.js | 5 + .../reference/asyncSetter_es6.errors.txt | 10 + tests/baselines/reference/asyncSetter_es6.js | 11 + .../reference/awaitBinaryExpression1_es6.js | 17 + .../awaitBinaryExpression1_es6.symbols | 19 + .../awaitBinaryExpression1_es6.types | 24 ++ .../reference/awaitBinaryExpression2_es6.js | 17 + .../awaitBinaryExpression2_es6.symbols | 19 + .../awaitBinaryExpression2_es6.types | 24 ++ .../reference/awaitBinaryExpression3_es6.js | 17 + .../awaitBinaryExpression3_es6.symbols | 19 + .../awaitBinaryExpression3_es6.types | 24 ++ .../reference/awaitBinaryExpression4_es6.js | 17 + .../awaitBinaryExpression4_es6.symbols | 19 + .../awaitBinaryExpression4_es6.types | 23 ++ .../reference/awaitBinaryExpression5_es6.js | 19 + .../awaitBinaryExpression5_es6.symbols | 24 ++ .../awaitBinaryExpression5_es6.types | 29 ++ .../reference/awaitCallExpression1_es6.js | 21 ++ .../awaitCallExpression1_es6.symbols | 50 +++ .../reference/awaitCallExpression1_es6.types | 54 +++ .../reference/awaitCallExpression2_es6.js | 21 ++ .../awaitCallExpression2_es6.symbols | 49 +++ .../reference/awaitCallExpression2_es6.types | 54 +++ .../reference/awaitCallExpression3_es6.js | 21 ++ .../awaitCallExpression3_es6.symbols | 49 +++ .../reference/awaitCallExpression3_es6.types | 54 +++ .../reference/awaitCallExpression4_es6.js | 21 ++ .../awaitCallExpression4_es6.symbols | 49 +++ .../reference/awaitCallExpression4_es6.types | 55 +++ .../reference/awaitCallExpression5_es6.js | 21 ++ .../awaitCallExpression5_es6.symbols | 52 +++ .../reference/awaitCallExpression5_es6.types | 56 +++ .../reference/awaitCallExpression6_es6.js | 21 ++ .../awaitCallExpression6_es6.symbols | 51 +++ .../reference/awaitCallExpression6_es6.types | 56 +++ .../reference/awaitCallExpression7_es6.js | 21 ++ .../awaitCallExpression7_es6.symbols | 51 +++ .../reference/awaitCallExpression7_es6.types | 56 +++ .../reference/awaitCallExpression8_es6.js | 21 ++ .../awaitCallExpression8_es6.symbols | 51 +++ .../reference/awaitCallExpression8_es6.types | 57 +++ .../reference/callWithSpreadES6.symbols | 2 +- ...tructuringParameterDeclaration3ES5.symbols | 16 +- ...tructuringParameterDeclaration3ES6.symbols | 16 +- ...owFunctionWhenUsingArguments14_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments15_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments16_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments17_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments18_ES6.symbols | 2 +- tests/baselines/reference/for-of13.symbols | 4 +- tests/baselines/reference/for-of18.symbols | 6 +- tests/baselines/reference/for-of19.symbols | 6 +- tests/baselines/reference/for-of20.symbols | 6 +- tests/baselines/reference/for-of21.symbols | 6 +- tests/baselines/reference/for-of22.symbols | 6 +- tests/baselines/reference/for-of23.symbols | 6 +- tests/baselines/reference/for-of25.symbols | 6 +- tests/baselines/reference/for-of26.symbols | 6 +- tests/baselines/reference/for-of27.symbols | 6 +- tests/baselines/reference/for-of28.symbols | 6 +- tests/baselines/reference/for-of37.symbols | 2 +- tests/baselines/reference/for-of38.symbols | 2 +- tests/baselines/reference/for-of40.symbols | 2 +- tests/baselines/reference/for-of44.symbols | 2 +- tests/baselines/reference/for-of45.symbols | 2 +- tests/baselines/reference/for-of50.symbols | 2 +- tests/baselines/reference/for-of57.symbols | 2 +- .../reference/iterableArrayPattern1.symbols | 8 +- .../reference/iterableArrayPattern11.symbols | 6 +- .../reference/iterableArrayPattern12.symbols | 6 +- .../reference/iterableArrayPattern13.symbols | 6 +- .../reference/iterableArrayPattern2.symbols | 8 +- .../reference/iterableArrayPattern3.symbols | 6 +- .../reference/iterableArrayPattern30.symbols | 2 +- .../reference/iterableArrayPattern4.symbols | 6 +- .../reference/iterableArrayPattern9.symbols | 6 +- .../iterableContextualTyping1.symbols | 2 +- .../reference/iteratorSpreadInArray.symbols | 8 +- .../reference/iteratorSpreadInArray11.symbols | 2 +- .../reference/iteratorSpreadInArray2.symbols | 14 +- .../reference/iteratorSpreadInArray3.symbols | 8 +- .../reference/iteratorSpreadInArray4.symbols | 8 +- .../reference/iteratorSpreadInArray7.symbols | 8 +- .../reference/iteratorSpreadInCall11.symbols | 8 +- .../reference/iteratorSpreadInCall12.symbols | 14 +- .../reference/iteratorSpreadInCall3.symbols | 8 +- .../reference/iteratorSpreadInCall5.symbols | 14 +- .../reference/parserSymbolProperty1.symbols | 6 +- .../reference/parserSymbolProperty2.symbols | 6 +- .../reference/parserSymbolProperty3.symbols | 6 +- .../reference/parserSymbolProperty4.symbols | 6 +- .../reference/parserSymbolProperty5.symbols | 6 +- .../reference/parserSymbolProperty6.symbols | 6 +- .../reference/parserSymbolProperty7.symbols | 6 +- .../reference/parserSymbolProperty8.symbols | 6 +- .../reference/parserSymbolProperty9.symbols | 6 +- .../reference/symbolDeclarationEmit1.symbols | 6 +- .../reference/symbolDeclarationEmit10.symbols | 12 +- .../reference/symbolDeclarationEmit11.symbols | 24 +- .../reference/symbolDeclarationEmit13.symbols | 12 +- .../reference/symbolDeclarationEmit14.symbols | 12 +- .../reference/symbolDeclarationEmit2.symbols | 6 +- .../reference/symbolDeclarationEmit3.symbols | 18 +- .../reference/symbolDeclarationEmit4.symbols | 12 +- .../reference/symbolDeclarationEmit5.symbols | 6 +- .../reference/symbolDeclarationEmit6.symbols | 6 +- .../reference/symbolDeclarationEmit7.symbols | 6 +- .../reference/symbolDeclarationEmit8.symbols | 6 +- .../reference/symbolDeclarationEmit9.symbols | 6 +- .../reference/symbolProperty11.symbols | 6 +- .../reference/symbolProperty13.symbols | 12 +- .../reference/symbolProperty14.symbols | 12 +- .../reference/symbolProperty15.symbols | 6 +- .../reference/symbolProperty16.symbols | 12 +- .../reference/symbolProperty18.symbols | 36 +- .../reference/symbolProperty19.symbols | 24 +- .../reference/symbolProperty2.symbols | 2 +- .../reference/symbolProperty20.symbols | 24 +- .../reference/symbolProperty21.symbols | 30 +- .../reference/symbolProperty22.symbols | 12 +- .../reference/symbolProperty23.symbols | 12 +- .../reference/symbolProperty26.symbols | 12 +- .../reference/symbolProperty27.symbols | 12 +- .../reference/symbolProperty28.symbols | 12 +- .../reference/symbolProperty4.symbols | 6 +- .../reference/symbolProperty40.symbols | 30 +- .../reference/symbolProperty41.symbols | 30 +- .../reference/symbolProperty45.symbols | 12 +- .../reference/symbolProperty5.symbols | 18 +- .../reference/symbolProperty50.symbols | 6 +- .../reference/symbolProperty51.symbols | 6 +- .../reference/symbolProperty55.symbols | 12 +- .../reference/symbolProperty56.symbols | 6 +- .../reference/symbolProperty57.symbols | 8 +- .../reference/symbolProperty6.symbols | 24 +- .../reference/symbolProperty8.symbols | 12 +- .../baselines/reference/symbolType11.symbols | 6 +- .../baselines/reference/symbolType16.symbols | 2 +- ...teStringWithEmbeddedNewOperatorES6.symbols | 2 +- tests/baselines/reference/typedArrays.symbols | 330 +++++++++--------- .../asyncArrowFunction10_es6.ts | 7 + .../asyncArrowFunction1_es6.ts | 5 + .../asyncArrowFunction2_es6.ts | 4 + .../asyncArrowFunction3_es6.ts | 4 + .../asyncArrowFunction4_es6.ts | 4 + .../asyncArrowFunction5_es6.ts | 5 + .../asyncArrowFunction6_es6.ts | 5 + .../asyncArrowFunction7_es6.ts | 8 + .../asyncArrowFunction8_es6.ts | 6 + .../asyncArrowFunction9_es6.ts | 4 + ...asyncArrowFunctionCapturesArguments_es6.ts | 8 + .../asyncArrowFunctionCapturesThis_es6.ts | 7 + .../conformance/async/es6/asyncClass_es6.ts | 4 + .../async/es6/asyncConstructor_es6.ts | 6 + .../conformance/async/es6/asyncDeclare_es6.ts | 3 + .../conformance/async/es6/asyncEnum_es6.ts | 5 + .../conformance/async/es6/asyncGetter_es6.ts | 6 + .../async/es6/asyncInterface_es6.ts | 4 + .../conformance/async/es6/asyncModule_es6.ts | 4 + .../conformance/async/es6/asyncSetter_es6.ts | 6 + .../awaitBinaryExpression1_es6.ts | 9 + .../awaitBinaryExpression2_es6.ts | 9 + .../awaitBinaryExpression3_es6.ts | 9 + .../awaitBinaryExpression4_es6.ts | 9 + .../awaitBinaryExpression5_es6.ts | 10 + .../awaitCallExpression1_es6.ts | 13 + .../awaitCallExpression2_es6.ts | 13 + .../awaitCallExpression3_es6.ts | 13 + .../awaitCallExpression4_es6.ts | 13 + .../awaitCallExpression5_es6.ts | 13 + .../awaitCallExpression6_es6.ts | 13 + .../awaitCallExpression7_es6.ts | 13 + .../awaitCallExpression8_es6.ts | 13 + .../asyncFunctionDeclaration10_es6.ts | 4 + .../asyncFunctionDeclaration11_es6.ts | 4 + .../asyncFunctionDeclaration12_es6.ts | 3 + .../asyncFunctionDeclaration13_es6.ts | 6 + .../asyncFunctionDeclaration14_es6.ts | 5 + .../asyncFunctionDeclaration1_es6.ts | 4 + .../asyncFunctionDeclaration2_es6.ts | 4 + .../asyncFunctionDeclaration3_es6.ts | 4 + .../asyncFunctionDeclaration4_es6.ts | 4 + .../asyncFunctionDeclaration5_es6.ts | 4 + .../asyncFunctionDeclaration6_es6.ts | 4 + .../asyncFunctionDeclaration7_es6.ts | 7 + .../asyncFunctionDeclaration8_es6.ts | 3 + .../asyncFunctionDeclaration9_es6.ts | 5 + 280 files changed, 3208 insertions(+), 767 deletions(-) create mode 100644 tests/baselines/reference/asyncArrowFunction10_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunction10_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction1_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction1_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction1_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction2_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction2_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction2_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction3_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunction3_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction4_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction4_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction4_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction5_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunction5_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction6_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunction6_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction7_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunction7_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction8_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunction8_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js create mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types create mode 100644 tests/baselines/reference/asyncClass_es6.errors.txt create mode 100644 tests/baselines/reference/asyncClass_es6.js create mode 100644 tests/baselines/reference/asyncConstructor_es6.errors.txt create mode 100644 tests/baselines/reference/asyncConstructor_es6.js create mode 100644 tests/baselines/reference/asyncDeclare_es6.errors.txt create mode 100644 tests/baselines/reference/asyncDeclare_es6.js create mode 100644 tests/baselines/reference/asyncEnum_es6.errors.txt create mode 100644 tests/baselines/reference/asyncEnum_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration11_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration11_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration12_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration13_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration13_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration14_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration14_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration1_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration1_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration2_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration2_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration2_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration3_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration3_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration4_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration4_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration4_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration5_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration6_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration7_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration8_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration8_es6.js create mode 100644 tests/baselines/reference/asyncFunctionDeclaration9_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration9_es6.js create mode 100644 tests/baselines/reference/asyncGetter_es6.errors.txt create mode 100644 tests/baselines/reference/asyncGetter_es6.js create mode 100644 tests/baselines/reference/asyncInterface_es6.errors.txt create mode 100644 tests/baselines/reference/asyncInterface_es6.js create mode 100644 tests/baselines/reference/asyncModule_es6.errors.txt create mode 100644 tests/baselines/reference/asyncModule_es6.js create mode 100644 tests/baselines/reference/asyncSetter_es6.errors.txt create mode 100644 tests/baselines/reference/asyncSetter_es6.js create mode 100644 tests/baselines/reference/awaitBinaryExpression1_es6.js create mode 100644 tests/baselines/reference/awaitBinaryExpression1_es6.symbols create mode 100644 tests/baselines/reference/awaitBinaryExpression1_es6.types create mode 100644 tests/baselines/reference/awaitBinaryExpression2_es6.js create mode 100644 tests/baselines/reference/awaitBinaryExpression2_es6.symbols create mode 100644 tests/baselines/reference/awaitBinaryExpression2_es6.types create mode 100644 tests/baselines/reference/awaitBinaryExpression3_es6.js create mode 100644 tests/baselines/reference/awaitBinaryExpression3_es6.symbols create mode 100644 tests/baselines/reference/awaitBinaryExpression3_es6.types create mode 100644 tests/baselines/reference/awaitBinaryExpression4_es6.js create mode 100644 tests/baselines/reference/awaitBinaryExpression4_es6.symbols create mode 100644 tests/baselines/reference/awaitBinaryExpression4_es6.types create mode 100644 tests/baselines/reference/awaitBinaryExpression5_es6.js create mode 100644 tests/baselines/reference/awaitBinaryExpression5_es6.symbols create mode 100644 tests/baselines/reference/awaitBinaryExpression5_es6.types create mode 100644 tests/baselines/reference/awaitCallExpression1_es6.js create mode 100644 tests/baselines/reference/awaitCallExpression1_es6.symbols create mode 100644 tests/baselines/reference/awaitCallExpression1_es6.types create mode 100644 tests/baselines/reference/awaitCallExpression2_es6.js create mode 100644 tests/baselines/reference/awaitCallExpression2_es6.symbols create mode 100644 tests/baselines/reference/awaitCallExpression2_es6.types create mode 100644 tests/baselines/reference/awaitCallExpression3_es6.js create mode 100644 tests/baselines/reference/awaitCallExpression3_es6.symbols create mode 100644 tests/baselines/reference/awaitCallExpression3_es6.types create mode 100644 tests/baselines/reference/awaitCallExpression4_es6.js create mode 100644 tests/baselines/reference/awaitCallExpression4_es6.symbols create mode 100644 tests/baselines/reference/awaitCallExpression4_es6.types create mode 100644 tests/baselines/reference/awaitCallExpression5_es6.js create mode 100644 tests/baselines/reference/awaitCallExpression5_es6.symbols create mode 100644 tests/baselines/reference/awaitCallExpression5_es6.types create mode 100644 tests/baselines/reference/awaitCallExpression6_es6.js create mode 100644 tests/baselines/reference/awaitCallExpression6_es6.symbols create mode 100644 tests/baselines/reference/awaitCallExpression6_es6.types create mode 100644 tests/baselines/reference/awaitCallExpression7_es6.js create mode 100644 tests/baselines/reference/awaitCallExpression7_es6.symbols create mode 100644 tests/baselines/reference/awaitCallExpression7_es6.types create mode 100644 tests/baselines/reference/awaitCallExpression8_es6.js create mode 100644 tests/baselines/reference/awaitCallExpression8_es6.symbols create mode 100644 tests/baselines/reference/awaitCallExpression8_es6.types create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncClass_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncConstructor_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncDeclare_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncEnum_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncGetter_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncInterface_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncModule_es6.ts create mode 100644 tests/cases/conformance/async/es6/asyncSetter_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts create mode 100644 tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts create mode 100644 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 13f527bd9f8..3532c778dd1 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -102,7 +102,7 @@ module ts { let globalArraySymbol: Symbol; let globalESSymbolConstructorSymbol: Symbol; - let getGlobalPromiseSymbol: () => Symbol; + let getGlobalPromiseConstructorSymbol: () => Symbol; let globalObjectType: ObjectType; let globalFunctionType: ObjectType; @@ -139,7 +139,6 @@ module ts { let symbolLinks: SymbolLinks[] = []; let nodeLinks: NodeLinks[] = []; let potentialThisCollisions: Node[] = []; - var potentialArgumentsCollisions: Node[] = []; let diagnostics = createDiagnosticCollection(); @@ -5420,11 +5419,13 @@ module ts { // can explicitly bound arguments objects let container = getContainingFunction(node); if (symbol === argumentsSymbol) { - if (container.kind === SyntaxKind.ArrowFunction && languageVersion < ScriptTarget.ES6) { - error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); - } - else if (node.parserContextFlags & ParserContextFlags.Await) { - captureLexicalArguments(node, container); + if (container.kind === SyntaxKind.ArrowFunction) { + if (languageVersion < ScriptTarget.ES6) { + error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); + } + else if (node.parserContextFlags & ParserContextFlags.Await) { + error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression); + } } } @@ -5434,7 +5435,6 @@ module ts { checkCollisionWithCapturedSuperVariable(node, node); checkCollisionWithCapturedThisVariable(node, node); - checkCollisionWithCapturedArgumentsVariable(node, node); checkBlockScopedBindingCapturedInLoop(node, symbol); return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node); @@ -5516,10 +5516,9 @@ module ts { // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES6); } - - if (node.parserContextFlags & ParserContextFlags.Await) { + else if (node.parserContextFlags & ParserContextFlags.Await) { // if 'this' is part of an async function, we will need to capture 'this' - needToCaptureLexicalThis = true; + needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES6); } switch (container.kind) { @@ -5561,14 +5560,6 @@ module ts { return anyType; } - function captureLexicalArguments(node: Node, container: Node): void { - if (node.parent.kind !== SyntaxKind.Parameter) { - getNodeLinks(node).flags |= NodeCheckFlags.LexicalArguments; - } - - getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments; - } - function isInConstructorArgumentInitializer(node: Node, constructorDecl: Node): boolean { for (let n = node; n && n !== constructorDecl; n = n.parent) { if (n.kind === SyntaxKind.Parameter) { @@ -7303,7 +7294,7 @@ module ts { let widenedType = getWidenedType(type); return isAsync ? createPromiseType(widenedType, func) - : type; + : widenedType; } /// Returns a set of types relating to every return expression relating to a function block. @@ -7421,7 +7412,6 @@ module ts { if (produceDiagnostics && node.kind !== SyntaxKind.MethodDeclaration && node.kind !== SyntaxKind.MethodSignature) { checkCollisionWithCapturedSuperVariable(node, (node).name); checkCollisionWithCapturedThisVariable(node, (node).name); - checkCollisionWithCapturedArgumentsVariable(node, (node).name); } return type; @@ -7574,13 +7564,7 @@ module ts { function checkAwaitExpression(node: AwaitExpression): Type { // Grammar checking if (!(node.parserContextFlags & ParserContextFlags.Await)) { - var parameter = getContainingParameter(node); - if (parameter && parameter.parserContextFlags & ParserContextFlags.Await) { - grammarErrorAfterFirstToken(node, Diagnostics._0_expression_is_not_allowed_in_an_initializer, "await"); - } - else { - grammarErrorOnFirstToken(node, Diagnostics.await_expression_must_be_contained_within_an_async_function); - } + grammarErrorOnFirstToken(node, Diagnostics.await_expression_must_be_contained_within_an_async_function); } var operandType = checkExpression(node.expression); @@ -7994,13 +7978,7 @@ module ts { function checkYieldExpression(node: YieldExpression): void { // Grammar checking if (!(node.parserContextFlags & ParserContextFlags.Yield)) { - let parameter = getContainingParameter(node); - if (parameter && (parameter.parserContextFlags & ParserContextFlags.GeneratorParameter)) { - grammarErrorAfterFirstToken(node, Diagnostics._0_expression_is_not_allowed_in_an_initializer, "yield"); - } - else { - grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration); - } + grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration); } else { grammarErrorOnFirstToken(node, Diagnostics.yield_expressions_are_not_currently_supported); @@ -8907,23 +8885,25 @@ module ts { // the "promised type" of a type is the type of the "value" argument of the "onfulfilled" callback. let globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType(); if (globalPromiseLikeType !== emptyObjectType && isTypeAssignableTo(type, globalPromiseLikeType)) { - let awaitedTypes: Type[] = []; let thenProp = getPropertyOfType(type, "then"); - let thenType = getTypeOfSymbol(thenProp); - let thenSignatures = getSignaturesOfType(thenType, SignatureKind.Call); - for (let thenSignature of thenSignatures) { - thenSignature = getErasedSignature(thenSignature); - let onfulfilledParameterType = getTypeAtPosition(thenSignature, 0); - let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call); - for (let onfulfilledParameterSignature of onfulfilledParameterSignatures) { - let valueParameterType = getTypeAtPosition(onfulfilledParameterSignature, 0); - if (valueParameterType !== type) { - awaitedTypes.push(valueParameterType); + if (thenProp) { + let awaitedTypes: Type[] = []; + let thenType = getTypeOfSymbol(thenProp); + let thenSignatures = getSignaturesOfType(thenType, SignatureKind.Call); + for (let thenSignature of thenSignatures) { + thenSignature = getErasedSignature(thenSignature); + let onfulfilledParameterType = getTypeAtPosition(thenSignature, 0); + let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call); + for (let onfulfilledParameterSignature of onfulfilledParameterSignatures) { + let valueParameterType = getTypeAtPosition(onfulfilledParameterSignature, 0); + if (valueParameterType !== type) { + awaitedTypes.push(valueParameterType); + } } } - } - - return getUnionType(awaitedTypes); + + return getUnionType(awaitedTypes); + } } return emptyObjectType; @@ -9142,7 +9122,6 @@ module ts { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); - checkCollisionWithCapturedArgumentsVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); } } @@ -9262,12 +9241,6 @@ module ts { } } - function checkCollisionWithCapturedArgumentsVariable(node: Node, name: Identifier): void { - if (needCollisionCheckForIdentifier(node, name, "_arguments")) { - potentialArgumentsCollisions.push(node); - } - } - // this function will run after checking the source file so 'CaptureThis' is correct for all nodes function checkIfThisIsCapturedInEnclosingScope(node: Node): void { let current = node; @@ -9286,25 +9259,6 @@ module ts { } } - function checkIfArgumentsIsCapturedInEnclosingScope(node: Node): void { - let current = node; - while (current) { - if (getNodeCheckFlags(current) & NodeCheckFlags.CaptureArguments) { - let isDeclaration = node.kind !== SyntaxKind.Identifier; - if (isDeclaration) { - error((node).name, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_variable_declaration_arguments_to_capture_arguments_reference); - } - else { - error(node, Diagnostics.Expression_resolves_to_variable_declaration_arguments_that_compiler_uses_to_capture_arguments_reference); - } - - return; - } - - current = current.parent; - } - } - function checkCollisionWithCapturedSuperVariable(node: Node, name: Identifier) { if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; @@ -9421,15 +9375,17 @@ module ts { } function getPromiseConstructor(node: SignatureDeclaration): EntityName { - if (node.type && node.type.kind === SyntaxKind.TypeReference) { - return (node.type).typeName; + if (isAsyncFunctionLike(node)) { + let links = getNodeLinks(node); + if (!links.promiseConstructor) { + if (node.type && node.type.kind === SyntaxKind.TypeReference) { + links.promiseConstructor = (node.type).typeName; + } + } + + return links.promiseConstructor; } - - let globalPromiseSymbol = getGlobalPromiseSymbol(); - if (globalPromiseSymbol && globalPromiseSymbol === resolveName(node, "Promise", SymbolFlags.Value, undefined, undefined)) { - return globalPromiseSymbol.valueDeclaration.name; - } - + return undefined; } @@ -9550,14 +9506,8 @@ module ts { } checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); - checkCollisionWithCapturedArgumentsVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); } - - if (symbol === argumentsSymbol && (node.parserContextFlags & ParserContextFlags.Await)) { - let container = getContainingFunction(node); - captureLexicalArguments(node.name, container); - } } function checkVariableDeclaration(node: VariableDeclaration) { @@ -11258,7 +11208,6 @@ module ts { emitDecorate = false; emitParam = false; potentialThisCollisions.length = 0; - potentialArgumentsCollisions.length = 0; forEach(node.statements, checkSourceElement); checkFunctionExpressionBodies(node); @@ -11272,11 +11221,6 @@ module ts { potentialThisCollisions.length = 0; } - if (potentialArgumentsCollisions.length) { - forEach(potentialArgumentsCollisions, checkIfArgumentsIsCapturedInEnclosingScope); - potentialArgumentsCollisions.length = 0; - } - if (emitExtends) { links.flags |= NodeCheckFlags.EmitExtends; } @@ -12279,6 +12223,7 @@ module ts { serializeTypeOfNode, serializeParameterTypesOfNode, serializeReturnTypeOfNode, + getPromiseConstructor, }; } @@ -12313,10 +12258,10 @@ module ts { getGlobalPropertyDecoratorType = memoize(() => getGlobalType("PropertyDecorator")); getGlobalMethodDecoratorType = memoize(() => getGlobalType("MethodDecorator")); getGlobalParameterDecoratorType = memoize(() => getGlobalType("ParameterDecorator")); - getGlobalPromiseSymbol = memoize(() => getGlobalTypeSymbol("Promise")); - getGlobalPromiseType = memoize(() => getTypeOfGlobalSymbol(getGlobalPromiseSymbol(), /*arity*/ 1)); + getGlobalPromiseType = memoize(() => getGlobalType("Promise", /*arity*/ 1)); getGlobalPromiseLikeType = memoize(() => getGlobalType("PromiseLike", /*arity*/ 1)); getInstantiatedGlobalPromiseLikeType = memoize(createInstantiatedPromiseLikeType); + getGlobalPromiseConstructorSymbol = memoize(() => getGlobalValueSymbol("Promise")); getGlobalPromiseConstructorLikeType = memoize(() => getGlobalType("PromiseConstructorLike")); getGlobalThenableType = memoize(createThenableType); diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 091cabb4480..39492ac5344 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -383,8 +383,7 @@ module ts { A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." }, Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." }, Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." }, - Duplicate_identifier_arguments_Compiler_uses_variable_declaration_arguments_to_capture_arguments_reference: { code: 2522, category: DiagnosticCategory.Error, key: "Duplicate identifier '_arguments'. Compiler uses variable declaration '_arguments' to capture 'arguments' reference." }, - Expression_resolves_to_variable_declaration_arguments_that_compiler_uses_to_capture_arguments_reference: { code: 2523, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '_arguments' that compiler uses to capture 'arguments' reference." }, + The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 431aec3f531..874c259a3b6 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1522,14 +1522,10 @@ "category": "Error", "code": 2521 }, - "Duplicate identifier '_arguments'. Compiler uses variable declaration '_arguments' to capture 'arguments' reference.": { + "The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression.": { "category": "Error", "code": 2522 }, - "Expression resolves to variable declaration '_arguments' that compiler uses to capture 'arguments' reference.": { - "category": "Error", - "code": 2523 - }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 5a9a654ce60..e31989e6726 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -48,6 +48,21 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return function (target, key) { decorator(target, key, paramIndex); } };`; + const awaiterHelper = ` +var __awaiter = (this && this.__awaiter) || function (generator, ctor) { + function resolve(value) { return step(generator.next(value)); } + function reject(reason) { return step(generator["throw"](reason)); } + function step(result) { + while (true) { + var done = result.done, value = result.value, then; + if (done) return value; + if (value && typeof (then = value.then) === "function") return then.call(value, resolve, reject); + result = generator.next(value); + } + } + return new (ctor || Promise)(function (resolver) { resolver(resolve(undefined)); }); +}`; + let compilerOptions = host.getCompilerOptions(); let languageVersion = compilerOptions.target || ScriptTarget.ES3; let sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined; @@ -131,6 +146,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { let extendsEmitted = false; let decorateEmitted = false; let paramEmitted = false; + let awaiterEmitted = false; let tempFlags = 0; let tempVariables: Identifier[]; let tempParameters: Identifier[]; @@ -1350,6 +1366,31 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { emit(node.expression); } } + + function emitAwaitExpression(node: AwaitExpression) { + let needsParenthesis = needsParenthesisForAwaitExpressionAsYield(node); + if (needsParenthesis) { + write("("); + } + write(tokenToString(SyntaxKind.YieldKeyword)); + write(" "); + emit(node.expression); + if (needsParenthesis) { + write(")"); + } + } + + function needsParenthesisForAwaitExpressionAsYield(node: AwaitExpression) { + for (let current: Node = node; isExpression(current.parent); current = current.parent) { + if (current.parent.kind === SyntaxKind.BinaryExpression) { + if ((current.parent).left === current) { + return true; + } + } + } + + return false; + } function needsParenthesisForPropertyAccessOrInvocation(node: Expression) { switch (node.kind) { @@ -3280,9 +3321,71 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { emit(node.parameters[0]); return; } + emitSignatureParameters(node); } + function emitAsyncSignatureAndBodyForES6(node: FunctionLikeDeclaration) { + let promiseConstructor = resolver.getPromiseConstructor(node); + let resolve = makeUniqueName("resolve"); + let isArrowFunction = node.kind === SyntaxKind.ArrowFunction; + let args: string; + if (isArrowFunction) { + if (node.parameters.length) { + args = makeUniqueName("arguments"); + write(`(...${args}) => `); + } + else { + write("() => "); + } + } + else { + args = "arguments"; + write("() {"); + increaseIndent(); + writeLine(); + write("return "); + } + + write("__awaiter(function *"); + + emitSignatureParameters(node); + emitFunctionBody(node); + write(".apply(this"); + if (args) { + write(`, ${args}`); + } + write(")"); + if (promiseConstructor) { + write(", "); + emit(promiseConstructor); + } + write(")"); + + if (!isArrowFunction) { + write(";"); + decreaseIndent(); + writeLine(); + write("}"); + } + } + + function emitFunctionBody(node: FunctionLikeDeclaration) { + if (!node.body) { + // There can be no body when there are parse errors. Just emit an empty block + // in that case. + write(" { }"); + } + else { + if (node.body.kind === SyntaxKind.Block) { + emitBlockFunctionBody(node, node.body); + } + else { + emitExpressionFunctionBody(node, node.body); + } + } + } + function emitSignatureAndBody(node: FunctionLikeDeclaration) { let saveTempFlags = tempFlags; let saveTempVariables = tempVariables; @@ -3291,27 +3394,23 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { tempVariables = undefined; tempParameters = undefined; - // When targeting ES6, emit arrow function natively in ES6 - if (shouldEmitAsArrowFunction(node)) { - emitSignatureParametersForArrow(node); - write(" =>"); + let isAsync = isAsyncFunctionLike(node); + if (isAsync && languageVersion === ScriptTarget.ES6) { + emitAsyncSignatureAndBodyForES6(node); } else { - emitSignatureParameters(node); + // When targeting ES6, emit arrow function natively in ES6 + if (shouldEmitAsArrowFunction(node)) { + emitSignatureParametersForArrow(node); + write(" =>"); + } + else { + emitSignatureParameters(node); + } + + emitFunctionBody(node); } - - if (!node.body) { - // There can be no body when there are parse errors. Just emit an empty block - // in that case. - write(" { }"); - } - else if (node.body.kind === SyntaxKind.Block) { - emitBlockFunctionBody(node, node.body); - } - else { - emitExpressionFunctionBody(node, node.body); - } - + if (!isES6ExportedDeclaration(node)) { emitExportMemberAssignment(node); } @@ -3329,7 +3428,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } function emitExpressionFunctionBody(node: FunctionLikeDeclaration, body: Expression) { - if (languageVersion < ScriptTarget.ES6) { + if (languageVersion < ScriptTarget.ES6 || node.flags & NodeFlags.Async) { emitDownLevelExpressionFunctionBody(node, body); return; } @@ -5636,6 +5735,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { writeLines(paramHelper); paramEmitted = true; } + + if (!awaiterEmitted && resolver.getNodeCheckFlags(node) & NodeCheckFlags.EmitAwaiter) { + writeLines(awaiterHelper); + awaiterEmitted = true; + } } if (isExternalModule(node) || compilerOptions.separateCompilation) { @@ -5806,6 +5910,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return emitTypeOfExpression(node); case SyntaxKind.VoidExpression: return emitVoidExpression(node); + case SyntaxKind.AwaitExpression: + return emitAwaitExpression(node); case SyntaxKind.PrefixUnaryExpression: return emitPrefixUnaryExpression(node); case SyntaxKind.PostfixUnaryExpression: diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index db958087178..a22ec28ecbc 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -568,11 +568,11 @@ module ts { } function doOutsideOfContext(context: ParserContextFlags, func: () => T): T { - let currentContextFlags = contextFlags & context; - if (currentContextFlags) { - setContextFlag(false, currentContextFlags); + let setContextFlags = context & contextFlags; + if (setContextFlags) { + setContextFlag(false, setContextFlags); let result = func(); - setContextFlag(true, currentContextFlags); + setContextFlag(true, setContextFlags); return result; } @@ -582,7 +582,7 @@ module ts { function doInsideOfContext(context: ParserContextFlags, func: () => T): T { let unsetContextFlags = context & ~contextFlags; - if (!unsetContextFlags) { + if (unsetContextFlags) { setContextFlag(true, unsetContextFlags); let result = func(); setContextFlag(false, unsetContextFlags); @@ -594,11 +594,11 @@ module ts { } function allowInAnd(func: () => T): T { - return doInsideOfContext(ParserContextFlags.DisallowIn, func); + return doOutsideOfContext(ParserContextFlags.DisallowIn, func); } function disallowInAnd(func: () => T): T { - return doOutsideOfContext(ParserContextFlags.DisallowIn, func); + return doInsideOfContext(ParserContextFlags.DisallowIn, func); } function doInYieldContext(func: () => T): T { @@ -772,6 +772,12 @@ module ts { if (token === SyntaxKind.YieldKeyword && inYieldContext()) { return false; } + + // If we have a 'await' keyword, and we're in the [Await] context, then 'await' is + // considered a keyword and is not an identifier. + if (token === SyntaxKind.AwaitKeyword && inAwaitContext()) { + return false; + } return token > SyntaxKind.LastReservedWord; } @@ -2642,12 +2648,11 @@ module ts { function tryParseParenthesizedArrowFunctionExpression(): Expression { let triState = isParenthesizedArrowFunctionExpression(); - if (triState === Tristate.False) { // It's definitely not a parenthesized arrow function expression. return undefined; } - + // If we definitely have an arrow function, then we can just parse one, not requiring a // following => or { token. Otherwise, we *might* have an arrow function. Try to parse // it out, but don't allow any ambiguity, and return 'undefined' if this could be an diff --git a/src/compiler/types.ts b/src/compiler/types.ts index b23b46bc9bd..f256c63056f 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1304,6 +1304,7 @@ module ts { serializeTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[]; serializeParameterTypesOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): (string | string[])[]; serializeReturnTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[]; + getPromiseConstructor(node: SignatureDeclaration): EntityName; } export const enum SymbolFlags { @@ -1423,22 +1424,20 @@ module ts { TypeChecked = 0x00000001, // Node has been type checked LexicalThis = 0x00000002, // Lexical 'this' reference CaptureThis = 0x00000004, // Lexical 'this' used in body - LexicalArguments = 0x00000008, // Lexical 'arguments' reference - CaptureArguments = 0x00000010, // Lexical 'arguments' used in body - EmitExtends = 0x00000020, // Emit __extends - EmitDecorate = 0x00000040, // Emit __decorate - EmitParam = 0x00000080, // Emit __param helper for decorators - EmitAwaiter = 0x00000100, // Emit __awaiter - EmitGenerator = 0x00000200, // Emit __generator - SuperInstance = 0x00000400, // Instance 'super' reference - SuperStatic = 0x00000800, // Static 'super' reference - ContextChecked = 0x00001000, // Contextual types have been assigned - PromiseCollision = 0x00002000, // Declaration collides with the global 'Promise' + EmitExtends = 0x00000008, // Emit __extends + EmitDecorate = 0x00000010, // Emit __decorate + EmitParam = 0x00000020, // Emit __param helper for decorators + EmitAwaiter = 0x00000040, // Emit __awaiter + EmitGenerator = 0x00000080, // Emit __generator + SuperInstance = 0x00000100, // Instance 'super' reference + SuperStatic = 0x00000200, // Static 'super' reference + ContextChecked = 0x00000400, // Contextual types have been assigned + PromiseCollision = 0x00000800, // Declaration collides with the global 'Promise' // Values for enum members have been computed, and any errors have been reported for them. - EnumValuesComputed = 0x00004000, - BlockScopedBindingInLoop = 0x00008000, - LexicalModuleMergesWithClass= 0x00010000, // Instantiated lexical module declaration is merged with a previous class declaration. + EnumValuesComputed = 0x00001000, + BlockScopedBindingInLoop = 0x00002000, + LexicalModuleMergesWithClass= 0x00004000, // Instantiated lexical module declaration is merged with a previous class declaration. } /* @internal */ @@ -1456,6 +1455,7 @@ module ts { assignmentChecks?: Map; // Cache of assignment checks hasReportedStatementInAmbientContext?: boolean; // Cache boolean if we report statements in ambient context importOnRightSide?: Symbol; // for import declarations - import that appear on the right side + promiseConstructor?: EntityName; } export const enum TypeFlags { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index e5856077edc..3536315853b 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1705,7 +1705,7 @@ module ts { return false; } } - + export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) { return (node.parent.kind === SyntaxKind.QualifiedName && (node.parent).right === node) || (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).name === node); diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt index 8c6b09c82d6..6efd10dce09 100644 --- a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt @@ -1,8 +1,20 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,10): error TS9001: Generators are not currently supported. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,16): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,26): error TS1005: ',' expected. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS1138: Parameter declaration expected. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS2304: Cannot find name 'yield'. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,34): error TS1005: ';' expected. -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (1 errors) ==== +==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (5 errors) ==== function * foo(a = yield => yield) { - ~ -!!! error TS9001: Generators are not currently supported. + ~~~~~~~~~ +!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. + ~~ +!!! error TS1005: ',' expected. + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2304: Cannot find name 'yield'. + ~ +!!! error TS1005: ';' expected. } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt index b5ea3f494a7..13f69a47653 100644 --- a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS9001: Generators are not currently supported. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2304: Cannot find name 'yield'. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS9000: 'yield' expressions are not currently supported. ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ==== @@ -7,5 +7,5 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,1 ~ !!! error TS9001: Generators are not currently supported. ~~~~~ -!!! error TS2304: Cannot find name 'yield'. +!!! error TS9000: 'yield' expressions are not currently supported. } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt index f129d3fa30b..8b15522b136 100644 --- a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt @@ -1,6 +1,6 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS9001: Generators are not currently supported. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS9001: Generators are not currently supported. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2304: Cannot find name 'yield'. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS9000: 'yield' expressions are not currently supported. ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ==== @@ -12,6 +12,6 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,2 ~ !!! error TS9001: Generators are not currently supported. ~~~~~ -!!! error TS2304: Cannot find name 'yield'. +!!! error TS9000: 'yield' expressions are not currently supported. } } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression12_es6.errors.txt b/tests/baselines/reference/YieldExpression12_es6.errors.txt index 10843421a3f..04c50ca2c34 100644 --- a/tests/baselines/reference/YieldExpression12_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression12_es6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): error TS1163: 'yield' expression must be contained_within a generator declaration. +tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): error TS1163: 'yield' expression must be contained within a generator declaration. ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts (1 errors) ==== @@ -6,6 +6,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): erro constructor() { yield foo ~~~~~ -!!! error TS1163: 'yield' expression must be contained_within a generator declaration. +!!! error TS1163: 'yield' expression must be contained within a generator declaration. } } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression14_es6.errors.txt b/tests/baselines/reference/YieldExpression14_es6.errors.txt index baeaf3ba30e..ddc427bacbe 100644 --- a/tests/baselines/reference/YieldExpression14_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression14_es6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): error TS1163: 'yield' expression must be contained_within a generator declaration. +tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): error TS1163: 'yield' expression must be contained within a generator declaration. ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts (1 errors) ==== @@ -6,6 +6,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): erro foo() { yield foo ~~~~~ -!!! error TS1163: 'yield' expression must be contained_within a generator declaration. +!!! error TS1163: 'yield' expression must be contained within a generator declaration. } } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression15_es6.errors.txt b/tests/baselines/reference/YieldExpression15_es6.errors.txt index 5e548799f5d..12d16a52d0a 100644 --- a/tests/baselines/reference/YieldExpression15_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression15_es6.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts(2,6): error TS1163: 'yield' expression must be contained_within a generator declaration. +tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts(2,6): error TS1163: 'yield' expression must be contained within a generator declaration. ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts (1 errors) ==== var v = () => { yield foo ~~~~~ -!!! error TS1163: 'yield' expression must be contained_within a generator declaration. +!!! error TS1163: 'yield' expression must be contained within a generator declaration. } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression16_es6.errors.txt b/tests/baselines/reference/YieldExpression16_es6.errors.txt index c0d2e4c8fc8..0b3d71c6ae4 100644 --- a/tests/baselines/reference/YieldExpression16_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression16_es6.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(1,9): error TS9001: Generators are not currently supported. -tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: 'yield' expression must be contained_within a generator declaration. +tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: 'yield' expression must be contained within a generator declaration. ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (2 errors) ==== @@ -9,6 +9,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): erro function bar() { yield foo; ~~~~~ -!!! error TS1163: 'yield' expression must be contained_within a generator declaration. +!!! error TS1163: 'yield' expression must be contained within a generator declaration. } } \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression17_es6.errors.txt b/tests/baselines/reference/YieldExpression17_es6.errors.txt index b39f47b07f9..0bcefebede2 100644 --- a/tests/baselines/reference/YieldExpression17_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression17_es6.errors.txt @@ -1,6 +1,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. -tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: 'yield' expression must be contained_within a generator declaration. +tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: 'yield' expression must be contained within a generator declaration. ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts (3 errors) ==== @@ -10,4 +10,4 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): err ~~~ !!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. ~~~~~ -!!! error TS1163: 'yield' expression must be contained_within a generator declaration. \ No newline at end of file +!!! error TS1163: 'yield' expression must be contained within a generator declaration. \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression18_es6.errors.txt b/tests/baselines/reference/YieldExpression18_es6.errors.txt index 3a67acdebcd..1fae530e44b 100644 --- a/tests/baselines/reference/YieldExpression18_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression18_es6.errors.txt @@ -1,8 +1,8 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts(2,1): error TS1163: 'yield' expression must be contained_within a generator declaration. +tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts(2,1): error TS1163: 'yield' expression must be contained within a generator declaration. ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts (1 errors) ==== "use strict"; yield(foo); ~~~~~ -!!! error TS1163: 'yield' expression must be contained_within a generator declaration. \ No newline at end of file +!!! error TS1163: 'yield' expression must be contained within a generator declaration. \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression2_es6.errors.txt b/tests/baselines/reference/YieldExpression2_es6.errors.txt index 553dab51fc2..9a3a4d69fac 100644 --- a/tests/baselines/reference/YieldExpression2_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression2_es6.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts(1,1): error TS1163: 'yield' expression must be contained_within a generator declaration. +tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts(1,1): error TS1163: 'yield' expression must be contained within a generator declaration. ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts (1 errors) ==== yield foo; ~~~~~ -!!! error TS1163: 'yield' expression must be contained_within a generator declaration. \ No newline at end of file +!!! error TS1163: 'yield' expression must be contained within a generator declaration. \ No newline at end of file diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols index 3b435de2e51..30f541751a1 100644 --- a/tests/baselines/reference/arrayLiterals2ES6.symbols +++ b/tests/baselines/reference/arrayLiterals2ES6.symbols @@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]]; interface myArray extends Array { } >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) interface myArray2 extends Array { } >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) var d0 = [1, true, ...temp, ]; // has type (string|number|boolean)[] >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3)) diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt new file mode 100644 index 00000000000..2476eaec6e3 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,17): error TS1005: ',' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,20): error TS1005: '=' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,24): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(4,11): error TS2304: Cannot find name 'await'. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts (5 errors) ==== + + var foo = async foo(): Promise => { + ~~~~~ +!!! error TS2304: Cannot find name 'async'. + ~~~ +!!! error TS1005: ',' expected. + ~ +!!! error TS1005: '=' expected. + ~~~~~~~~~~~~~ +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. + // Legal to use 'await' in a type context. + var v: await; + ~~~~~ +!!! error TS2304: Cannot find name 'await'. + } + \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.js b/tests/baselines/reference/asyncArrowFunction10_es6.js new file mode 100644 index 00000000000..23b2c3af80e --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction10_es6.js @@ -0,0 +1,13 @@ +//// [asyncArrowFunction10_es6.ts] + +var foo = async foo(): Promise => { + // Legal to use 'await' in a type context. + var v: await; +} + + +//// [asyncArrowFunction10_es6.js] +var foo = async, foo = () => { + // Legal to use 'await' in a type context. + var v; +}; diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js new file mode 100644 index 00000000000..78a2899d056 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction1_es6.js @@ -0,0 +1,8 @@ +//// [asyncArrowFunction1_es6.ts] + +var foo = async (): Promise => { +}; + +//// [asyncArrowFunction1_es6.js] +var foo = () => __awaiter(function *() { +}.apply(this), Promise); diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols new file mode 100644 index 00000000000..dc2ed671c46 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts === + +var foo = async (): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +}; diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.types b/tests/baselines/reference/asyncArrowFunction1_es6.types new file mode 100644 index 00000000000..3ecfdeb7919 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction1_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts === + +var foo = async (): Promise => { +>foo : () => Promise +>async (): Promise => {} : () => Promise +>Promise : Promise + +}; diff --git a/tests/baselines/reference/asyncArrowFunction2_es6.js b/tests/baselines/reference/asyncArrowFunction2_es6.js new file mode 100644 index 00000000000..9d7f1d10ea6 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction2_es6.js @@ -0,0 +1,7 @@ +//// [asyncArrowFunction2_es6.ts] +var f = (await) => { +} + +//// [asyncArrowFunction2_es6.js] +var f = (await) => { +}; diff --git a/tests/baselines/reference/asyncArrowFunction2_es6.symbols b/tests/baselines/reference/asyncArrowFunction2_es6.symbols new file mode 100644 index 00000000000..dd8b4ea2390 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction2_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts === +var f = (await) => { +>f : Symbol(f, Decl(asyncArrowFunction2_es6.ts, 0, 3)) +>await : Symbol(await, Decl(asyncArrowFunction2_es6.ts, 0, 9)) +} diff --git a/tests/baselines/reference/asyncArrowFunction2_es6.types b/tests/baselines/reference/asyncArrowFunction2_es6.types new file mode 100644 index 00000000000..98808d175f8 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction2_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts === +var f = (await) => { +>f : (await: any) => void +>(await) => {} : (await: any) => void +>await : any +} diff --git a/tests/baselines/reference/asyncArrowFunction3_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction3_es6.errors.txt new file mode 100644 index 00000000000..d0f56df51da --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction3_es6.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts(1,20): error TS2372: Parameter 'await' cannot be referenced in its initializer. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts (1 errors) ==== + function f(await = await) { + ~~~~~ +!!! error TS2372: Parameter 'await' cannot be referenced in its initializer. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction3_es6.js b/tests/baselines/reference/asyncArrowFunction3_es6.js new file mode 100644 index 00000000000..9616336d76a --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction3_es6.js @@ -0,0 +1,7 @@ +//// [asyncArrowFunction3_es6.ts] +function f(await = await) { +} + +//// [asyncArrowFunction3_es6.js] +function f(await = await) { +} diff --git a/tests/baselines/reference/asyncArrowFunction4_es6.js b/tests/baselines/reference/asyncArrowFunction4_es6.js new file mode 100644 index 00000000000..eb89d98bbeb --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction4_es6.js @@ -0,0 +1,7 @@ +//// [asyncArrowFunction4_es6.ts] +var await = () => { +} + +//// [asyncArrowFunction4_es6.js] +var await = () => { +}; diff --git a/tests/baselines/reference/asyncArrowFunction4_es6.symbols b/tests/baselines/reference/asyncArrowFunction4_es6.symbols new file mode 100644 index 00000000000..1c001040720 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction4_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts === +var await = () => { +>await : Symbol(await, Decl(asyncArrowFunction4_es6.ts, 0, 3)) +} diff --git a/tests/baselines/reference/asyncArrowFunction4_es6.types b/tests/baselines/reference/asyncArrowFunction4_es6.types new file mode 100644 index 00000000000..e23ff786105 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction4_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts === +var await = () => { +>await : () => void +>() => {} : () => void +} diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt new file mode 100644 index 00000000000..fed29620532 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,18): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,24): error TS1005: ',' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,26): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,33): error TS1005: '=' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,40): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts (6 errors) ==== + + var foo = async (await): Promise => { + ~~~~~ +!!! error TS2304: Cannot find name 'async'. + ~~~~~ +!!! error TS2304: Cannot find name 'await'. + ~ +!!! error TS1005: ',' expected. + ~~~~~~~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. + ~ +!!! error TS1005: '=' expected. + ~~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.js b/tests/baselines/reference/asyncArrowFunction5_es6.js new file mode 100644 index 00000000000..ed4035e6175 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction5_es6.js @@ -0,0 +1,9 @@ +//// [asyncArrowFunction5_es6.ts] + +var foo = async (await): Promise => { +} + +//// [asyncArrowFunction5_es6.js] +var foo = async(await), Promise = ; +{ +} diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt new file mode 100644 index 00000000000..3afce3a8127 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt @@ -0,0 +1,9 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,27): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts (1 errors) ==== + + var foo = async (a = await): Promise => { + ~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js new file mode 100644 index 00000000000..186ecc4cf19 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -0,0 +1,8 @@ +//// [asyncArrowFunction6_es6.ts] + +var foo = async (a = await): Promise => { +} + +//// [asyncArrowFunction6_es6.js] +var foo = (...arguments_1) => __awaiter(function *(a = yield ) { +}.apply(this, arguments_1), Promise); diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt new file mode 100644 index 00000000000..db7e634b479 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt @@ -0,0 +1,12 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,29): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts (1 errors) ==== + + var bar = async (): Promise => { + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { + ~ +!!! error TS1109: Expression expected. + } + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js new file mode 100644 index 00000000000..b1859159c92 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -0,0 +1,14 @@ +//// [asyncArrowFunction7_es6.ts] + +var bar = async (): Promise => { + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { + } +} + +//// [asyncArrowFunction7_es6.js] +var bar = () => __awaiter(function *() { + // 'await' here is an identifier, and not an await expression. + var foo = (...arguments_1) => __awaiter(function *(a = yield ) { + }.apply(this, arguments_1), Promise); +}.apply(this), Promise); diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt new file mode 100644 index 00000000000..7252805cdca --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts(3,19): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts (1 errors) ==== + + var foo = async (): Promise => { + var v = { [await]: foo } + ~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js new file mode 100644 index 00000000000..3f98f3a4f63 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction8_es6.js @@ -0,0 +1,10 @@ +//// [asyncArrowFunction8_es6.ts] + +var foo = async (): Promise => { + var v = { [await]: foo } +} + +//// [asyncArrowFunction8_es6.js] +var foo = () => __awaiter(function *() { + var v = { [yield ]: foo }; +}.apply(this), Promise); diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt new file mode 100644 index 00000000000..623095e8a5e --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt @@ -0,0 +1,23 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,18): error TS2304: Cannot find name 'a'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,37): error TS1005: ',' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,39): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,46): error TS1005: '=' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,53): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts (6 errors) ==== + var foo = async (a = await => await): Promise => { + ~~~~~ +!!! error TS2304: Cannot find name 'async'. + ~ +!!! error TS2304: Cannot find name 'a'. + ~ +!!! error TS1005: ',' expected. + ~~~~~~~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. + ~ +!!! error TS1005: '=' expected. + ~~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.js b/tests/baselines/reference/asyncArrowFunction9_es6.js new file mode 100644 index 00000000000..fb2f9d28a17 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es6.js @@ -0,0 +1,8 @@ +//// [asyncArrowFunction9_es6.ts] +var foo = async (a = await => await): Promise => { +} + +//// [asyncArrowFunction9_es6.js] +var foo = async(a = await => await), Promise = ; +{ +} diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt new file mode 100644 index 00000000000..6b80a53f529 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts(4,52): error TS2522: The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts (1 errors) ==== + class C { + method() { + function other() {} + var fn = async () => await other.apply(this, arguments); + ~~~~~~~~~ +!!! error TS2522: The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js new file mode 100644 index 00000000000..96926ba8f41 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js @@ -0,0 +1,16 @@ +//// [asyncArrowFunctionCapturesArguments_es6.ts] +class C { + method() { + function other() {} + var fn = async () => await other.apply(this, arguments); + } +} + + +//// [asyncArrowFunctionCapturesArguments_es6.js] +class C { + method() { + function other() { } + var fn = () => __awaiter(function *() { return yield other.apply(this, arguments); }.apply(this)); + } +} diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js new file mode 100644 index 00000000000..572c5fbe046 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js @@ -0,0 +1,14 @@ +//// [asyncArrowFunctionCapturesThis_es6.ts] +class C { + method() { + var fn = async () => await this; + } +} + + +//// [asyncArrowFunctionCapturesThis_es6.js] +class C { + method() { + var fn = () => __awaiter(function *() { return yield this; }.apply(this)); + } +} diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.symbols b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.symbols new file mode 100644 index 00000000000..ae516bb7fe3 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.symbols @@ -0,0 +1,13 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts === +class C { +>C : Symbol(C, Decl(asyncArrowFunctionCapturesThis_es6.ts, 0, 0)) + + method() { +>method : Symbol(method, Decl(asyncArrowFunctionCapturesThis_es6.ts, 0, 9)) + + var fn = async () => await this; +>fn : Symbol(fn, Decl(asyncArrowFunctionCapturesThis_es6.ts, 2, 9)) +>this : Symbol(C, Decl(asyncArrowFunctionCapturesThis_es6.ts, 0, 0)) + } +} + diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types new file mode 100644 index 00000000000..f3cd0f2d2de --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts === +class C { +>C : C + + method() { +>method : () => void + + var fn = async () => await this; +>fn : () => Promise +>async () => await this : () => Promise +>this : C + } +} + diff --git a/tests/baselines/reference/asyncClass_es6.errors.txt b/tests/baselines/reference/asyncClass_es6.errors.txt new file mode 100644 index 00000000000..ee8a3a85dbc --- /dev/null +++ b/tests/baselines/reference/asyncClass_es6.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/async/es6/asyncClass_es6.ts(1,1): error TS1042: 'async' modifier cannot be used here. + + +==== tests/cases/conformance/async/es6/asyncClass_es6.ts (1 errors) ==== + async class C { + ~~~~~ +!!! error TS1042: 'async' modifier cannot be used here. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncClass_es6.js b/tests/baselines/reference/asyncClass_es6.js new file mode 100644 index 00000000000..b5e1498f70c --- /dev/null +++ b/tests/baselines/reference/asyncClass_es6.js @@ -0,0 +1,7 @@ +//// [asyncClass_es6.ts] +async class C { +} + +//// [asyncClass_es6.js] +class C { +} diff --git a/tests/baselines/reference/asyncConstructor_es6.errors.txt b/tests/baselines/reference/asyncConstructor_es6.errors.txt new file mode 100644 index 00000000000..6eb18cf41a1 --- /dev/null +++ b/tests/baselines/reference/asyncConstructor_es6.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/async/es6/asyncConstructor_es6.ts(2,3): error TS1089: 'async' modifier cannot appear on a constructor declaration. + + +==== tests/cases/conformance/async/es6/asyncConstructor_es6.ts (1 errors) ==== + class C { + async constructor() { + ~~~~~ +!!! error TS1089: 'async' modifier cannot appear on a constructor declaration. + } + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncConstructor_es6.js b/tests/baselines/reference/asyncConstructor_es6.js new file mode 100644 index 00000000000..a0cfa7709df --- /dev/null +++ b/tests/baselines/reference/asyncConstructor_es6.js @@ -0,0 +1,11 @@ +//// [asyncConstructor_es6.ts] +class C { + async constructor() { + } +} + +//// [asyncConstructor_es6.js] +class C { + constructor() { + } +} diff --git a/tests/baselines/reference/asyncDeclare_es6.errors.txt b/tests/baselines/reference/asyncDeclare_es6.errors.txt new file mode 100644 index 00000000000..65a4068e140 --- /dev/null +++ b/tests/baselines/reference/asyncDeclare_es6.errors.txt @@ -0,0 +1,7 @@ +tests/cases/conformance/async/es6/asyncDeclare_es6.ts(1,9): error TS1040: 'async' modifier cannot be used in an ambient context. + + +==== tests/cases/conformance/async/es6/asyncDeclare_es6.ts (1 errors) ==== + declare async function foo(): Promise; + ~~~~~ +!!! error TS1040: 'async' modifier cannot be used in an ambient context. \ No newline at end of file diff --git a/tests/baselines/reference/asyncDeclare_es6.js b/tests/baselines/reference/asyncDeclare_es6.js new file mode 100644 index 00000000000..096f43a248a --- /dev/null +++ b/tests/baselines/reference/asyncDeclare_es6.js @@ -0,0 +1,4 @@ +//// [asyncDeclare_es6.ts] +declare async function foo(): Promise; + +//// [asyncDeclare_es6.js] diff --git a/tests/baselines/reference/asyncEnum_es6.errors.txt b/tests/baselines/reference/asyncEnum_es6.errors.txt new file mode 100644 index 00000000000..a50853fd8ea --- /dev/null +++ b/tests/baselines/reference/asyncEnum_es6.errors.txt @@ -0,0 +1,9 @@ +tests/cases/conformance/async/es6/asyncEnum_es6.ts(1,1): error TS1042: 'async' modifier cannot be used here. + + +==== tests/cases/conformance/async/es6/asyncEnum_es6.ts (1 errors) ==== + async enum E { + ~~~~~ +!!! error TS1042: 'async' modifier cannot be used here. + Value + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncEnum_es6.js b/tests/baselines/reference/asyncEnum_es6.js new file mode 100644 index 00000000000..074de3dd0ae --- /dev/null +++ b/tests/baselines/reference/asyncEnum_es6.js @@ -0,0 +1,10 @@ +//// [asyncEnum_es6.ts] +async enum E { + Value +} + +//// [asyncEnum_es6.js] +var E; +(function (E) { + E[E["Value"] = 0] = "Value"; +})(E || (E = {})); diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt new file mode 100644 index 00000000000..15ceb3e60c7 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt @@ -0,0 +1,26 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,20): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,30): error TS1109: Expression expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS1138: Parameter declaration expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,38): error TS1005: ';' expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,39): error TS1128: Declaration or statement expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,53): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts (7 errors) ==== + async function foo(a = await => await): Promise { + ~~~~~~~~~ +!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. + ~~ +!!! error TS1109: Expression expected. + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2304: Cannot find name 'await'. + ~ +!!! error TS1005: ';' expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js new file mode 100644 index 00000000000..141c0cbab55 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js @@ -0,0 +1,7 @@ +//// [asyncFunctionDeclaration10_es6.ts] +async function foo(a = await => await): Promise { +} + +//// [asyncFunctionDeclaration10_es6.js] +await; +Promise < void > {}; diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js new file mode 100644 index 00000000000..39bf2c20e79 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js @@ -0,0 +1,9 @@ +//// [asyncFunctionDeclaration11_es6.ts] +async function await(): Promise { +} + +//// [asyncFunctionDeclaration11_es6.js] +function await() { + return __awaiter(function *() { + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols new file mode 100644 index 00000000000..b4320296373 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts === +async function await(): Promise { +>await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.types b/tests/baselines/reference/asyncFunctionDeclaration11_es6.types new file mode 100644 index 00000000000..65896e7b3b5 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts === +async function await(): Promise { +>await : () => Promise +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt new file mode 100644 index 00000000000..978492f0744 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt @@ -0,0 +1,16 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,24): error TS1005: '(' expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,29): error TS1005: '=' expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,33): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,47): error TS1005: '=>' expected. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts (4 errors) ==== + var v = async function await(): Promise { } + ~~~~~ +!!! error TS1005: '(' expected. + ~ +!!! error TS1005: '=' expected. + ~~~~~~~~~~~~~ +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. + ~ +!!! error TS1005: '=>' expected. \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.js b/tests/baselines/reference/asyncFunctionDeclaration12_es6.js new file mode 100644 index 00000000000..dae33682ce6 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.js @@ -0,0 +1,5 @@ +//// [asyncFunctionDeclaration12_es6.ts] +var v = async function await(): Promise { } + +//// [asyncFunctionDeclaration12_es6.js] +var v = , await = () => { }; diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration13_es6.errors.txt new file mode 100644 index 00000000000..6cf65ca4e3a --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.errors.txt @@ -0,0 +1,11 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts(3,11): error TS2304: Cannot find name 'await'. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts (1 errors) ==== + async function foo(): Promise { + // Legal to use 'await' in a type context. + var v: await; + ~~~~~ +!!! error TS2304: Cannot find name 'await'. + } + \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js new file mode 100644 index 00000000000..9666fb5d7c4 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js @@ -0,0 +1,14 @@ +//// [asyncFunctionDeclaration13_es6.ts] +async function foo(): Promise { + // Legal to use 'await' in a type context. + var v: await; +} + + +//// [asyncFunctionDeclaration13_es6.js] +function foo() { + return __awaiter(function *() { + // Legal to use 'await' in a type context. + var v; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js new file mode 100644 index 00000000000..2f694f02696 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js @@ -0,0 +1,11 @@ +//// [asyncFunctionDeclaration14_es6.ts] +async function foo(): Promise { + return; +} + +//// [asyncFunctionDeclaration14_es6.js] +function foo() { + return __awaiter(function *() { + return; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols new file mode 100644 index 00000000000..5354c67a195 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts === +async function foo(): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + return; +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.types b/tests/baselines/reference/asyncFunctionDeclaration14_es6.types new file mode 100644 index 00000000000..7727ffafaeb --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts === +async function foo(): Promise { +>foo : () => Promise +>Promise : Promise + + return; +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js new file mode 100644 index 00000000000..75cb74a68a5 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js @@ -0,0 +1,9 @@ +//// [asyncFunctionDeclaration1_es6.ts] +async function foo(): Promise { +} + +//// [asyncFunctionDeclaration1_es6.js] +function foo() { + return __awaiter(function *() { + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols new file mode 100644 index 00000000000..241290a4899 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts === +async function foo(): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.types b/tests/baselines/reference/asyncFunctionDeclaration1_es6.types new file mode 100644 index 00000000000..5cba25724f0 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts === +async function foo(): Promise { +>foo : () => Promise +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration2_es6.js b/tests/baselines/reference/asyncFunctionDeclaration2_es6.js new file mode 100644 index 00000000000..1c54b9bc056 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration2_es6.js @@ -0,0 +1,7 @@ +//// [asyncFunctionDeclaration2_es6.ts] +function f(await) { +} + +//// [asyncFunctionDeclaration2_es6.js] +function f(await) { +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration2_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration2_es6.symbols new file mode 100644 index 00000000000..c709d7f7386 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration2_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts === +function f(await) { +>f : Symbol(f, Decl(asyncFunctionDeclaration2_es6.ts, 0, 0)) +>await : Symbol(await, Decl(asyncFunctionDeclaration2_es6.ts, 0, 11)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration2_es6.types b/tests/baselines/reference/asyncFunctionDeclaration2_es6.types new file mode 100644 index 00000000000..9c9a19f3e76 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration2_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts === +function f(await) { +>f : (await: any) => void +>await : any +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration3_es6.errors.txt new file mode 100644 index 00000000000..a480bf3d2b8 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration3_es6.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts(1,20): error TS2372: Parameter 'await' cannot be referenced in its initializer. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts (1 errors) ==== + function f(await = await) { + ~~~~~ +!!! error TS2372: Parameter 'await' cannot be referenced in its initializer. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es6.js b/tests/baselines/reference/asyncFunctionDeclaration3_es6.js new file mode 100644 index 00000000000..7038858d2c8 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration3_es6.js @@ -0,0 +1,7 @@ +//// [asyncFunctionDeclaration3_es6.ts] +function f(await = await) { +} + +//// [asyncFunctionDeclaration3_es6.js] +function f(await = await) { +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration4_es6.js b/tests/baselines/reference/asyncFunctionDeclaration4_es6.js new file mode 100644 index 00000000000..8bfb7bf642f --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration4_es6.js @@ -0,0 +1,7 @@ +//// [asyncFunctionDeclaration4_es6.ts] +function await() { +} + +//// [asyncFunctionDeclaration4_es6.js] +function await() { +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration4_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration4_es6.symbols new file mode 100644 index 00000000000..cdbe1f5a8db --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration4_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts === +function await() { +>await : Symbol(await, Decl(asyncFunctionDeclaration4_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration4_es6.types b/tests/baselines/reference/asyncFunctionDeclaration4_es6.types new file mode 100644 index 00000000000..537661e2c66 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration4_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts === +function await() { +>await : () => void +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt new file mode 100644 index 00000000000..a6944e0c6e6 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt @@ -0,0 +1,20 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,20): error TS1138: Parameter declaration expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,20): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,25): error TS1005: ';' expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,26): error TS1128: Declaration or statement expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,40): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts (5 errors) ==== + async function foo(await): Promise { + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2304: Cannot find name 'await'. + ~ +!!! error TS1005: ';' expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es6.js b/tests/baselines/reference/asyncFunctionDeclaration5_es6.js new file mode 100644 index 00000000000..8d28c371465 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration5_es6.js @@ -0,0 +1,7 @@ +//// [asyncFunctionDeclaration5_es6.ts] +async function foo(await): Promise { +} + +//// [asyncFunctionDeclaration5_es6.js] +await; +Promise < void > {}; diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt new file mode 100644 index 00000000000..e719ed801e6 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts(1,29): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts (1 errors) ==== + async function foo(a = await): Promise { + ~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js new file mode 100644 index 00000000000..2a3ffaa94dd --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js @@ -0,0 +1,9 @@ +//// [asyncFunctionDeclaration6_es6.ts] +async function foo(a = await): Promise { +} + +//// [asyncFunctionDeclaration6_es6.js] +function foo() { + return __awaiter(function *(a = yield ) { + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt new file mode 100644 index 00000000000..01643ffcdbb --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt @@ -0,0 +1,11 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts(3,31): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts (1 errors) ==== + async function bar(): Promise { + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { + ~ +!!! error TS1109: Expression expected. + } + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js new file mode 100644 index 00000000000..c22870b08fe --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js @@ -0,0 +1,17 @@ +//// [asyncFunctionDeclaration7_es6.ts] +async function bar(): Promise { + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { + } +} + +//// [asyncFunctionDeclaration7_es6.js] +function bar() { + return __awaiter(function *() { + // 'await' here is an identifier, and not a yield expression. + function foo() { + return __awaiter(function *(a = yield ) { + }.apply(this, arguments), Promise); + } + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration8_es6.errors.txt new file mode 100644 index 00000000000..c785ae41b17 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration8_es6.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts(1,12): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts(1,20): error TS2304: Cannot find name 'foo'. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts (2 errors) ==== + var v = { [await]: foo } + ~~~~~ +!!! error TS2304: Cannot find name 'await'. + ~~~ +!!! error TS2304: Cannot find name 'foo'. \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es6.js b/tests/baselines/reference/asyncFunctionDeclaration8_es6.js new file mode 100644 index 00000000000..a363015f8ab --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration8_es6.js @@ -0,0 +1,5 @@ +//// [asyncFunctionDeclaration8_es6.ts] +var v = { [await]: foo } + +//// [asyncFunctionDeclaration8_es6.js] +var v = { [await]: foo }; diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration9_es6.errors.txt new file mode 100644 index 00000000000..235ef165bed --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.errors.txt @@ -0,0 +1,9 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts(2,19): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts (1 errors) ==== + async function foo(): Promise { + var v = { [await]: foo } + ~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js new file mode 100644 index 00000000000..8b5ea4c4b5c --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js @@ -0,0 +1,11 @@ +//// [asyncFunctionDeclaration9_es6.ts] +async function foo(): Promise { + var v = { [await]: foo } +} + +//// [asyncFunctionDeclaration9_es6.js] +function foo() { + return __awaiter(function *() { + var v = { [yield ]: foo }; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/asyncGetter_es6.errors.txt b/tests/baselines/reference/asyncGetter_es6.errors.txt new file mode 100644 index 00000000000..5f5a9f6b1d7 --- /dev/null +++ b/tests/baselines/reference/asyncGetter_es6.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,3): error TS1042: 'async' modifier cannot be used here. +tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,13): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. + + +==== tests/cases/conformance/async/es6/asyncGetter_es6.ts (2 errors) ==== + class C { + async get foo() { + ~~~~~ +!!! error TS1042: 'async' modifier cannot be used here. + ~~~ +!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. + } + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncGetter_es6.js b/tests/baselines/reference/asyncGetter_es6.js new file mode 100644 index 00000000000..606f4d95dc7 --- /dev/null +++ b/tests/baselines/reference/asyncGetter_es6.js @@ -0,0 +1,11 @@ +//// [asyncGetter_es6.ts] +class C { + async get foo() { + } +} + +//// [asyncGetter_es6.js] +class C { + get foo() { + } +} diff --git a/tests/baselines/reference/asyncInterface_es6.errors.txt b/tests/baselines/reference/asyncInterface_es6.errors.txt new file mode 100644 index 00000000000..c7519ba040e --- /dev/null +++ b/tests/baselines/reference/asyncInterface_es6.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/async/es6/asyncInterface_es6.ts(1,1): error TS1042: 'async' modifier cannot be used here. + + +==== tests/cases/conformance/async/es6/asyncInterface_es6.ts (1 errors) ==== + async interface I { + ~~~~~ +!!! error TS1042: 'async' modifier cannot be used here. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncInterface_es6.js b/tests/baselines/reference/asyncInterface_es6.js new file mode 100644 index 00000000000..36314fa2141 --- /dev/null +++ b/tests/baselines/reference/asyncInterface_es6.js @@ -0,0 +1,5 @@ +//// [asyncInterface_es6.ts] +async interface I { +} + +//// [asyncInterface_es6.js] diff --git a/tests/baselines/reference/asyncModule_es6.errors.txt b/tests/baselines/reference/asyncModule_es6.errors.txt new file mode 100644 index 00000000000..91e5e8ccdd3 --- /dev/null +++ b/tests/baselines/reference/asyncModule_es6.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/async/es6/asyncModule_es6.ts(1,1): error TS1042: 'async' modifier cannot be used here. + + +==== tests/cases/conformance/async/es6/asyncModule_es6.ts (1 errors) ==== + async module M { + ~~~~~ +!!! error TS1042: 'async' modifier cannot be used here. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncModule_es6.js b/tests/baselines/reference/asyncModule_es6.js new file mode 100644 index 00000000000..e3e9306dbcb --- /dev/null +++ b/tests/baselines/reference/asyncModule_es6.js @@ -0,0 +1,5 @@ +//// [asyncModule_es6.ts] +async module M { +} + +//// [asyncModule_es6.js] diff --git a/tests/baselines/reference/asyncSetter_es6.errors.txt b/tests/baselines/reference/asyncSetter_es6.errors.txt new file mode 100644 index 00000000000..e60e05cbc55 --- /dev/null +++ b/tests/baselines/reference/asyncSetter_es6.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/async/es6/asyncSetter_es6.ts(2,3): error TS1042: 'async' modifier cannot be used here. + + +==== tests/cases/conformance/async/es6/asyncSetter_es6.ts (1 errors) ==== + class C { + async set foo(value) { + ~~~~~ +!!! error TS1042: 'async' modifier cannot be used here. + } + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncSetter_es6.js b/tests/baselines/reference/asyncSetter_es6.js new file mode 100644 index 00000000000..303e483f9a9 --- /dev/null +++ b/tests/baselines/reference/asyncSetter_es6.js @@ -0,0 +1,11 @@ +//// [asyncSetter_es6.ts] +class C { + async set foo(value) { + } +} + +//// [asyncSetter_es6.js] +class C { + set foo(value) { + } +} diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.js b/tests/baselines/reference/awaitBinaryExpression1_es6.js new file mode 100644 index 00000000000..f92324dcdac --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.js @@ -0,0 +1,17 @@ +//// [awaitBinaryExpression1_es6.ts] +declare var a: boolean; +declare var p: Promise; +async function func(): Promise { + "before"; + var b = await p || a; + "after"; +} + +//// [awaitBinaryExpression1_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = (yield p) || a; + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols new file mode 100644 index 00000000000..373086ecbac --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitBinaryExpression1_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = await p || a; +>b : Symbol(b, Decl(awaitBinaryExpression1_es6.ts, 4, 7)) +>a : Symbol(a, Decl(awaitBinaryExpression1_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.types b/tests/baselines/reference/awaitBinaryExpression1_es6.types new file mode 100644 index 00000000000..59370dda14b --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.types @@ -0,0 +1,24 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = await p || a; +>b : boolean +>await p || a : boolean +>p : any +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.js b/tests/baselines/reference/awaitBinaryExpression2_es6.js new file mode 100644 index 00000000000..e2d3b3ba46f --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.js @@ -0,0 +1,17 @@ +//// [awaitBinaryExpression2_es6.ts] +declare var a: boolean; +declare var p: Promise; +async function func(): Promise { + "before"; + var b = await p && a; + "after"; +} + +//// [awaitBinaryExpression2_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = (yield p) && a; + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols new file mode 100644 index 00000000000..9331ad13ce5 --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitBinaryExpression2_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = await p && a; +>b : Symbol(b, Decl(awaitBinaryExpression2_es6.ts, 4, 7)) +>a : Symbol(a, Decl(awaitBinaryExpression2_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.types b/tests/baselines/reference/awaitBinaryExpression2_es6.types new file mode 100644 index 00000000000..c3f33bca2fa --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.types @@ -0,0 +1,24 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = await p && a; +>b : boolean +>await p && a : boolean +>p : any +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.js b/tests/baselines/reference/awaitBinaryExpression3_es6.js new file mode 100644 index 00000000000..08e98d5dafe --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.js @@ -0,0 +1,17 @@ +//// [awaitBinaryExpression3_es6.ts] +declare var a: number; +declare var p: Promise; +async function func(): Promise { + "before"; + var b = await p + a; + "after"; +} + +//// [awaitBinaryExpression3_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = (yield p) + a; + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols new file mode 100644 index 00000000000..b1acda70136 --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts === +declare var a: number; +>a : Symbol(a, Decl(awaitBinaryExpression3_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = await p + a; +>b : Symbol(b, Decl(awaitBinaryExpression3_es6.ts, 4, 7)) +>a : Symbol(a, Decl(awaitBinaryExpression3_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.types b/tests/baselines/reference/awaitBinaryExpression3_es6.types new file mode 100644 index 00000000000..786eabadae4 --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.types @@ -0,0 +1,24 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts === +declare var a: number; +>a : number + +declare var p: Promise; +>p : Promise +>Promise : Promise + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = await p + a; +>b : number +>await p + a : number +>p : any +>a : number + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.js b/tests/baselines/reference/awaitBinaryExpression4_es6.js new file mode 100644 index 00000000000..0eec5e990a5 --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.js @@ -0,0 +1,17 @@ +//// [awaitBinaryExpression4_es6.ts] +declare var a: boolean; +declare var p: Promise; +async function func(): Promise { + "before"; + var b = await p, a; + "after"; +} + +//// [awaitBinaryExpression4_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = yield p, a; + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols new file mode 100644 index 00000000000..c1a3bd903f4 --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitBinaryExpression4_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = await p, a; +>b : Symbol(b, Decl(awaitBinaryExpression4_es6.ts, 4, 7)) +>a : Symbol(a, Decl(awaitBinaryExpression4_es6.ts, 4, 20)) + + "after"; +} diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.types b/tests/baselines/reference/awaitBinaryExpression4_es6.types new file mode 100644 index 00000000000..73126b7797d --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.types @@ -0,0 +1,23 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = await p, a; +>b : boolean +>p : any +>a : any + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.js b/tests/baselines/reference/awaitBinaryExpression5_es6.js new file mode 100644 index 00000000000..d725d55404a --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.js @@ -0,0 +1,19 @@ +//// [awaitBinaryExpression5_es6.ts] +declare var a: boolean; +declare var p: Promise; +async function func(): Promise { + "before"; + var o: { a: boolean; }; + o.a = await p; + "after"; +} + +//// [awaitBinaryExpression5_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var o; + o.a = yield p; + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols new file mode 100644 index 00000000000..cb74dcff7f6 --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var o: { a: boolean; }; +>o : Symbol(o, Decl(awaitBinaryExpression5_es6.ts, 4, 7)) +>a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12)) + + o.a = await p; +>o.a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12)) +>o : Symbol(o, Decl(awaitBinaryExpression5_es6.ts, 4, 7)) +>a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12)) + + "after"; +} diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.types b/tests/baselines/reference/awaitBinaryExpression5_es6.types new file mode 100644 index 00000000000..922e5887a77 --- /dev/null +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.types @@ -0,0 +1,29 @@ +=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var o: { a: boolean; }; +>o : { a: boolean; } +>a : boolean + + o.a = await p; +>o.a = await p : boolean +>o.a : boolean +>o : { a: boolean; } +>a : boolean +>p : any + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitCallExpression1_es6.js b/tests/baselines/reference/awaitCallExpression1_es6.js new file mode 100644 index 00000000000..3391274ae7a --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression1_es6.js @@ -0,0 +1,21 @@ +//// [awaitCallExpression1_es6.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = fn(a, a, a); + "after"; +} + +//// [awaitCallExpression1_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = fn(a, a, a); + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols new file mode 100644 index 00000000000..f9756da1768 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols @@ -0,0 +1,50 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression1_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression1_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 5, 58)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = fn(a, a, a); +>b : Symbol(b, Decl(awaitCallExpression1_es6.ts, 8, 7)) +>fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32)) +>a : Symbol(a, Decl(awaitCallExpression1_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression1_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression1_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitCallExpression1_es6.types b/tests/baselines/reference/awaitCallExpression1_es6.types new file mode 100644 index 00000000000..334175b7edb --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression1_es6.types @@ -0,0 +1,54 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = fn(a, a, a); +>b : void +>fn(a, a, a) : void +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>a : boolean +>a : boolean +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitCallExpression2_es6.js b/tests/baselines/reference/awaitCallExpression2_es6.js new file mode 100644 index 00000000000..fd7129e8418 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression2_es6.js @@ -0,0 +1,21 @@ +//// [awaitCallExpression2_es6.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = fn(await p, a, a); + "after"; +} + +//// [awaitCallExpression2_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = fn(yield p, a, a); + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols new file mode 100644 index 00000000000..2e5b8761163 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression2_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 5, 58)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = fn(await p, a, a); +>b : Symbol(b, Decl(awaitCallExpression2_es6.ts, 8, 7)) +>fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32)) +>a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitCallExpression2_es6.types b/tests/baselines/reference/awaitCallExpression2_es6.types new file mode 100644 index 00000000000..6c7f02a578a --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression2_es6.types @@ -0,0 +1,54 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = fn(await p, a, a); +>b : void +>fn(await p, a, a) : void +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>p : any +>a : boolean +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitCallExpression3_es6.js b/tests/baselines/reference/awaitCallExpression3_es6.js new file mode 100644 index 00000000000..4f0d55185e2 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression3_es6.js @@ -0,0 +1,21 @@ +//// [awaitCallExpression3_es6.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = fn(a, await p, a); + "after"; +} + +//// [awaitCallExpression3_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = fn(a, yield p, a); + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols new file mode 100644 index 00000000000..331fbeb8e6e --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression3_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 5, 58)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = fn(a, await p, a); +>b : Symbol(b, Decl(awaitCallExpression3_es6.ts, 8, 7)) +>fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32)) +>a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitCallExpression3_es6.types b/tests/baselines/reference/awaitCallExpression3_es6.types new file mode 100644 index 00000000000..24d22db3c8c --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression3_es6.types @@ -0,0 +1,54 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = fn(a, await p, a); +>b : void +>fn(a, await p, a) : void +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>a : boolean +>p : any +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitCallExpression4_es6.js b/tests/baselines/reference/awaitCallExpression4_es6.js new file mode 100644 index 00000000000..7ec6c6ff90e --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression4_es6.js @@ -0,0 +1,21 @@ +//// [awaitCallExpression4_es6.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = (await pfn)(a, a, a); + "after"; +} + +//// [awaitCallExpression4_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = (yield pfn)(a, a, a); + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols new file mode 100644 index 00000000000..cc3407610b7 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression4_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 5, 58)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = (await pfn)(a, a, a); +>b : Symbol(b, Decl(awaitCallExpression4_es6.ts, 8, 7)) +>a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitCallExpression4_es6.types b/tests/baselines/reference/awaitCallExpression4_es6.types new file mode 100644 index 00000000000..04115466427 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression4_es6.types @@ -0,0 +1,55 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = (await pfn)(a, a, a); +>b : void +>(await pfn)(a, a, a) : void +>(await pfn) : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>pfn : any +>a : boolean +>a : boolean +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitCallExpression5_es6.js b/tests/baselines/reference/awaitCallExpression5_es6.js new file mode 100644 index 00000000000..f41d0ae994f --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression5_es6.js @@ -0,0 +1,21 @@ +//// [awaitCallExpression5_es6.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = o.fn(a, a, a); + "after"; +} + +//// [awaitCallExpression5_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = o.fn(a, a, a); + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols new file mode 100644 index 00000000000..0063434d0fb --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols @@ -0,0 +1,52 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression5_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression5_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 5, 58)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = o.fn(a, a, a); +>b : Symbol(b, Decl(awaitCallExpression5_es6.ts, 8, 7)) +>o.fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 3, 16)) +>o : Symbol(o, Decl(awaitCallExpression5_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 3, 16)) +>a : Symbol(a, Decl(awaitCallExpression5_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression5_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression5_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitCallExpression5_es6.types b/tests/baselines/reference/awaitCallExpression5_es6.types new file mode 100644 index 00000000000..5074c007743 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression5_es6.types @@ -0,0 +1,56 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = o.fn(a, a, a); +>b : void +>o.fn(a, a, a) : void +>o.fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>a : boolean +>a : boolean +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitCallExpression6_es6.js b/tests/baselines/reference/awaitCallExpression6_es6.js new file mode 100644 index 00000000000..d6c0e370748 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression6_es6.js @@ -0,0 +1,21 @@ +//// [awaitCallExpression6_es6.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = o.fn(await p, a, a); + "after"; +} + +//// [awaitCallExpression6_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = o.fn(yield p, a, a); + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols new file mode 100644 index 00000000000..9f99f55f26c --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression6_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 5, 58)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = o.fn(await p, a, a); +>b : Symbol(b, Decl(awaitCallExpression6_es6.ts, 8, 7)) +>o.fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16)) +>o : Symbol(o, Decl(awaitCallExpression6_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16)) +>a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitCallExpression6_es6.types b/tests/baselines/reference/awaitCallExpression6_es6.types new file mode 100644 index 00000000000..d18377cebbb --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression6_es6.types @@ -0,0 +1,56 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = o.fn(await p, a, a); +>b : void +>o.fn(await p, a, a) : void +>o.fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>p : any +>a : boolean +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitCallExpression7_es6.js b/tests/baselines/reference/awaitCallExpression7_es6.js new file mode 100644 index 00000000000..45e8a9fa646 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression7_es6.js @@ -0,0 +1,21 @@ +//// [awaitCallExpression7_es6.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = o.fn(a, await p, a); + "after"; +} + +//// [awaitCallExpression7_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = o.fn(a, yield p, a); + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols new file mode 100644 index 00000000000..d9dd6535bc2 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression7_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 5, 58)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = o.fn(a, await p, a); +>b : Symbol(b, Decl(awaitCallExpression7_es6.ts, 8, 7)) +>o.fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 3, 16)) +>o : Symbol(o, Decl(awaitCallExpression7_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 3, 16)) +>a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitCallExpression7_es6.types b/tests/baselines/reference/awaitCallExpression7_es6.types new file mode 100644 index 00000000000..b213a75dcd6 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression7_es6.types @@ -0,0 +1,56 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = o.fn(a, await p, a); +>b : void +>o.fn(a, await p, a) : void +>o.fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>a : boolean +>p : any +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/awaitCallExpression8_es6.js b/tests/baselines/reference/awaitCallExpression8_es6.js new file mode 100644 index 00000000000..3ffac0006ae --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression8_es6.js @@ -0,0 +1,21 @@ +//// [awaitCallExpression8_es6.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = (await po).fn(a, a, a); + "after"; +} + +//// [awaitCallExpression8_es6.js] +function func() { + return __awaiter(function *() { + "before"; + var b = (yield po).fn(a, a, a); + "after"; + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols new file mode 100644 index 00000000000..1a2097d041d --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression8_es6.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 5, 58)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) + + "before"; + var b = (await po).fn(a, a, a); +>b : Symbol(b, Decl(awaitCallExpression8_es6.ts, 8, 7)) +>(await po).fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) +>fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) +>a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11)) + + "after"; +} diff --git a/tests/baselines/reference/awaitCallExpression8_es6.types b/tests/baselines/reference/awaitCallExpression8_es6.types new file mode 100644 index 00000000000..37511a7e3d7 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression8_es6.types @@ -0,0 +1,57 @@ +=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + "before"; +>"before" : string + + var b = (await po).fn(a, a, a); +>b : void +>(await po).fn(a, a, a) : void +>(await po).fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>(await po) : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>po : any +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>a : boolean +>a : boolean +>a : boolean + + "after"; +>"after" : string +} diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols index 94e0b94b002..c29c41bff20 100644 --- a/tests/baselines/reference/callWithSpreadES6.symbols +++ b/tests/baselines/reference/callWithSpreadES6.symbols @@ -94,7 +94,7 @@ xa[1].foo(1, 2, ...a, "abc"); >a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) (xa[1].foo)(...[1, 2, "abc"]); ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 1355, 1)) +>Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 1366, 1)) >xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) >xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols index 033ad46ece1..6a4eb82af97 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols @@ -8,18 +8,18 @@ type arrayString = Array >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) type someArray = Array | number[]; >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) type stringOrNumArray = Array; >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) function a1(...x: (number|string)[]) { } @@ -33,8 +33,8 @@ function a2(...a) { } function a3(...a: Array) { } >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) function a4(...a: arrayString) { } >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols index d23b624a023..22340c6aa60 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols @@ -8,18 +8,18 @@ type arrayString = Array >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) type someArray = Array | number[]; >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) type stringOrNumArray = Array; >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) function a1(...x: (number|string)[]) { } @@ -33,8 +33,8 @@ function a2(...a) { } function a3(...a: Array) { } >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) function a4(...a: arrayString) { } >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols index 18e1063f1e6..611db6485b9 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols @@ -5,7 +5,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) let arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols index 6885b359416..7a3c2620424 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols @@ -8,7 +8,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) const arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols index ae6be6f7951..c9658b4d90d 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols @@ -8,7 +8,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments[0]; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols index c8bf211897a..df5ab202dfc 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols @@ -9,7 +9,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments[0]; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols index cc867dd2c72..c4fc2e434e8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols @@ -9,7 +9,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments; diff --git a/tests/baselines/reference/for-of13.symbols b/tests/baselines/reference/for-of13.symbols index 833ea1d6875..bcd19f1a4d4 100644 --- a/tests/baselines/reference/for-of13.symbols +++ b/tests/baselines/reference/for-of13.symbols @@ -4,6 +4,6 @@ var v: string; for (v of [""].values()) { } >v : Symbol(v, Decl(for-of13.ts, 0, 3)) ->[""].values : Symbol(Array.values, Decl(lib.d.ts, 1453, 37)) ->values : Symbol(Array.values, Decl(lib.d.ts, 1453, 37)) +>[""].values : Symbol(Array.values, Decl(lib.d.ts, 1464, 37)) +>values : Symbol(Array.values, Decl(lib.d.ts, 1464, 37)) diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols index 2c08338ce73..a61af492538 100644 --- a/tests/baselines/reference/for-of18.symbols +++ b/tests/baselines/reference/for-of18.symbols @@ -22,9 +22,9 @@ class StringIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(StringIterator, Decl(for-of18.ts, 1, 33)) diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols index 6be3c83964a..c2d2d078415 100644 --- a/tests/baselines/reference/for-of19.symbols +++ b/tests/baselines/reference/for-of19.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(for-of19.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols index 97200f93f35..251a5b28fca 100644 --- a/tests/baselines/reference/for-of20.symbols +++ b/tests/baselines/reference/for-of20.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(for-of20.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols index bbe3504294c..0b6b6f23cc0 100644 --- a/tests/baselines/reference/for-of21.symbols +++ b/tests/baselines/reference/for-of21.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(for-of21.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols index 4f15b541356..cc4fcf55a7c 100644 --- a/tests/baselines/reference/for-of22.symbols +++ b/tests/baselines/reference/for-of22.symbols @@ -28,9 +28,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(for-of22.ts, 5, 13)) diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols index 0f409605e28..8c7455a2dbc 100644 --- a/tests/baselines/reference/for-of23.symbols +++ b/tests/baselines/reference/for-of23.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(for-of23.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of25.symbols b/tests/baselines/reference/for-of25.symbols index 44cc83143af..dae7d4bae7f 100644 --- a/tests/baselines/reference/for-of25.symbols +++ b/tests/baselines/reference/for-of25.symbols @@ -10,9 +10,9 @@ class StringIterator { >StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 1, 37)) [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return x; >x : Symbol(x, Decl(for-of25.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of26.symbols b/tests/baselines/reference/for-of26.symbols index 0218a8b9995..34766b1bc8c 100644 --- a/tests/baselines/reference/for-of26.symbols +++ b/tests/baselines/reference/for-of26.symbols @@ -16,9 +16,9 @@ class StringIterator { >x : Symbol(x, Decl(for-of26.ts, 0, 3)) } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(StringIterator, Decl(for-of26.ts, 1, 37)) diff --git a/tests/baselines/reference/for-of27.symbols b/tests/baselines/reference/for-of27.symbols index 82918a19986..aa44808cd73 100644 --- a/tests/baselines/reference/for-of27.symbols +++ b/tests/baselines/reference/for-of27.symbols @@ -7,7 +7,7 @@ class StringIterator { >StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 37)) [Symbol.iterator]: any; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) } diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols index e4324b05779..caf0356df22 100644 --- a/tests/baselines/reference/for-of28.symbols +++ b/tests/baselines/reference/for-of28.symbols @@ -10,9 +10,9 @@ class StringIterator { >next : Symbol(next, Decl(for-of28.ts, 2, 22)) [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(StringIterator, Decl(for-of28.ts, 0, 37)) diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols index 93f6c4f7dd6..73455ff17e6 100644 --- a/tests/baselines/reference/for-of37.symbols +++ b/tests/baselines/reference/for-of37.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of37.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of37.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) for (var v of map) { >v : Symbol(v, Decl(for-of37.ts, 1, 8)) diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols index fab42d91724..bfbe035730c 100644 --- a/tests/baselines/reference/for-of38.symbols +++ b/tests/baselines/reference/for-of38.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of38.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of38.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) for (var [k, v] of map) { >k : Symbol(k, Decl(for-of38.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols index 1cd3538f987..ed6ecb128f7 100644 --- a/tests/baselines/reference/for-of40.symbols +++ b/tests/baselines/reference/for-of40.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of40.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of40.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) for (var [k = "", v = false] of map) { >k : Symbol(k, Decl(for-of40.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of44.symbols b/tests/baselines/reference/for-of44.symbols index 9c6afa04adb..adcd2ae3760 100644 --- a/tests/baselines/reference/for-of44.symbols +++ b/tests/baselines/reference/for-of44.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of44.ts === var array: [number, string | boolean | symbol][] = [[0, ""], [0, true], [1, Symbol()]] >array : Symbol(array, Decl(for-of44.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) for (var [num, strBoolSym] of array) { >num : Symbol(num, Decl(for-of44.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols index 9fda4cb4e0a..2f4a8511147 100644 --- a/tests/baselines/reference/for-of45.symbols +++ b/tests/baselines/reference/for-of45.symbols @@ -5,7 +5,7 @@ var k: string, v: boolean; var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of45.ts, 1, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) for ([k = "", v = false] of map) { >k : Symbol(k, Decl(for-of45.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols index c176e1aca0c..6813cd4eee5 100644 --- a/tests/baselines/reference/for-of50.symbols +++ b/tests/baselines/reference/for-of50.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of50.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of50.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) for (const [k, v] of map) { >k : Symbol(k, Decl(for-of50.ts, 1, 12)) diff --git a/tests/baselines/reference/for-of57.symbols b/tests/baselines/reference/for-of57.symbols index 27aed0777ba..e8be8da6f9c 100644 --- a/tests/baselines/reference/for-of57.symbols +++ b/tests/baselines/reference/for-of57.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of57.ts === var iter: Iterable; >iter : Symbol(iter, Decl(for-of57.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1663, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1)) for (let num of iter) { } >num : Symbol(num, Decl(for-of57.ts, 1, 8)) diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols index c6025123179..02f2ad6e8ef 100644 --- a/tests/baselines/reference/iterableArrayPattern1.symbols +++ b/tests/baselines/reference/iterableArrayPattern1.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iterableArrayPattern1.ts, 3, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iterableArrayPattern1.ts, 4, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iterableArrayPattern1.ts, 0, 32)) diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols index 07b1fb52af8..9bbe4bfb983 100644 --- a/tests/baselines/reference/iterableArrayPattern11.symbols +++ b/tests/baselines/reference/iterableArrayPattern11.symbols @@ -36,9 +36,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern11.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols index 001cb99b486..1a8634862ea 100644 --- a/tests/baselines/reference/iterableArrayPattern12.symbols +++ b/tests/baselines/reference/iterableArrayPattern12.symbols @@ -36,9 +36,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern12.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols index 7085fd224f4..3c8a8c1ba52 100644 --- a/tests/baselines/reference/iterableArrayPattern13.symbols +++ b/tests/baselines/reference/iterableArrayPattern13.symbols @@ -35,9 +35,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern13.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols index 09a6984cb3c..a28e682c9ed 100644 --- a/tests/baselines/reference/iterableArrayPattern2.symbols +++ b/tests/baselines/reference/iterableArrayPattern2.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iterableArrayPattern2.ts, 3, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iterableArrayPattern2.ts, 4, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iterableArrayPattern2.ts, 0, 35)) diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols index 4ee65a10825..46087c2f8bb 100644 --- a/tests/baselines/reference/iterableArrayPattern3.symbols +++ b/tests/baselines/reference/iterableArrayPattern3.symbols @@ -37,9 +37,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern3.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols index 0f50713b43d..e4c5de17704 100644 --- a/tests/baselines/reference/iterableArrayPattern30.symbols +++ b/tests/baselines/reference/iterableArrayPattern30.symbols @@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]) >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11)) >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18)) >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21)) ->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols index aa5ce5783a0..2b0c26918e4 100644 --- a/tests/baselines/reference/iterableArrayPattern4.symbols +++ b/tests/baselines/reference/iterableArrayPattern4.symbols @@ -37,9 +37,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern4.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols index 01cfba0f09e..90adcfeba92 100644 --- a/tests/baselines/reference/iterableArrayPattern9.symbols +++ b/tests/baselines/reference/iterableArrayPattern9.symbols @@ -32,9 +32,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern9.ts, 2, 27)) diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols index 76d94dc2923..43c6d7135e0 100644 --- a/tests/baselines/reference/iterableContextualTyping1.symbols +++ b/tests/baselines/reference/iterableContextualTyping1.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts === var iter: Iterable<(x: string) => number> = [s => s.length]; >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1663, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1)) >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20)) >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45)) >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols index f53e8266baa..3c1cf17480d 100644 --- a/tests/baselines/reference/iteratorSpreadInArray.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray.ts, 0, 36)) diff --git a/tests/baselines/reference/iteratorSpreadInArray11.symbols b/tests/baselines/reference/iteratorSpreadInArray11.symbols index b128803aa50..d1eb5420ef1 100644 --- a/tests/baselines/reference/iteratorSpreadInArray11.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray11.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts === var iter: Iterable; >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1663, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1)) var array = [...iter]; >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3)) diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols index db8da1bac9d..42c7e7e626e 100644 --- a/tests/baselines/reference/iteratorSpreadInArray2.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray2.ts, 5, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray2.ts, 0, 59)) @@ -48,9 +48,9 @@ class NumberIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(NumberIterator, Decl(iteratorSpreadInArray2.ts, 13, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols index bdc200c25ec..8a7abd3f195 100644 --- a/tests/baselines/reference/iteratorSpreadInArray3.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray3.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray3.ts, 0, 47)) diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols index c49ea74dc23..03aca3c69b3 100644 --- a/tests/baselines/reference/iteratorSpreadInArray4.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray4.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray4.ts, 0, 42)) diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols index e7fbdac2264..e8c6571943e 100644 --- a/tests/baselines/reference/iteratorSpreadInArray7.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols @@ -17,7 +17,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray7.ts, 6, 28)) @@ -26,9 +26,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 1, 38)) diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols index 54ac770c5df..d695457621f 100644 --- a/tests/baselines/reference/iteratorSpreadInCall11.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols @@ -19,7 +19,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 6, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall11.ts, 7, 28)) @@ -28,9 +28,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall11.ts, 2, 42)) diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols index 8b24ba5d1b7..58ed5ea4935 100644 --- a/tests/baselines/reference/iteratorSpreadInCall12.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols @@ -22,7 +22,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 8, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall12.ts, 9, 28)) @@ -31,9 +31,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall12.ts, 4, 1)) @@ -57,9 +57,9 @@ class StringIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 17, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols index d43a7f9b4fc..ac81fdea261 100644 --- a/tests/baselines/reference/iteratorSpreadInCall3.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols @@ -16,7 +16,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall3.ts, 6, 28)) @@ -25,9 +25,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall3.ts, 2, 32)) diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols index 9d86858eb8e..da79720409d 100644 --- a/tests/baselines/reference/iteratorSpreadInCall5.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols @@ -17,7 +17,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall5.ts, 6, 28)) @@ -26,9 +26,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall5.ts, 2, 43)) @@ -52,9 +52,9 @@ class StringIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) return this; >this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 14, 1)) diff --git a/tests/baselines/reference/parserSymbolProperty1.symbols b/tests/baselines/reference/parserSymbolProperty1.symbols index 54d674ea0a8..9b0b706077d 100644 --- a/tests/baselines/reference/parserSymbolProperty1.symbols +++ b/tests/baselines/reference/parserSymbolProperty1.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(parserSymbolProperty1.ts, 0, 0)) [Symbol.iterator]: string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) } diff --git a/tests/baselines/reference/parserSymbolProperty2.symbols b/tests/baselines/reference/parserSymbolProperty2.symbols index 51fdb40efd4..f13748e9996 100644 --- a/tests/baselines/reference/parserSymbolProperty2.symbols +++ b/tests/baselines/reference/parserSymbolProperty2.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(parserSymbolProperty2.ts, 0, 0)) [Symbol.unscopables](): string; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty3.symbols b/tests/baselines/reference/parserSymbolProperty3.symbols index 11b6d8de94f..cb4ff68a637 100644 --- a/tests/baselines/reference/parserSymbolProperty3.symbols +++ b/tests/baselines/reference/parserSymbolProperty3.symbols @@ -3,7 +3,7 @@ declare class C { >C : Symbol(C, Decl(parserSymbolProperty3.ts, 0, 0)) [Symbol.unscopables](): string; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty4.symbols b/tests/baselines/reference/parserSymbolProperty4.symbols index b2ffc2c89d2..34f550b750b 100644 --- a/tests/baselines/reference/parserSymbolProperty4.symbols +++ b/tests/baselines/reference/parserSymbolProperty4.symbols @@ -3,7 +3,7 @@ declare class C { >C : Symbol(C, Decl(parserSymbolProperty4.ts, 0, 0)) [Symbol.toPrimitive]: string; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty5.symbols b/tests/baselines/reference/parserSymbolProperty5.symbols index e896ebbd2a2..5257941831b 100644 --- a/tests/baselines/reference/parserSymbolProperty5.symbols +++ b/tests/baselines/reference/parserSymbolProperty5.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty5.ts, 0, 0)) [Symbol.toPrimitive]: string; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty6.symbols b/tests/baselines/reference/parserSymbolProperty6.symbols index 1859c954ba4..77770a62bd5 100644 --- a/tests/baselines/reference/parserSymbolProperty6.symbols +++ b/tests/baselines/reference/parserSymbolProperty6.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty6.ts, 0, 0)) [Symbol.toStringTag]: string = ""; ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty7.symbols b/tests/baselines/reference/parserSymbolProperty7.symbols index a91a8227ae4..3e912a18a2f 100644 --- a/tests/baselines/reference/parserSymbolProperty7.symbols +++ b/tests/baselines/reference/parserSymbolProperty7.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty7.ts, 0, 0)) [Symbol.toStringTag](): void { } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty8.symbols b/tests/baselines/reference/parserSymbolProperty8.symbols index dee98ed1e77..dcf4a037db2 100644 --- a/tests/baselines/reference/parserSymbolProperty8.symbols +++ b/tests/baselines/reference/parserSymbolProperty8.symbols @@ -3,7 +3,7 @@ var x: { >x : Symbol(x, Decl(parserSymbolProperty8.ts, 0, 3)) [Symbol.toPrimitive](): string ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty9.symbols b/tests/baselines/reference/parserSymbolProperty9.symbols index cffbded17e6..f706a35e3b5 100644 --- a/tests/baselines/reference/parserSymbolProperty9.symbols +++ b/tests/baselines/reference/parserSymbolProperty9.symbols @@ -3,7 +3,7 @@ var x: { >x : Symbol(x, Decl(parserSymbolProperty9.ts, 0, 3)) [Symbol.toPrimitive]: string ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit1.symbols b/tests/baselines/reference/symbolDeclarationEmit1.symbols index f24cfe2b783..6b17c421a07 100644 --- a/tests/baselines/reference/symbolDeclarationEmit1.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit1.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit1.ts, 0, 0)) [Symbol.toPrimitive]: number; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols index 375bcf2174a..e620614d829 100644 --- a/tests/baselines/reference/symbolDeclarationEmit10.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols @@ -3,13 +3,13 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3)) get [Symbol.isConcatSpreadable]() { return '' }, ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) set [Symbol.isConcatSpreadable](x) { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) >x : Symbol(x, Decl(symbolDeclarationEmit10.ts, 2, 36)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit11.symbols b/tests/baselines/reference/symbolDeclarationEmit11.symbols index 90290569e07..3cbae021c32 100644 --- a/tests/baselines/reference/symbolDeclarationEmit11.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit11.symbols @@ -3,23 +3,23 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit11.ts, 0, 0)) static [Symbol.iterator] = 0; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) static [Symbol.isConcatSpreadable]() { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) static get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) static set [Symbol.toPrimitive](x) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit11.ts, 4, 36)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit13.symbols b/tests/baselines/reference/symbolDeclarationEmit13.symbols index 66f540a8cae..9e6b00fbc45 100644 --- a/tests/baselines/reference/symbolDeclarationEmit13.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit13.symbols @@ -3,13 +3,13 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit13.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) set [Symbol.toStringTag](x) { } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) >x : Symbol(x, Decl(symbolDeclarationEmit13.ts, 2, 29)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit14.symbols b/tests/baselines/reference/symbolDeclarationEmit14.symbols index 5927b8a6a29..610a6bae9cd 100644 --- a/tests/baselines/reference/symbolDeclarationEmit14.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit14.symbols @@ -3,12 +3,12 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit14.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) get [Symbol.toStringTag]() { return ""; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit2.symbols b/tests/baselines/reference/symbolDeclarationEmit2.symbols index 3c214bd9c25..e0ba5ffc72a 100644 --- a/tests/baselines/reference/symbolDeclarationEmit2.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit2.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit2.ts, 0, 0)) [Symbol.toPrimitive] = ""; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit3.symbols b/tests/baselines/reference/symbolDeclarationEmit3.symbols index d3a3a313223..712b233a744 100644 --- a/tests/baselines/reference/symbolDeclarationEmit3.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit3.symbols @@ -3,20 +3,20 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit3.ts, 0, 0)) [Symbol.toPrimitive](x: number); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 1, 25)) [Symbol.toPrimitive](x: string); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 2, 25)) [Symbol.toPrimitive](x: any) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 3, 25)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit4.symbols b/tests/baselines/reference/symbolDeclarationEmit4.symbols index d552300b70e..3a24de2f0e3 100644 --- a/tests/baselines/reference/symbolDeclarationEmit4.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit4.symbols @@ -3,13 +3,13 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit4.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) set [Symbol.toPrimitive](x) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit4.ts, 2, 29)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit5.symbols b/tests/baselines/reference/symbolDeclarationEmit5.symbols index 7f5fc3cf51b..5580b833c08 100644 --- a/tests/baselines/reference/symbolDeclarationEmit5.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit5.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(symbolDeclarationEmit5.ts, 0, 0)) [Symbol.isConcatSpreadable](): string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit6.symbols b/tests/baselines/reference/symbolDeclarationEmit6.symbols index fe60e2ecc31..10c95ed620b 100644 --- a/tests/baselines/reference/symbolDeclarationEmit6.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit6.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(symbolDeclarationEmit6.ts, 0, 0)) [Symbol.isConcatSpreadable]: string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit7.symbols b/tests/baselines/reference/symbolDeclarationEmit7.symbols index b044c5264d8..42f6b866867 100644 --- a/tests/baselines/reference/symbolDeclarationEmit7.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit7.symbols @@ -3,7 +3,7 @@ var obj: { >obj : Symbol(obj, Decl(symbolDeclarationEmit7.ts, 0, 3)) [Symbol.isConcatSpreadable]: string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols index 797b422c7fc..13331a49dc3 100644 --- a/tests/baselines/reference/symbolDeclarationEmit8.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols @@ -3,7 +3,7 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3)) [Symbol.isConcatSpreadable]: 0 ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols index deaf1c1bb62..2b6984b6bae 100644 --- a/tests/baselines/reference/symbolDeclarationEmit9.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols @@ -3,7 +3,7 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3)) [Symbol.isConcatSpreadable]() { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) } diff --git a/tests/baselines/reference/symbolProperty11.symbols b/tests/baselines/reference/symbolProperty11.symbols index f8b758cbf68..bff61ccc014 100644 --- a/tests/baselines/reference/symbolProperty11.symbols +++ b/tests/baselines/reference/symbolProperty11.symbols @@ -6,9 +6,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty11.ts, 0, 11)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty11.ts, 2, 25)) } diff --git a/tests/baselines/reference/symbolProperty13.symbols b/tests/baselines/reference/symbolProperty13.symbols index 246ca2f0851..1b0026c5ea4 100644 --- a/tests/baselines/reference/symbolProperty13.symbols +++ b/tests/baselines/reference/symbolProperty13.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(symbolProperty13.ts, 0, 0)) [Symbol.iterator]: { x; y }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty13.ts, 1, 24)) >y : Symbol(y, Decl(symbolProperty13.ts, 1, 27)) } @@ -13,9 +13,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty13.ts, 2, 1)) [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty13.ts, 4, 24)) } diff --git a/tests/baselines/reference/symbolProperty14.symbols b/tests/baselines/reference/symbolProperty14.symbols index 4531b13dca1..358819f47b3 100644 --- a/tests/baselines/reference/symbolProperty14.symbols +++ b/tests/baselines/reference/symbolProperty14.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(symbolProperty14.ts, 0, 0)) [Symbol.iterator]: { x; y }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty14.ts, 1, 24)) >y : Symbol(y, Decl(symbolProperty14.ts, 1, 27)) } @@ -13,9 +13,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty14.ts, 2, 1)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty14.ts, 4, 25)) } diff --git a/tests/baselines/reference/symbolProperty15.symbols b/tests/baselines/reference/symbolProperty15.symbols index 6027f5e797e..fe630f8f82d 100644 --- a/tests/baselines/reference/symbolProperty15.symbols +++ b/tests/baselines/reference/symbolProperty15.symbols @@ -6,9 +6,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty15.ts, 0, 11)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty15.ts, 2, 25)) } diff --git a/tests/baselines/reference/symbolProperty16.symbols b/tests/baselines/reference/symbolProperty16.symbols index f7700e3b777..d87416cd43a 100644 --- a/tests/baselines/reference/symbolProperty16.symbols +++ b/tests/baselines/reference/symbolProperty16.symbols @@ -3,18 +3,18 @@ class C { >C : Symbol(C, Decl(symbolProperty16.ts, 0, 0)) private [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty16.ts, 1, 32)) } interface I { >I : Symbol(I, Decl(symbolProperty16.ts, 2, 1)) [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty16.ts, 4, 24)) } diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols index bc23c468a22..4597eb81c0f 100644 --- a/tests/baselines/reference/symbolProperty18.symbols +++ b/tests/baselines/reference/symbolProperty18.symbols @@ -3,39 +3,39 @@ var i = { >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) [Symbol.iterator]: 0, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) [Symbol.toStringTag]() { return "" }, ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) set [Symbol.toPrimitive](p: boolean) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) >p : Symbol(p, Decl(symbolProperty18.ts, 3, 29)) } var it = i[Symbol.iterator]; >it : Symbol(it, Decl(symbolProperty18.ts, 6, 3)) >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) var str = i[Symbol.toStringTag](); >str : Symbol(str, Decl(symbolProperty18.ts, 7, 3)) >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) i[Symbol.toPrimitive] = false; >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols index a0274f2c762..d3295b6507e 100644 --- a/tests/baselines/reference/symbolProperty19.symbols +++ b/tests/baselines/reference/symbolProperty19.symbols @@ -3,15 +3,15 @@ var i = { >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) [Symbol.iterator]: { p: null }, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >p : Symbol(p, Decl(symbolProperty19.ts, 1, 24)) [Symbol.toStringTag]() { return { p: undefined }; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37)) >undefined : Symbol(undefined) } @@ -19,14 +19,14 @@ var i = { var it = i[Symbol.iterator]; >it : Symbol(it, Decl(symbolProperty19.ts, 5, 3)) >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) var str = i[Symbol.toStringTag](); >str : Symbol(str, Decl(symbolProperty19.ts, 6, 3)) >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols index c6bb74bef31..ea698562ed2 100644 --- a/tests/baselines/reference/symbolProperty2.symbols +++ b/tests/baselines/reference/symbolProperty2.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/Symbols/symbolProperty2.ts === var s = Symbol(); >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) var x = { >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3)) diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols index 04c76275b55..714b771b67e 100644 --- a/tests/baselines/reference/symbolProperty20.symbols +++ b/tests/baselines/reference/symbolProperty20.symbols @@ -3,15 +3,15 @@ interface I { >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0)) [Symbol.iterator]: (s: string) => string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >s : Symbol(s, Decl(symbolProperty20.ts, 1, 24)) [Symbol.toStringTag](s: number): number; ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) >s : Symbol(s, Decl(symbolProperty20.ts, 2, 25)) } @@ -20,16 +20,16 @@ var i: I = { >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0)) [Symbol.iterator]: s => s, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22)) >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22)) [Symbol.toStringTag](n) { return n; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25)) >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25)) } diff --git a/tests/baselines/reference/symbolProperty21.symbols b/tests/baselines/reference/symbolProperty21.symbols index 544813c3056..f2061b3bb2c 100644 --- a/tests/baselines/reference/symbolProperty21.symbols +++ b/tests/baselines/reference/symbolProperty21.symbols @@ -5,15 +5,15 @@ interface I { >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14)) [Symbol.unscopables]: T; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) >T : Symbol(T, Decl(symbolProperty21.ts, 0, 12)) [Symbol.isConcatSpreadable]: U; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14)) } @@ -34,18 +34,18 @@ foo({ >foo : Symbol(foo, Decl(symbolProperty21.ts, 3, 1)) [Symbol.isConcatSpreadable]: "", ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) [Symbol.toPrimitive]: 0, ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) [Symbol.unscopables]: true ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) }); diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols index e9f6761e121..d1bee54bd7b 100644 --- a/tests/baselines/reference/symbolProperty22.symbols +++ b/tests/baselines/reference/symbolProperty22.symbols @@ -5,9 +5,9 @@ interface I { >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14)) [Symbol.unscopables](x: T): U; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) >x : Symbol(x, Decl(symbolProperty22.ts, 1, 25)) >T : Symbol(T, Decl(symbolProperty22.ts, 0, 12)) >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14)) @@ -27,9 +27,9 @@ declare function foo(p1: T, p2: I): U; foo("", { [Symbol.unscopables]: s => s.length }); >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1)) ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31)) >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31)) diff --git a/tests/baselines/reference/symbolProperty23.symbols b/tests/baselines/reference/symbolProperty23.symbols index d220f80c0f7..94dc416010e 100644 --- a/tests/baselines/reference/symbolProperty23.symbols +++ b/tests/baselines/reference/symbolProperty23.symbols @@ -3,9 +3,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0)) [Symbol.toPrimitive]: () => boolean; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) } class C implements I { @@ -13,9 +13,9 @@ class C implements I { >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0)) [Symbol.toPrimitive]() { ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) return true; } diff --git a/tests/baselines/reference/symbolProperty26.symbols b/tests/baselines/reference/symbolProperty26.symbols index 819b93e6147..0850ec9cdaa 100644 --- a/tests/baselines/reference/symbolProperty26.symbols +++ b/tests/baselines/reference/symbolProperty26.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) return ""; } @@ -16,9 +16,9 @@ class C2 extends C1 { >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) return ""; } diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols index 7ead7b14b34..ed56e55cca6 100644 --- a/tests/baselines/reference/symbolProperty27.symbols +++ b/tests/baselines/reference/symbolProperty27.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) return {}; } @@ -16,9 +16,9 @@ class C2 extends C1 { >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) return ""; } diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols index 9f57cd1e2e3..e5cdbb0ea61 100644 --- a/tests/baselines/reference/symbolProperty28.symbols +++ b/tests/baselines/reference/symbolProperty28.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty28.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) return { x: "" }; >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) @@ -24,8 +24,8 @@ var obj = c[Symbol.toStringTag]().x; >obj : Symbol(obj, Decl(symbolProperty28.ts, 9, 3)) >c[Symbol.toStringTag]().x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) >c : Symbol(c, Decl(symbolProperty28.ts, 8, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols index a6594f5146b..8a0d692de22 100644 --- a/tests/baselines/reference/symbolProperty4.symbols +++ b/tests/baselines/reference/symbolProperty4.symbols @@ -3,13 +3,13 @@ var x = { >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3)) [Symbol()]: 0, ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) [Symbol()]() { }, ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) get [Symbol()]() { ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) return 0; } diff --git a/tests/baselines/reference/symbolProperty40.symbols b/tests/baselines/reference/symbolProperty40.symbols index 1f0fdaf91a7..246d0952c89 100644 --- a/tests/baselines/reference/symbolProperty40.symbols +++ b/tests/baselines/reference/symbolProperty40.symbols @@ -3,21 +3,21 @@ class C { >C : Symbol(C, Decl(symbolProperty40.ts, 0, 0)) [Symbol.iterator](x: string): string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 1, 22)) [Symbol.iterator](x: number): number; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 2, 22)) [Symbol.iterator](x: any) { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 3, 22)) return undefined; @@ -31,13 +31,13 @@ var c = new C; c[Symbol.iterator](""); >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) c[Symbol.iterator](0); >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) diff --git a/tests/baselines/reference/symbolProperty41.symbols b/tests/baselines/reference/symbolProperty41.symbols index d50401a637a..2872f6cb134 100644 --- a/tests/baselines/reference/symbolProperty41.symbols +++ b/tests/baselines/reference/symbolProperty41.symbols @@ -3,24 +3,24 @@ class C { >C : Symbol(C, Decl(symbolProperty41.ts, 0, 0)) [Symbol.iterator](x: string): { x: string }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 1, 22)) >x : Symbol(x, Decl(symbolProperty41.ts, 1, 35)) [Symbol.iterator](x: "hello"): { x: string; hello: string }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 2, 22)) >x : Symbol(x, Decl(symbolProperty41.ts, 2, 36)) >hello : Symbol(hello, Decl(symbolProperty41.ts, 2, 47)) [Symbol.iterator](x: any) { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 3, 22)) return undefined; @@ -34,13 +34,13 @@ var c = new C; c[Symbol.iterator](""); >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) c[Symbol.iterator]("hello"); >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) diff --git a/tests/baselines/reference/symbolProperty45.symbols b/tests/baselines/reference/symbolProperty45.symbols index 4c3d2595c13..1f691f8827d 100644 --- a/tests/baselines/reference/symbolProperty45.symbols +++ b/tests/baselines/reference/symbolProperty45.symbols @@ -3,16 +3,16 @@ class C { >C : Symbol(C, Decl(symbolProperty45.ts, 0, 0)) get [Symbol.hasInstance]() { ->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1222, 32)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1222, 32)) +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1233, 32)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1233, 32)) return ""; } get [Symbol.toPrimitive]() { ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) return ""; } diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols index a759e09588e..e9bda77fd71 100644 --- a/tests/baselines/reference/symbolProperty5.symbols +++ b/tests/baselines/reference/symbolProperty5.symbols @@ -3,19 +3,19 @@ var x = { >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3)) [Symbol.iterator]: 0, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) [Symbol.toPrimitive]() { }, ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) get [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) return 0; } diff --git a/tests/baselines/reference/symbolProperty50.symbols b/tests/baselines/reference/symbolProperty50.symbols index ee785ae606d..69a695e6c5b 100644 --- a/tests/baselines/reference/symbolProperty50.symbols +++ b/tests/baselines/reference/symbolProperty50.symbols @@ -9,8 +9,8 @@ module M { >C : Symbol(C, Decl(symbolProperty50.ts, 1, 24)) [Symbol.iterator]() { } ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) } } diff --git a/tests/baselines/reference/symbolProperty51.symbols b/tests/baselines/reference/symbolProperty51.symbols index 825f73ebcd1..e045d35f13f 100644 --- a/tests/baselines/reference/symbolProperty51.symbols +++ b/tests/baselines/reference/symbolProperty51.symbols @@ -9,8 +9,8 @@ module M { >C : Symbol(C, Decl(symbolProperty51.ts, 1, 21)) [Symbol.iterator]() { } ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) } } diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols index e76ad43f43d..077199e4969 100644 --- a/tests/baselines/reference/symbolProperty55.symbols +++ b/tests/baselines/reference/symbolProperty55.symbols @@ -3,9 +3,9 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) }; @@ -14,13 +14,13 @@ module M { var Symbol: SymbolConstructor; >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7)) ->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 1196, 1)) +>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 1207, 1)) // The following should be of type 'any'. This is because even though obj has a property keyed by Symbol.iterator, // the key passed in here is the *wrong* Symbol.iterator. It is not the iterator property of the global Symbol. obj[Symbol.iterator]; >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) } diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols index caca4686bbf..a76ab0418cc 100644 --- a/tests/baselines/reference/symbolProperty56.symbols +++ b/tests/baselines/reference/symbolProperty56.symbols @@ -3,9 +3,9 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) }; diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols index 4e0ce420388..e98cf963807 100644 --- a/tests/baselines/reference/symbolProperty57.symbols +++ b/tests/baselines/reference/symbolProperty57.symbols @@ -3,14 +3,14 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) }; // Should give type 'any'. obj[Symbol["nonsense"]]; >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) diff --git a/tests/baselines/reference/symbolProperty6.symbols b/tests/baselines/reference/symbolProperty6.symbols index cedcfe69a9f..8b0e62e4068 100644 --- a/tests/baselines/reference/symbolProperty6.symbols +++ b/tests/baselines/reference/symbolProperty6.symbols @@ -3,24 +3,24 @@ class C { >C : Symbol(C, Decl(symbolProperty6.ts, 0, 0)) [Symbol.iterator] = 0; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) [Symbol.unscopables]: number; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) [Symbol.toPrimitive]() { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) get [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) return 0; } diff --git a/tests/baselines/reference/symbolProperty8.symbols b/tests/baselines/reference/symbolProperty8.symbols index 269a8412d95..a1a4d1d50df 100644 --- a/tests/baselines/reference/symbolProperty8.symbols +++ b/tests/baselines/reference/symbolProperty8.symbols @@ -3,12 +3,12 @@ interface I { >I : Symbol(I, Decl(symbolProperty8.ts, 0, 0)) [Symbol.unscopables]: number; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) [Symbol.toPrimitive](); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) } diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols index 4bf91a6112e..6c4001fa4c8 100644 --- a/tests/baselines/reference/symbolType11.symbols +++ b/tests/baselines/reference/symbolType11.symbols @@ -1,9 +1,9 @@ === tests/cases/conformance/es6/Symbols/symbolType11.ts === var s = Symbol.for("logical"); >s : Symbol(s, Decl(symbolType11.ts, 0, 3)) ->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1208, 42)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11)) ->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1208, 42)) +>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1219, 42)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1219, 42)) s && s; >s : Symbol(s, Decl(symbolType11.ts, 0, 3)) diff --git a/tests/baselines/reference/symbolType16.symbols b/tests/baselines/reference/symbolType16.symbols index 1d87ae6a1a4..7a54b0efcbe 100644 --- a/tests/baselines/reference/symbolType16.symbols +++ b/tests/baselines/reference/symbolType16.symbols @@ -1,6 +1,6 @@ === tests/cases/conformance/es6/Symbols/symbolType16.ts === interface Symbol { ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11), Decl(symbolType16.ts, 0, 0)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11), Decl(symbolType16.ts, 0, 0)) newSymbolProp: number; >newSymbolProp : Symbol(newSymbolProp, Decl(symbolType16.ts, 0, 18)) diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols index 0cfe0d854be..a6e319c0dfa 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols +++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts === var x = `abc${ new String("Hi") }def`; >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols index 27b72cc54f1..ef9f533bb58 100644 --- a/tests/baselines/reference/typedArrays.symbols +++ b/tests/baselines/reference/typedArrays.symbols @@ -8,39 +8,39 @@ function CreateTypedArrayTypes() { typedArrays[0] = Int8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) typedArrays[1] = Uint8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) typedArrays[2] = Int16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) typedArrays[3] = Uint16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) typedArrays[4] = Int32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) typedArrays[5] = Uint32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) typedArrays[6] = Float32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) typedArrays[7] = Float64Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) typedArrays[8] = Uint8ClampedArray; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) @@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) return typedArrays; @@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) return typedArrays; @@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) return typedArrays; @@ -235,72 +235,72 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >CreateIntegerTypedArraysFromArrayLike : Symbol(CreateIntegerTypedArraysFromArrayLike, Decl(typedArrays.ts, 59, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1434, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1)) var typedArrays = []; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) return typedArrays; @@ -332,57 +332,57 @@ function CreateTypedArraysOf2() { typedArrays[0] = Int8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2381, 30)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11)) ->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2381, 30)) +>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2392, 30)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) +>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2392, 30)) typedArrays[1] = Uint8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2671, 30)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11)) ->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2671, 30)) +>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2682, 30)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) +>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2682, 30)) typedArrays[2] = Int16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3251, 30)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11)) ->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3251, 30)) +>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3262, 30)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) +>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3262, 30)) typedArrays[3] = Uint16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3541, 30)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11)) ->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3541, 30)) +>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3552, 30)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) +>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3552, 30)) typedArrays[4] = Int32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3831, 30)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11)) ->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3831, 30)) +>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3842, 30)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) +>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3842, 30)) typedArrays[5] = Uint32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4121, 30)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11)) ->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4121, 30)) +>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4132, 30)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) +>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4132, 30)) typedArrays[6] = Float32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4411, 30)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11)) ->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4411, 30)) +>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4422, 30)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) +>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4422, 30)) typedArrays[7] = Float64Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4701, 30)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11)) ->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4701, 30)) +>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4712, 30)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) +>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4712, 30)) typedArrays[8] = Uint8ClampedArray.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2961, 30)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11)) ->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2961, 30)) +>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2972, 30)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) +>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2972, 30)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) @@ -391,7 +391,7 @@ function CreateTypedArraysOf2() { function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:number)=> number) { >CreateTypedArraysFromMapFn : Symbol(CreateTypedArraysFromMapFn, Decl(typedArrays.ts, 106, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1434, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) >n : Symbol(n, Decl(typedArrays.ts, 108, 67)) >v : Symbol(v, Decl(typedArrays.ts, 108, 76)) @@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n typedArrays[0] = Int8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[1] = Uint8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[2] = Int16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[3] = Uint16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[4] = Int32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[5] = Uint32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[6] = Float32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[7] = Float64Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) @@ -478,7 +478,7 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v:number)=> number, thisArg: {}) { >CreateTypedArraysFromThisObj : Symbol(CreateTypedArraysFromThisObj, Decl(typedArrays.ts, 121, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1434, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >n : Symbol(n, Decl(typedArrays.ts, 123, 69)) >v : Symbol(v, Decl(typedArrays.ts, 123, 78)) @@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v typedArrays[0] = Int8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[2] = Int16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[4] = Int32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[6] = Float32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[7] = Float64Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts new file mode 100644 index 00000000000..0959ed6c561 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts @@ -0,0 +1,7 @@ +// @target: ES6 +// @noEmitHelpers: true + +var foo = async foo(): Promise => { + // Legal to use 'await' in a type context. + var v: await; +} diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts new file mode 100644 index 00000000000..83e7413c527 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts @@ -0,0 +1,5 @@ +// @target: ES6 +// @noEmitHelpers: true + +var foo = async (): Promise => { +}; \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts new file mode 100644 index 00000000000..bf39735d460 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +var f = (await) => { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts new file mode 100644 index 00000000000..4ae27c596f1 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +function f(await = await) { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts new file mode 100644 index 00000000000..51b34abeca1 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +var await = () => { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts new file mode 100644 index 00000000000..174a619bdf9 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts @@ -0,0 +1,5 @@ +// @target: ES6 +// @noEmitHelpers: true + +var foo = async (await): Promise => { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts new file mode 100644 index 00000000000..dace96c4933 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts @@ -0,0 +1,5 @@ +// @target: ES6 +// @noEmitHelpers: true + +var foo = async (a = await): Promise => { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts new file mode 100644 index 00000000000..b1fd5cc030d --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts @@ -0,0 +1,8 @@ +// @target: ES6 +// @noEmitHelpers: true + +var bar = async (): Promise => { + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { + } +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts new file mode 100644 index 00000000000..5d53338b1bd --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts @@ -0,0 +1,6 @@ +// @target: ES6 +// @noEmitHelpers: true + +var foo = async (): Promise => { + var v = { [await]: foo } +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts new file mode 100644 index 00000000000..da041fe472b --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +var foo = async (a = await => await): Promise => { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts new file mode 100644 index 00000000000..8dab2c04086 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts @@ -0,0 +1,8 @@ +// @target: ES6 +// @noEmitHelpers: true +class C { + method() { + function other() {} + var fn = async () => await other.apply(this, arguments); + } +} diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts new file mode 100644 index 00000000000..f2c507cbdd6 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts @@ -0,0 +1,7 @@ +// @target: ES6 +// @noEmitHelpers: true +class C { + method() { + var fn = async () => await this; + } +} diff --git a/tests/cases/conformance/async/es6/asyncClass_es6.ts b/tests/cases/conformance/async/es6/asyncClass_es6.ts new file mode 100644 index 00000000000..22ffe997b03 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncClass_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +async class C { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncConstructor_es6.ts b/tests/cases/conformance/async/es6/asyncConstructor_es6.ts new file mode 100644 index 00000000000..d769fad0395 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncConstructor_es6.ts @@ -0,0 +1,6 @@ +// @target: ES6 +// @noEmitHelpers: true +class C { + async constructor() { + } +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncDeclare_es6.ts b/tests/cases/conformance/async/es6/asyncDeclare_es6.ts new file mode 100644 index 00000000000..5e0fb536b39 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncDeclare_es6.ts @@ -0,0 +1,3 @@ +// @target: ES6 +// @noEmitHelpers: true +declare async function foo(): Promise; \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncEnum_es6.ts b/tests/cases/conformance/async/es6/asyncEnum_es6.ts new file mode 100644 index 00000000000..4fad7923a8c --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncEnum_es6.ts @@ -0,0 +1,5 @@ +// @target: ES6 +// @noEmitHelpers: true +async enum E { + Value +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncGetter_es6.ts b/tests/cases/conformance/async/es6/asyncGetter_es6.ts new file mode 100644 index 00000000000..79fde60fdc4 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncGetter_es6.ts @@ -0,0 +1,6 @@ +// @target: ES6 +// @noEmitHelpers: true +class C { + async get foo() { + } +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncInterface_es6.ts b/tests/cases/conformance/async/es6/asyncInterface_es6.ts new file mode 100644 index 00000000000..5d5497d3cd4 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncInterface_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +async interface I { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncModule_es6.ts b/tests/cases/conformance/async/es6/asyncModule_es6.ts new file mode 100644 index 00000000000..aa4c295d0e3 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncModule_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +async module M { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncSetter_es6.ts b/tests/cases/conformance/async/es6/asyncSetter_es6.ts new file mode 100644 index 00000000000..8eedcbb5288 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncSetter_es6.ts @@ -0,0 +1,6 @@ +// @target: ES6 +// @noEmitHelpers: true +class C { + async set foo(value) { + } +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts new file mode 100644 index 00000000000..46060f309b2 --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts @@ -0,0 +1,9 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +async function func(): Promise { + "before"; + var b = await p || a; + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts new file mode 100644 index 00000000000..362f1ecc446 --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts @@ -0,0 +1,9 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +async function func(): Promise { + "before"; + var b = await p && a; + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts new file mode 100644 index 00000000000..d3b02033252 --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts @@ -0,0 +1,9 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: number; +declare var p: Promise; +async function func(): Promise { + "before"; + var b = await p + a; + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts new file mode 100644 index 00000000000..eba3be31acf --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts @@ -0,0 +1,9 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +async function func(): Promise { + "before"; + var b = await p, a; + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts new file mode 100644 index 00000000000..71b173f9e73 --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts @@ -0,0 +1,10 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +async function func(): Promise { + "before"; + var o: { a: boolean; }; + o.a = await p; + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts new file mode 100644 index 00000000000..d0442f0968d --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts @@ -0,0 +1,13 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = fn(a, a, a); + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts new file mode 100644 index 00000000000..6de07ef12ff --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts @@ -0,0 +1,13 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = fn(await p, a, a); + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts new file mode 100644 index 00000000000..2cc0b7b12d0 --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts @@ -0,0 +1,13 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = fn(a, await p, a); + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts new file mode 100644 index 00000000000..8e349fbc5c3 --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts @@ -0,0 +1,13 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = (await pfn)(a, a, a); + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts new file mode 100644 index 00000000000..bbe81ac94b1 --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts @@ -0,0 +1,13 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = o.fn(a, a, a); + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts new file mode 100644 index 00000000000..09e88f5acbc --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts @@ -0,0 +1,13 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = o.fn(await p, a, a); + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts new file mode 100644 index 00000000000..fe0182da4aa --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts @@ -0,0 +1,13 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = o.fn(a, await p, a); + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts new file mode 100644 index 00000000000..e3280eb7c10 --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts @@ -0,0 +1,13 @@ +// @target: ES6 +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +async function func(): Promise { + "before"; + var b = (await po).fn(a, a, a); + "after"; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts new file mode 100644 index 00000000000..aab1f0013ec --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +async function foo(a = await => await): Promise { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts new file mode 100644 index 00000000000..747d20d7ea8 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +async function await(): Promise { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts new file mode 100644 index 00000000000..bbd77250365 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts @@ -0,0 +1,3 @@ +// @target: ES6 +// @noEmitHelpers: true +var v = async function await(): Promise { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts new file mode 100644 index 00000000000..8670fa02811 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts @@ -0,0 +1,6 @@ +// @target: ES6 +// @noEmitHelpers: true +async function foo(): Promise { + // Legal to use 'await' in a type context. + var v: await; +} diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts new file mode 100644 index 00000000000..ba70c61b492 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts @@ -0,0 +1,5 @@ +// @target: ES6 +// @noEmitHelpers: true +async function foo(): Promise { + return; +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts new file mode 100644 index 00000000000..289a65bb74f --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +async function foo(): Promise { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts new file mode 100644 index 00000000000..25a153b4a34 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +function f(await) { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts new file mode 100644 index 00000000000..4ae27c596f1 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +function f(await = await) { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts new file mode 100644 index 00000000000..5d1ec389da3 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +function await() { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts new file mode 100644 index 00000000000..eb3cd1db556 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +async function foo(await): Promise { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts new file mode 100644 index 00000000000..89b0445fd2e --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts @@ -0,0 +1,4 @@ +// @target: ES6 +// @noEmitHelpers: true +async function foo(a = await): Promise { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts new file mode 100644 index 00000000000..5a964695da5 --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts @@ -0,0 +1,7 @@ +// @target: ES6 +// @noEmitHelpers: true +async function bar(): Promise { + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { + } +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts new file mode 100644 index 00000000000..764b0f3fb8a --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts @@ -0,0 +1,3 @@ +// @target: ES6 +// @noEmitHelpers: true +var v = { [await]: foo } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts new file mode 100644 index 00000000000..7671764ad2a --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts @@ -0,0 +1,5 @@ +// @target: ES6 +// @noEmitHelpers: true +async function foo(): Promise { + var v = { [await]: foo } +} \ No newline at end of file From 80edb2de4a058ccd8594d8faad5f8e1f4cbe8962 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 7 May 2015 11:13:45 -0700 Subject: [PATCH 009/309] Bug fixes and baselines --- src/compiler/parser.ts | 58 +++++++++---------- src/compiler/types.ts | 4 +- tests/baselines/reference/APISample_linter.js | 20 +++---- .../FunctionDeclaration10_es6.errors.txt | 20 ++----- .../FunctionDeclaration6_es6.errors.txt | 4 +- .../FunctionDeclaration7_es6.errors.txt | 4 +- .../asyncArrowFunction6_es6.errors.txt | 6 +- .../reference/asyncArrowFunction6_es6.js | 2 +- .../asyncArrowFunction7_es6.errors.txt | 6 +- .../reference/asyncArrowFunction7_es6.js | 2 +- .../asyncArrowFunction9_es6.errors.txt | 23 -------- .../reference/asyncArrowFunction9_es6.js | 5 +- .../reference/asyncArrowFunction9_es6.symbols | 8 +++ .../reference/asyncArrowFunction9_es6.types | 10 ++++ .../asyncFunctionDeclaration10_es6.errors.txt | 26 --------- .../asyncFunctionDeclaration10_es6.js | 6 +- .../asyncFunctionDeclaration10_es6.symbols | 8 +++ .../asyncFunctionDeclaration10_es6.types | 9 +++ .../asyncFunctionDeclaration6_es6.errors.txt | 6 +- .../asyncFunctionDeclaration6_es6.js | 2 +- .../asyncFunctionDeclaration7_es6.errors.txt | 6 +- .../asyncFunctionDeclaration7_es6.js | 2 +- 22 files changed, 104 insertions(+), 133 deletions(-) delete mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.types delete mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.types diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index a22ec28ecbc..db6a00ec9aa 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -592,7 +592,7 @@ module ts { // no need to do anything special as we are already in all of the requested contexts return func(); } - + function allowInAnd(func: () => T): T { return doOutsideOfContext(ParserContextFlags.DisallowIn, func); } @@ -621,12 +621,16 @@ module ts { return doOutsideOfContext(ParserContextFlags.Await, func); } + function doInYieldAndAwaitContext(func: () => T): T { + return doInsideOfContext(ParserContextFlags.Yield | ParserContextFlags.Await, func); + } + function doOutsideOfYieldAndAwaitContext(func: () => T): T { return doOutsideOfContext(ParserContextFlags.Yield | ParserContextFlags.Await, func); } function inContext(flags: ParserContextFlags) { - return (contextFlags & flags) === flags; + return (contextFlags & flags) !== 0; } function inYieldContext() { @@ -957,8 +961,8 @@ module ts { // says that only an assignment expression is allowed, so the grammar checker // will error if it sees a comma expression. node.expression = inGeneratorParameterOrAsyncParameterContext() - ? doOutsideOfYieldAndAwaitContext(parseExpression) - : parseExpression(); + ? doOutsideOfYieldAndAwaitContext(allowInAndParseExpression) + : allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseBracketToken); return finishNode(node); @@ -1857,8 +1861,8 @@ module ts { function parseParameter(): ParameterDeclaration { let node = createNode(SyntaxKind.Parameter); node.decorators = parseDecorators(); - setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); + setModifiers(node, parseModifiers()); // FormalParameter[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 14.1 // BindingElement[?Yield,?GeneratorParameter,?Await,?AsyncParameter] @@ -1901,7 +1905,6 @@ module ts { // [+GeneratorParameter] BindingIdentifier[Yield] Initializer[In]opt // [+AsyncParameter] BindingIdentifier[Await] Initializer[In]opt // [~GeneratorParameter,~AsyncParameter] BindingIdentifier[?Yield,?Await] Initializer[In,?Yield,?Await]opt - let parseInitializer = inParameter ? parseParameterInitializer : parseNonParameterInitializer; return inGeneratorParameterOrAsyncParameterContext() ? doOutsideOfYieldAndAwaitContext(parseInitializer) @@ -1957,27 +1960,19 @@ module ts { let savedGeneratorParameterContext = inGeneratorParameterContext(); let savedAwaitContext = inAwaitContext(); let savedAsyncParameterContext = inAsyncParameterContext(); - - if (yieldAndGeneratorParameterContext) { - setYieldContext(true); - } + setYieldContext(yieldAndGeneratorParameterContext); setGeneratorParameterContext(yieldAndGeneratorParameterContext); - - if (awaitAndAsyncParameterContext) { - setAwaitContext(true); - } - + setAwaitContext(awaitAndAsyncParameterContext); setAsyncParameterContext(awaitAndAsyncParameterContext); - + let result = parseDelimitedList(ParsingContext.Parameters, parseParameter); - + setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); - setAwaitContext(savedAwaitContext); setAsyncParameterContext(savedAsyncParameterContext); - + if (!parseExpected(SyntaxKind.CloseParenToken) && requireCompleteParameterList) { // Caller insisted that we had to end with a ) We didn't. So just return // undefined here. @@ -1992,7 +1987,7 @@ module ts { // then just return an empty set of parameters. return requireCompleteParameterList ? undefined : createMissingList(); } - + function parseTypeMemberSemicolon() { // We allow type members to be separated by commas or (possibly ASI) semicolons. // First check if it was a comma. If so, we're done with the member. @@ -2368,7 +2363,7 @@ module ts { function parseType(): TypeNode { // The rules about 'yield' only apply to actual code/expression contexts. They don't // apply to 'type' contexts. So we disable these parameters here before moving on. - return doOutsideOfContext(ParserContextFlags.ContextParameterFlags, parseTypeWorker); + return doOutsideOfContext(ParserContextFlags.AllParameterFlags, parseTypeWorker); } function parseTypeWorker(): TypeNode { @@ -2455,6 +2450,10 @@ module ts { token !== SyntaxKind.AtToken && isStartOfExpression(); } + + function allowInAndParseExpression(): Expression { + return allowInAnd(parseExpression); + } function parseExpression(): Expression { // Expression[in]: @@ -3449,20 +3448,15 @@ module ts { let node = createNode(SyntaxKind.FunctionExpression); setModifiers(node, parseModifiers()); parseExpected(SyntaxKind.FunctionKeyword); - node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); + node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); - let savedYieldContext = inYieldContext(); let isGenerator = node.asteriskToken != undefined; - setYieldContext(isGenerator); - - let savedAwaitContext = inAwaitContext(); let isAsync = isAsyncFunctionLike(node); - setAwaitContext(isAsync); - - node.name = parseOptionalIdentifier(); - - setYieldContext(savedYieldContext); - setAwaitContext(savedAwaitContext); + node.name = + isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) : + isGenerator ? doInYieldContext(parseOptionalIdentifier) : + isAsync ? doInAwaitContext(parseOptionalIdentifier) : + parseOptionalIdentifier(); fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList*/ false, node); node.body = parseFunctionBlock(/*allowYield*/ isGenerator, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ false); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index f256c63056f..86b4113eecc 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -359,7 +359,9 @@ module ts { ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | Decorator | ThisNodeHasError | AsyncParameter | Await, // Context flags passed as part of the modified ES6 grammar. - ContextParameterFlags = Yield | GeneratorParameter | AsyncParameter | Await, + YieldAndGeneratorParameterFlags = Yield | GeneratorParameter, + AwaitAndAsyncParameterFlags = Await | AsyncParameter, + AllParameterFlags = YieldAndGeneratorParameterFlags | AwaitAndAsyncParameterFlags, // Context flags computed by aggregating child flags upwards. diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js index cd2df23ffbf..5c2a8953a61 100644 --- a/tests/baselines/reference/APISample_linter.js +++ b/tests/baselines/reference/APISample_linter.js @@ -75,26 +75,26 @@ function delint(sourceFile) { delintNode(sourceFile); function delintNode(node) { switch (node.kind) { - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 186 /* WhileStatement */: - case 185 /* DoStatement */: - if (node.statement.kind !== 180 /* Block */) { + case 190 /* ForStatement */: + case 191 /* ForInStatement */: + case 189 /* WhileStatement */: + case 188 /* DoStatement */: + if (node.statement.kind !== 183 /* Block */) { report(node, "A looping statement's contents should be wrapped in a block body."); } break; - case 184 /* IfStatement */: + case 187 /* IfStatement */: var ifStatement = node; - if (ifStatement.thenStatement.kind !== 180 /* Block */) { + if (ifStatement.thenStatement.kind !== 183 /* Block */) { report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); } if (ifStatement.elseStatement && - ifStatement.elseStatement.kind !== 180 /* Block */ && - ifStatement.elseStatement.kind !== 184 /* IfStatement */) { + ifStatement.elseStatement.kind !== 183 /* Block */ && + ifStatement.elseStatement.kind !== 187 /* IfStatement */) { report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); } break; - case 170 /* BinaryExpression */: + case 173 /* BinaryExpression */: var op = node.operatorToken.kind; if (op === 28 /* EqualsEqualsToken */ || op == 29 /* ExclamationEqualsToken */) { report(node, "Use '===' and '!=='."); diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt index 6efd10dce09..8c6b09c82d6 100644 --- a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt @@ -1,20 +1,8 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,16): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,26): error TS1005: ',' expected. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS1138: Parameter declaration expected. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS2304: Cannot find name 'yield'. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,34): error TS1005: ';' expected. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,10): error TS9001: Generators are not currently supported. -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (5 errors) ==== +==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (1 errors) ==== function * foo(a = yield => yield) { - ~~~~~~~~~ -!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. - ~~ -!!! error TS1005: ',' expected. - ~~~~~ -!!! error TS1138: Parameter declaration expected. - ~~~~~ -!!! error TS2304: Cannot find name 'yield'. - ~ -!!! error TS1005: ';' expected. + ~ +!!! error TS9001: Generators are not currently supported. } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt index 13f69a47653..b5ea3f494a7 100644 --- a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS9001: Generators are not currently supported. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS9000: 'yield' expressions are not currently supported. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2304: Cannot find name 'yield'. ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ==== @@ -7,5 +7,5 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,1 ~ !!! error TS9001: Generators are not currently supported. ~~~~~ -!!! error TS9000: 'yield' expressions are not currently supported. +!!! error TS2304: Cannot find name 'yield'. } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt index 8b15522b136..f129d3fa30b 100644 --- a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt @@ -1,6 +1,6 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS9001: Generators are not currently supported. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS9001: Generators are not currently supported. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS9000: 'yield' expressions are not currently supported. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2304: Cannot find name 'yield'. ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ==== @@ -12,6 +12,6 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,2 ~ !!! error TS9001: Generators are not currently supported. ~~~~~ -!!! error TS9000: 'yield' expressions are not currently supported. +!!! error TS2304: Cannot find name 'yield'. } } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt index 3afce3a8127..c5a34f513b0 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,27): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,22): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts (1 errors) ==== var foo = async (a = await): Promise => { - ~ -!!! error TS1109: Expression expected. + ~~~~~ +!!! error TS2304: Cannot find name 'await'. } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js index 186ecc4cf19..e4da75e3cd1 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.js +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -4,5 +4,5 @@ var foo = async (a = await): Promise => { } //// [asyncArrowFunction6_es6.js] -var foo = (...arguments_1) => __awaiter(function *(a = yield ) { +var foo = (...arguments_1) => __awaiter(function *(a = await) { }.apply(this, arguments_1), Promise); diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt index db7e634b479..823d779c601 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,29): error TS1109: Expression expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,24): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts (1 errors) ==== @@ -6,7 +6,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts( var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { - ~ -!!! error TS1109: Expression expected. + ~~~~~ +!!! error TS2304: Cannot find name 'await'. } } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js index b1859159c92..9bf3fdc480f 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.js +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -9,6 +9,6 @@ var bar = async (): Promise => { //// [asyncArrowFunction7_es6.js] var bar = () => __awaiter(function *() { // 'await' here is an identifier, and not an await expression. - var foo = (...arguments_1) => __awaiter(function *(a = yield ) { + var foo = (...arguments_1) => __awaiter(function *(a = await) { }.apply(this, arguments_1), Promise); }.apply(this), Promise); diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt deleted file mode 100644 index 623095e8a5e..00000000000 --- a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt +++ /dev/null @@ -1,23 +0,0 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,11): error TS2304: Cannot find name 'async'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,18): error TS2304: Cannot find name 'a'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,37): error TS1005: ',' expected. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,39): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,46): error TS1005: '=' expected. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,53): error TS1109: Expression expected. - - -==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts (6 errors) ==== - var foo = async (a = await => await): Promise => { - ~~~~~ -!!! error TS2304: Cannot find name 'async'. - ~ -!!! error TS2304: Cannot find name 'a'. - ~ -!!! error TS1005: ',' expected. - ~~~~~~~ -!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. - ~ -!!! error TS1005: '=' expected. - ~~ -!!! error TS1109: Expression expected. - } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.js b/tests/baselines/reference/asyncArrowFunction9_es6.js index fb2f9d28a17..b78a49afdbb 100644 --- a/tests/baselines/reference/asyncArrowFunction9_es6.js +++ b/tests/baselines/reference/asyncArrowFunction9_es6.js @@ -3,6 +3,5 @@ var foo = async (a = await => await): Promise => { } //// [asyncArrowFunction9_es6.js] -var foo = async(a = await => await), Promise = ; -{ -} +var foo = (...arguments_1) => __awaiter(function *(a = await => await) { +}.apply(this, arguments_1), Promise); diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.symbols b/tests/baselines/reference/asyncArrowFunction9_es6.symbols new file mode 100644 index 00000000000..8db4592f0e1 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es6.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts === +var foo = async (a = await => await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction9_es6.ts, 0, 3)) +>a : Symbol(a, Decl(asyncArrowFunction9_es6.ts, 0, 17)) +>await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) +>await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +} diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.types b/tests/baselines/reference/asyncArrowFunction9_es6.types new file mode 100644 index 00000000000..9f6244c4a0e --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts === +var foo = async (a = await => await): Promise => { +>foo : (a?: (await: any) => any) => Promise +>async (a = await => await): Promise => {} : (a?: (await: any) => any) => Promise +>a : (await: any) => any +>await => await : (await: any) => any +>await : any +>await : any +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt deleted file mode 100644 index 15ceb3e60c7..00000000000 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt +++ /dev/null @@ -1,26 +0,0 @@ -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,20): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,30): error TS1109: Expression expected. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS1138: Parameter declaration expected. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS2304: Cannot find name 'await'. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,38): error TS1005: ';' expected. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,39): error TS1128: Declaration or statement expected. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,53): error TS1109: Expression expected. - - -==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts (7 errors) ==== - async function foo(a = await => await): Promise { - ~~~~~~~~~ -!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. - ~~ -!!! error TS1109: Expression expected. - ~~~~~ -!!! error TS1138: Parameter declaration expected. - ~~~~~ -!!! error TS2304: Cannot find name 'await'. - ~ -!!! error TS1005: ';' expected. - ~ -!!! error TS1128: Declaration or statement expected. - ~ -!!! error TS1109: Expression expected. - } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js index 141c0cbab55..e85492bee70 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js @@ -3,5 +3,7 @@ async function foo(a = await => await): Promise { } //// [asyncFunctionDeclaration10_es6.js] -await; -Promise < void > {}; +function foo() { + return __awaiter(function *(a = await => await) { + }.apply(this, arguments), Promise); +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols new file mode 100644 index 00000000000..d4f4dcedcd0 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts === +async function foo(a = await => await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration10_es6.ts, 0, 0)) +>a : Symbol(a, Decl(asyncFunctionDeclaration10_es6.ts, 0, 19)) +>await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) +>await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.types b/tests/baselines/reference/asyncFunctionDeclaration10_es6.types new file mode 100644 index 00000000000..0018b994e00 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts === +async function foo(a = await => await): Promise { +>foo : (a?: (await: any) => any) => Promise +>a : (await: any) => any +>await => await : (await: any) => any +>await : any +>await : any +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt index e719ed801e6..e89029e7c5f 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt @@ -1,8 +1,8 @@ -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts(1,29): error TS1109: Expression expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts(1,24): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts (1 errors) ==== async function foo(a = await): Promise { - ~ -!!! error TS1109: Expression expected. + ~~~~~ +!!! error TS2304: Cannot find name 'await'. } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js index 2a3ffaa94dd..663e02604ea 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js @@ -4,6 +4,6 @@ async function foo(a = await): Promise { //// [asyncFunctionDeclaration6_es6.js] function foo() { - return __awaiter(function *(a = yield ) { + return __awaiter(function *(a = await) { }.apply(this, arguments), Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt index 01643ffcdbb..b29fed652d8 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt @@ -1,11 +1,11 @@ -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts(3,31): error TS1109: Expression expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts(3,26): error TS2304: Cannot find name 'await'. ==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts (1 errors) ==== async function bar(): Promise { // 'await' here is an identifier, and not a yield expression. async function foo(a = await): Promise { - ~ -!!! error TS1109: Expression expected. + ~~~~~ +!!! error TS2304: Cannot find name 'await'. } } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js index c22870b08fe..fb913e3f6f4 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js @@ -10,7 +10,7 @@ function bar() { return __awaiter(function *() { // 'await' here is an identifier, and not a yield expression. function foo() { - return __awaiter(function *(a = yield ) { + return __awaiter(function *(a = await) { }.apply(this, arguments), Promise); } }.apply(this, arguments), Promise); From bca21ecf48bc3642c8174c0b258fc76fd427ef24 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 7 May 2015 18:30:38 -0700 Subject: [PATCH 010/309] Updated baselines --- .../reference/arrayLiterals2ES6.symbols | 6 +- .../reference/asyncArrowFunction1_es6.symbols | 2 +- .../reference/asyncArrowFunction9_es6.symbols | 2 +- .../asyncFunctionDeclaration10_es6.symbols | 2 +- .../asyncFunctionDeclaration11_es6.symbols | 2 +- .../asyncFunctionDeclaration14_es6.symbols | 2 +- .../asyncFunctionDeclaration1_es6.symbols | 2 +- .../awaitBinaryExpression1_es6.symbols | 4 +- .../awaitBinaryExpression2_es6.symbols | 4 +- .../awaitBinaryExpression3_es6.symbols | 4 +- .../awaitBinaryExpression4_es6.symbols | 4 +- .../awaitBinaryExpression5_es6.symbols | 4 +- .../awaitCallExpression1_es6.symbols | 8 +- .../awaitCallExpression2_es6.symbols | 8 +- .../awaitCallExpression3_es6.symbols | 8 +- .../awaitCallExpression4_es6.symbols | 8 +- .../awaitCallExpression5_es6.symbols | 8 +- .../awaitCallExpression6_es6.symbols | 8 +- .../awaitCallExpression7_es6.symbols | 8 +- .../awaitCallExpression8_es6.symbols | 8 +- .../reference/callWithSpreadES6.symbols | 2 +- ...tructuringParameterDeclaration3ES5.symbols | 16 +- ...tructuringParameterDeclaration3ES6.symbols | 16 +- ...owFunctionWhenUsingArguments14_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments15_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments16_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments17_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments18_ES6.symbols | 2 +- tests/baselines/reference/for-of13.symbols | 4 +- tests/baselines/reference/for-of18.symbols | 6 +- tests/baselines/reference/for-of19.symbols | 6 +- tests/baselines/reference/for-of20.symbols | 6 +- tests/baselines/reference/for-of21.symbols | 6 +- tests/baselines/reference/for-of22.symbols | 6 +- tests/baselines/reference/for-of23.symbols | 6 +- tests/baselines/reference/for-of25.symbols | 6 +- tests/baselines/reference/for-of26.symbols | 6 +- tests/baselines/reference/for-of27.symbols | 6 +- tests/baselines/reference/for-of28.symbols | 6 +- tests/baselines/reference/for-of37.symbols | 2 +- tests/baselines/reference/for-of38.symbols | 2 +- tests/baselines/reference/for-of40.symbols | 2 +- tests/baselines/reference/for-of44.symbols | 2 +- tests/baselines/reference/for-of45.symbols | 2 +- tests/baselines/reference/for-of50.symbols | 2 +- tests/baselines/reference/for-of57.symbols | 2 +- .../reference/iterableArrayPattern1.symbols | 8 +- .../reference/iterableArrayPattern11.symbols | 6 +- .../reference/iterableArrayPattern12.symbols | 6 +- .../reference/iterableArrayPattern13.symbols | 6 +- .../reference/iterableArrayPattern2.symbols | 8 +- .../reference/iterableArrayPattern3.symbols | 6 +- .../reference/iterableArrayPattern30.symbols | 2 +- .../reference/iterableArrayPattern4.symbols | 6 +- .../reference/iterableArrayPattern9.symbols | 6 +- .../iterableContextualTyping1.symbols | 2 +- .../reference/iteratorSpreadInArray.symbols | 8 +- .../reference/iteratorSpreadInArray11.symbols | 2 +- .../reference/iteratorSpreadInArray2.symbols | 14 +- .../reference/iteratorSpreadInArray3.symbols | 8 +- .../reference/iteratorSpreadInArray4.symbols | 8 +- .../reference/iteratorSpreadInArray7.symbols | 8 +- .../reference/iteratorSpreadInCall11.symbols | 8 +- .../reference/iteratorSpreadInCall12.symbols | 14 +- .../reference/iteratorSpreadInCall3.symbols | 8 +- .../reference/iteratorSpreadInCall5.symbols | 14 +- .../reference/parserSymbolProperty1.symbols | 6 +- .../reference/parserSymbolProperty2.symbols | 6 +- .../reference/parserSymbolProperty3.symbols | 6 +- .../reference/parserSymbolProperty4.symbols | 6 +- .../reference/parserSymbolProperty5.symbols | 6 +- .../reference/parserSymbolProperty6.symbols | 6 +- .../reference/parserSymbolProperty7.symbols | 6 +- .../reference/parserSymbolProperty8.symbols | 6 +- .../reference/parserSymbolProperty9.symbols | 6 +- .../promiseVoidErrorCallback.symbols | 16 +- .../reference/symbolDeclarationEmit1.symbols | 6 +- .../reference/symbolDeclarationEmit10.symbols | 12 +- .../reference/symbolDeclarationEmit11.symbols | 24 +- .../reference/symbolDeclarationEmit13.symbols | 12 +- .../reference/symbolDeclarationEmit14.symbols | 12 +- .../reference/symbolDeclarationEmit2.symbols | 6 +- .../reference/symbolDeclarationEmit3.symbols | 18 +- .../reference/symbolDeclarationEmit4.symbols | 12 +- .../reference/symbolDeclarationEmit5.symbols | 6 +- .../reference/symbolDeclarationEmit6.symbols | 6 +- .../reference/symbolDeclarationEmit7.symbols | 6 +- .../reference/symbolDeclarationEmit8.symbols | 6 +- .../reference/symbolDeclarationEmit9.symbols | 6 +- .../reference/symbolProperty11.symbols | 6 +- .../reference/symbolProperty13.symbols | 12 +- .../reference/symbolProperty14.symbols | 12 +- .../reference/symbolProperty15.symbols | 6 +- .../reference/symbolProperty16.symbols | 12 +- .../reference/symbolProperty18.symbols | 36 +- .../reference/symbolProperty19.symbols | 24 +- .../reference/symbolProperty2.symbols | 2 +- .../reference/symbolProperty20.symbols | 24 +- .../reference/symbolProperty21.symbols | 30 +- .../reference/symbolProperty22.symbols | 12 +- .../reference/symbolProperty23.symbols | 12 +- .../reference/symbolProperty26.symbols | 12 +- .../reference/symbolProperty27.symbols | 12 +- .../reference/symbolProperty28.symbols | 12 +- .../reference/symbolProperty4.symbols | 6 +- .../reference/symbolProperty40.symbols | 30 +- .../reference/symbolProperty41.symbols | 30 +- .../reference/symbolProperty45.symbols | 12 +- .../reference/symbolProperty5.symbols | 18 +- .../reference/symbolProperty50.symbols | 6 +- .../reference/symbolProperty51.symbols | 6 +- .../reference/symbolProperty55.symbols | 12 +- .../reference/symbolProperty56.symbols | 6 +- .../reference/symbolProperty57.symbols | 8 +- .../reference/symbolProperty6.symbols | 24 +- .../reference/symbolProperty8.symbols | 12 +- .../baselines/reference/symbolType11.symbols | 6 +- .../baselines/reference/symbolType16.symbols | 2 +- ...teStringWithEmbeddedNewOperatorES6.symbols | 2 +- tests/baselines/reference/typedArrays.symbols | 330 +++++++++--------- 120 files changed, 654 insertions(+), 654 deletions(-) diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols index 30f541751a1..f4b223379da 100644 --- a/tests/baselines/reference/arrayLiterals2ES6.symbols +++ b/tests/baselines/reference/arrayLiterals2ES6.symbols @@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]]; interface myArray extends Array { } >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) interface myArray2 extends Array { } >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) var d0 = [1, true, ...temp, ]; // has type (string|number|boolean)[] >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3)) diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols index dc2ed671c46..405121287a6 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols @@ -2,6 +2,6 @@ var foo = async (): Promise => { >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) }; diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.symbols b/tests/baselines/reference/asyncArrowFunction9_es6.symbols index 8db4592f0e1..7c50a463248 100644 --- a/tests/baselines/reference/asyncArrowFunction9_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction9_es6.symbols @@ -4,5 +4,5 @@ var foo = async (a = await => await): Promise => { >a : Symbol(a, Decl(asyncArrowFunction9_es6.ts, 0, 17)) >await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) >await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols index d4f4dcedcd0..76ed959e0af 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols @@ -4,5 +4,5 @@ async function foo(a = await => await): Promise { >a : Symbol(a, Decl(asyncFunctionDeclaration10_es6.ts, 0, 19)) >await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) >await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols index b4320296373..ec477460202 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts === async function await(): Promise { >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols index 5354c67a195..0cbcb69685c 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts === async function foo(): Promise { >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) return; } diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols index 241290a4899..9631076c084 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts === async function foo(): Promise { >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) } diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols index 373086ecbac..6df30c99fa5 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = await p || a; diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols index 9331ad13ce5..af1c2e3395a 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = await p && a; diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols index b1acda70136..6983f2c73ab 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols @@ -4,11 +4,11 @@ declare var a: number; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = await p + a; diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols index c1a3bd903f4..42f6730ad66 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = await p, a; diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols index cb74dcff7f6..4f5d853c68f 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var o: { a: boolean; }; diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols index f9756da1768..4065e1e0e02 100644 --- a/tests/baselines/reference/awaitCallExpression1_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = fn(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols index 2e5b8761163..a4b36cbc13c 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = fn(await p, a, a); diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols index 331fbeb8e6e..184c80fde62 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = fn(a, await p, a); diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols index cc3407610b7..f8a7bbe037b 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = (await pfn)(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols index 0063434d0fb..58a0553533e 100644 --- a/tests/baselines/reference/awaitCallExpression5_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = o.fn(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols index 9f99f55f26c..48262825ed9 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = o.fn(await p, a, a); diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols index d9dd6535bc2..85f172d03e4 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = o.fn(a, await p, a); diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols index 1a2097d041d..a1b9798b4c2 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) "before"; var b = (await po).fn(a, a, a); diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols index c29c41bff20..c642152ebc3 100644 --- a/tests/baselines/reference/callWithSpreadES6.symbols +++ b/tests/baselines/reference/callWithSpreadES6.symbols @@ -94,7 +94,7 @@ xa[1].foo(1, 2, ...a, "abc"); >a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) (xa[1].foo)(...[1, 2, "abc"]); ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 1366, 1)) +>Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 1367, 1)) >xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) >xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols index 6a4eb82af97..acb0e91ab3e 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols @@ -8,18 +8,18 @@ type arrayString = Array >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) type someArray = Array | number[]; >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) type stringOrNumArray = Array; >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) function a1(...x: (number|string)[]) { } @@ -33,8 +33,8 @@ function a2(...a) { } function a3(...a: Array) { } >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) function a4(...a: arrayString) { } >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols index 22340c6aa60..08a61e4fb0c 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols @@ -8,18 +8,18 @@ type arrayString = Array >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) type someArray = Array | number[]; >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) type stringOrNumArray = Array; >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) function a1(...x: (number|string)[]) { } @@ -33,8 +33,8 @@ function a2(...a) { } function a3(...a: Array) { } >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) function a4(...a: arrayString) { } >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols index 611db6485b9..7e69e1c51ae 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols @@ -5,7 +5,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1706, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) let arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols index 7a3c2620424..083b2713d18 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols @@ -8,7 +8,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1706, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) const arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols index c9658b4d90d..403bf7d4946 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols @@ -8,7 +8,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1706, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments[0]; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols index df5ab202dfc..ed79ccc0e5d 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols @@ -9,7 +9,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1706, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments[0]; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols index c4fc2e434e8..15baf6aca1c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols @@ -9,7 +9,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1706, 1)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments; diff --git a/tests/baselines/reference/for-of13.symbols b/tests/baselines/reference/for-of13.symbols index bcd19f1a4d4..bc4595f73cf 100644 --- a/tests/baselines/reference/for-of13.symbols +++ b/tests/baselines/reference/for-of13.symbols @@ -4,6 +4,6 @@ var v: string; for (v of [""].values()) { } >v : Symbol(v, Decl(for-of13.ts, 0, 3)) ->[""].values : Symbol(Array.values, Decl(lib.d.ts, 1464, 37)) ->values : Symbol(Array.values, Decl(lib.d.ts, 1464, 37)) +>[""].values : Symbol(Array.values, Decl(lib.d.ts, 1465, 37)) +>values : Symbol(Array.values, Decl(lib.d.ts, 1465, 37)) diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols index a61af492538..f5688d73566 100644 --- a/tests/baselines/reference/for-of18.symbols +++ b/tests/baselines/reference/for-of18.symbols @@ -22,9 +22,9 @@ class StringIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(StringIterator, Decl(for-of18.ts, 1, 33)) diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols index c2d2d078415..182d45a3369 100644 --- a/tests/baselines/reference/for-of19.symbols +++ b/tests/baselines/reference/for-of19.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(for-of19.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols index 251a5b28fca..4697f3283a6 100644 --- a/tests/baselines/reference/for-of20.symbols +++ b/tests/baselines/reference/for-of20.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(for-of20.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols index 0b6b6f23cc0..fcaf9b069dc 100644 --- a/tests/baselines/reference/for-of21.symbols +++ b/tests/baselines/reference/for-of21.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(for-of21.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols index cc4fcf55a7c..f72094cdf4f 100644 --- a/tests/baselines/reference/for-of22.symbols +++ b/tests/baselines/reference/for-of22.symbols @@ -28,9 +28,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(for-of22.ts, 5, 13)) diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols index 8c7455a2dbc..205a57d2c07 100644 --- a/tests/baselines/reference/for-of23.symbols +++ b/tests/baselines/reference/for-of23.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(for-of23.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of25.symbols b/tests/baselines/reference/for-of25.symbols index dae7d4bae7f..6ff68dea5d4 100644 --- a/tests/baselines/reference/for-of25.symbols +++ b/tests/baselines/reference/for-of25.symbols @@ -10,9 +10,9 @@ class StringIterator { >StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 1, 37)) [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return x; >x : Symbol(x, Decl(for-of25.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of26.symbols b/tests/baselines/reference/for-of26.symbols index 34766b1bc8c..19e917e7190 100644 --- a/tests/baselines/reference/for-of26.symbols +++ b/tests/baselines/reference/for-of26.symbols @@ -16,9 +16,9 @@ class StringIterator { >x : Symbol(x, Decl(for-of26.ts, 0, 3)) } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(StringIterator, Decl(for-of26.ts, 1, 37)) diff --git a/tests/baselines/reference/for-of27.symbols b/tests/baselines/reference/for-of27.symbols index aa44808cd73..edf8ab0a84c 100644 --- a/tests/baselines/reference/for-of27.symbols +++ b/tests/baselines/reference/for-of27.symbols @@ -7,7 +7,7 @@ class StringIterator { >StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 37)) [Symbol.iterator]: any; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) } diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols index caf0356df22..d569ffae2f6 100644 --- a/tests/baselines/reference/for-of28.symbols +++ b/tests/baselines/reference/for-of28.symbols @@ -10,9 +10,9 @@ class StringIterator { >next : Symbol(next, Decl(for-of28.ts, 2, 22)) [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(StringIterator, Decl(for-of28.ts, 0, 37)) diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols index 73455ff17e6..17c30514ffc 100644 --- a/tests/baselines/reference/for-of37.symbols +++ b/tests/baselines/reference/for-of37.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of37.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of37.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1879, 1), Decl(lib.d.ts, 1901, 11)) for (var v of map) { >v : Symbol(v, Decl(for-of37.ts, 1, 8)) diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols index bfbe035730c..118d687659f 100644 --- a/tests/baselines/reference/for-of38.symbols +++ b/tests/baselines/reference/for-of38.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of38.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of38.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1879, 1), Decl(lib.d.ts, 1901, 11)) for (var [k, v] of map) { >k : Symbol(k, Decl(for-of38.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols index ed6ecb128f7..b916ffc3bf5 100644 --- a/tests/baselines/reference/for-of40.symbols +++ b/tests/baselines/reference/for-of40.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of40.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of40.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1879, 1), Decl(lib.d.ts, 1901, 11)) for (var [k = "", v = false] of map) { >k : Symbol(k, Decl(for-of40.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of44.symbols b/tests/baselines/reference/for-of44.symbols index adcd2ae3760..2c4ebb582f9 100644 --- a/tests/baselines/reference/for-of44.symbols +++ b/tests/baselines/reference/for-of44.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of44.ts === var array: [number, string | boolean | symbol][] = [[0, ""], [0, true], [1, Symbol()]] >array : Symbol(array, Decl(for-of44.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) for (var [num, strBoolSym] of array) { >num : Symbol(num, Decl(for-of44.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols index 2f4a8511147..83ab93a9b60 100644 --- a/tests/baselines/reference/for-of45.symbols +++ b/tests/baselines/reference/for-of45.symbols @@ -5,7 +5,7 @@ var k: string, v: boolean; var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of45.ts, 1, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1879, 1), Decl(lib.d.ts, 1901, 11)) for ([k = "", v = false] of map) { >k : Symbol(k, Decl(for-of45.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols index 6813cd4eee5..f11290b9879 100644 --- a/tests/baselines/reference/for-of50.symbols +++ b/tests/baselines/reference/for-of50.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of50.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of50.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1879, 1), Decl(lib.d.ts, 1901, 11)) for (const [k, v] of map) { >k : Symbol(k, Decl(for-of50.ts, 1, 12)) diff --git a/tests/baselines/reference/for-of57.symbols b/tests/baselines/reference/for-of57.symbols index e8be8da6f9c..9f3862e1017 100644 --- a/tests/baselines/reference/for-of57.symbols +++ b/tests/baselines/reference/for-of57.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of57.ts === var iter: Iterable; >iter : Symbol(iter, Decl(for-of57.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1675, 1)) for (let num of iter) { } >num : Symbol(num, Decl(for-of57.ts, 1, 8)) diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols index 02f2ad6e8ef..d7877b5947a 100644 --- a/tests/baselines/reference/iterableArrayPattern1.symbols +++ b/tests/baselines/reference/iterableArrayPattern1.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iterableArrayPattern1.ts, 3, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iterableArrayPattern1.ts, 4, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iterableArrayPattern1.ts, 0, 32)) diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols index 9bbe4bfb983..a4dae0104c8 100644 --- a/tests/baselines/reference/iterableArrayPattern11.symbols +++ b/tests/baselines/reference/iterableArrayPattern11.symbols @@ -36,9 +36,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern11.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols index 1a8634862ea..124fc600b06 100644 --- a/tests/baselines/reference/iterableArrayPattern12.symbols +++ b/tests/baselines/reference/iterableArrayPattern12.symbols @@ -36,9 +36,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern12.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols index 3c8a8c1ba52..43641993f34 100644 --- a/tests/baselines/reference/iterableArrayPattern13.symbols +++ b/tests/baselines/reference/iterableArrayPattern13.symbols @@ -35,9 +35,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern13.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols index a28e682c9ed..ded5eea8726 100644 --- a/tests/baselines/reference/iterableArrayPattern2.symbols +++ b/tests/baselines/reference/iterableArrayPattern2.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iterableArrayPattern2.ts, 3, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iterableArrayPattern2.ts, 4, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iterableArrayPattern2.ts, 0, 35)) diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols index 46087c2f8bb..85ecd34218b 100644 --- a/tests/baselines/reference/iterableArrayPattern3.symbols +++ b/tests/baselines/reference/iterableArrayPattern3.symbols @@ -37,9 +37,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern3.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols index e4c5de17704..db22e31429e 100644 --- a/tests/baselines/reference/iterableArrayPattern30.symbols +++ b/tests/baselines/reference/iterableArrayPattern30.symbols @@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]) >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11)) >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18)) >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21)) ->Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1879, 1), Decl(lib.d.ts, 1901, 11)) diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols index 2b0c26918e4..b6b569d15c6 100644 --- a/tests/baselines/reference/iterableArrayPattern4.symbols +++ b/tests/baselines/reference/iterableArrayPattern4.symbols @@ -37,9 +37,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern4.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols index 90adcfeba92..0722765c4de 100644 --- a/tests/baselines/reference/iterableArrayPattern9.symbols +++ b/tests/baselines/reference/iterableArrayPattern9.symbols @@ -32,9 +32,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern9.ts, 2, 27)) diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols index 43c6d7135e0..0270830ca79 100644 --- a/tests/baselines/reference/iterableContextualTyping1.symbols +++ b/tests/baselines/reference/iterableContextualTyping1.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts === var iter: Iterable<(x: string) => number> = [s => s.length]; >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1675, 1)) >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20)) >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45)) >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols index 3c1cf17480d..e7085745aa7 100644 --- a/tests/baselines/reference/iteratorSpreadInArray.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray.ts, 0, 36)) diff --git a/tests/baselines/reference/iteratorSpreadInArray11.symbols b/tests/baselines/reference/iteratorSpreadInArray11.symbols index d1eb5420ef1..8d276ae5554 100644 --- a/tests/baselines/reference/iteratorSpreadInArray11.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray11.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts === var iter: Iterable; >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1675, 1)) var array = [...iter]; >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3)) diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols index 42c7e7e626e..7bc6808d849 100644 --- a/tests/baselines/reference/iteratorSpreadInArray2.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray2.ts, 5, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray2.ts, 0, 59)) @@ -48,9 +48,9 @@ class NumberIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(NumberIterator, Decl(iteratorSpreadInArray2.ts, 13, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols index 8a7abd3f195..bded5309f83 100644 --- a/tests/baselines/reference/iteratorSpreadInArray3.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray3.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray3.ts, 0, 47)) diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols index 03aca3c69b3..0dbe4711e95 100644 --- a/tests/baselines/reference/iteratorSpreadInArray4.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray4.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray4.ts, 0, 42)) diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols index e8c6571943e..50725a3f99f 100644 --- a/tests/baselines/reference/iteratorSpreadInArray7.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols @@ -17,7 +17,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray7.ts, 6, 28)) @@ -26,9 +26,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 1, 38)) diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols index d695457621f..ac52c5d172a 100644 --- a/tests/baselines/reference/iteratorSpreadInCall11.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols @@ -19,7 +19,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 6, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall11.ts, 7, 28)) @@ -28,9 +28,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall11.ts, 2, 42)) diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols index 58ed5ea4935..8ac205edcc5 100644 --- a/tests/baselines/reference/iteratorSpreadInCall12.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols @@ -22,7 +22,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 8, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall12.ts, 9, 28)) @@ -31,9 +31,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall12.ts, 4, 1)) @@ -57,9 +57,9 @@ class StringIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 17, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols index ac81fdea261..12e4bd1bb9b 100644 --- a/tests/baselines/reference/iteratorSpreadInCall3.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols @@ -16,7 +16,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall3.ts, 6, 28)) @@ -25,9 +25,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall3.ts, 2, 32)) diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols index da79720409d..06226958069 100644 --- a/tests/baselines/reference/iteratorSpreadInCall5.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols @@ -17,7 +17,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall5.ts, 6, 28)) @@ -26,9 +26,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall5.ts, 2, 43)) @@ -52,9 +52,9 @@ class StringIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) return this; >this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 14, 1)) diff --git a/tests/baselines/reference/parserSymbolProperty1.symbols b/tests/baselines/reference/parserSymbolProperty1.symbols index 9b0b706077d..72d4ad96aac 100644 --- a/tests/baselines/reference/parserSymbolProperty1.symbols +++ b/tests/baselines/reference/parserSymbolProperty1.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(parserSymbolProperty1.ts, 0, 0)) [Symbol.iterator]: string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) } diff --git a/tests/baselines/reference/parserSymbolProperty2.symbols b/tests/baselines/reference/parserSymbolProperty2.symbols index f13748e9996..77eb6c61059 100644 --- a/tests/baselines/reference/parserSymbolProperty2.symbols +++ b/tests/baselines/reference/parserSymbolProperty2.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(parserSymbolProperty2.ts, 0, 0)) [Symbol.unscopables](): string; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty3.symbols b/tests/baselines/reference/parserSymbolProperty3.symbols index cb4ff68a637..5f7f13956a8 100644 --- a/tests/baselines/reference/parserSymbolProperty3.symbols +++ b/tests/baselines/reference/parserSymbolProperty3.symbols @@ -3,7 +3,7 @@ declare class C { >C : Symbol(C, Decl(parserSymbolProperty3.ts, 0, 0)) [Symbol.unscopables](): string; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty4.symbols b/tests/baselines/reference/parserSymbolProperty4.symbols index 34f550b750b..94701b8908a 100644 --- a/tests/baselines/reference/parserSymbolProperty4.symbols +++ b/tests/baselines/reference/parserSymbolProperty4.symbols @@ -3,7 +3,7 @@ declare class C { >C : Symbol(C, Decl(parserSymbolProperty4.ts, 0, 0)) [Symbol.toPrimitive]: string; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty5.symbols b/tests/baselines/reference/parserSymbolProperty5.symbols index 5257941831b..b91cd771c5d 100644 --- a/tests/baselines/reference/parserSymbolProperty5.symbols +++ b/tests/baselines/reference/parserSymbolProperty5.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty5.ts, 0, 0)) [Symbol.toPrimitive]: string; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty6.symbols b/tests/baselines/reference/parserSymbolProperty6.symbols index 77770a62bd5..4762fb4fd70 100644 --- a/tests/baselines/reference/parserSymbolProperty6.symbols +++ b/tests/baselines/reference/parserSymbolProperty6.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty6.ts, 0, 0)) [Symbol.toStringTag]: string = ""; ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty7.symbols b/tests/baselines/reference/parserSymbolProperty7.symbols index 3e912a18a2f..0eb96fa03b0 100644 --- a/tests/baselines/reference/parserSymbolProperty7.symbols +++ b/tests/baselines/reference/parserSymbolProperty7.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty7.ts, 0, 0)) [Symbol.toStringTag](): void { } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty8.symbols b/tests/baselines/reference/parserSymbolProperty8.symbols index dcf4a037db2..cc11d61259e 100644 --- a/tests/baselines/reference/parserSymbolProperty8.symbols +++ b/tests/baselines/reference/parserSymbolProperty8.symbols @@ -3,7 +3,7 @@ var x: { >x : Symbol(x, Decl(parserSymbolProperty8.ts, 0, 3)) [Symbol.toPrimitive](): string ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty9.symbols b/tests/baselines/reference/parserSymbolProperty9.symbols index f706a35e3b5..eae90071b65 100644 --- a/tests/baselines/reference/parserSymbolProperty9.symbols +++ b/tests/baselines/reference/parserSymbolProperty9.symbols @@ -3,7 +3,7 @@ var x: { >x : Symbol(x, Decl(parserSymbolProperty9.ts, 0, 3)) [Symbol.toPrimitive]: string ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) } diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols index 78faacdb1f1..d9e329885aa 100644 --- a/tests/baselines/reference/promiseVoidErrorCallback.symbols +++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols @@ -22,13 +22,13 @@ interface T3 { function f1(): Promise { >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4854, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0)) return Promise.resolve({ __t1: "foo_t1" }); ->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4836, 39), Decl(lib.d.ts, 4843, 54)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4854, 11)) ->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4836, 39), Decl(lib.d.ts, 4843, 54)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54)) >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28)) } @@ -47,12 +47,12 @@ function f2(x: T1): T2 { var x3 = f1() >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3)) ->f1() .then(f2, (e: Error) => { throw e;}) .then : Symbol(Promise.then, Decl(lib.d.ts, 4774, 22), Decl(lib.d.ts, 4781, 158)) ->f1() .then : Symbol(Promise.then, Decl(lib.d.ts, 4774, 22), Decl(lib.d.ts, 4781, 158)) +>f1() .then(f2, (e: Error) => { throw e;}) .then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158)) +>f1() .then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158)) >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) .then(f2, (e: Error) => { ->then : Symbol(Promise.then, Decl(lib.d.ts, 4774, 22), Decl(lib.d.ts, 4781, 158)) +>then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158)) >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1)) >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15)) >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) @@ -62,7 +62,7 @@ var x3 = f1() }) .then((x: T2) => { ->then : Symbol(Promise.then, Decl(lib.d.ts, 4774, 22), Decl(lib.d.ts, 4781, 158)) +>then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158)) >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11)) >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1)) diff --git a/tests/baselines/reference/symbolDeclarationEmit1.symbols b/tests/baselines/reference/symbolDeclarationEmit1.symbols index 6b17c421a07..0b0e820404b 100644 --- a/tests/baselines/reference/symbolDeclarationEmit1.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit1.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit1.ts, 0, 0)) [Symbol.toPrimitive]: number; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols index e620614d829..5ed853abd19 100644 --- a/tests/baselines/reference/symbolDeclarationEmit10.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols @@ -3,13 +3,13 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3)) get [Symbol.isConcatSpreadable]() { return '' }, ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) set [Symbol.isConcatSpreadable](x) { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) >x : Symbol(x, Decl(symbolDeclarationEmit10.ts, 2, 36)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit11.symbols b/tests/baselines/reference/symbolDeclarationEmit11.symbols index 3cbae021c32..44115a3e730 100644 --- a/tests/baselines/reference/symbolDeclarationEmit11.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit11.symbols @@ -3,23 +3,23 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit11.ts, 0, 0)) static [Symbol.iterator] = 0; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) static [Symbol.isConcatSpreadable]() { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) static get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) static set [Symbol.toPrimitive](x) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit11.ts, 4, 36)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit13.symbols b/tests/baselines/reference/symbolDeclarationEmit13.symbols index 9e6b00fbc45..a0aa4e1142a 100644 --- a/tests/baselines/reference/symbolDeclarationEmit13.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit13.symbols @@ -3,13 +3,13 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit13.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) set [Symbol.toStringTag](x) { } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) >x : Symbol(x, Decl(symbolDeclarationEmit13.ts, 2, 29)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit14.symbols b/tests/baselines/reference/symbolDeclarationEmit14.symbols index 610a6bae9cd..0acef2d8a71 100644 --- a/tests/baselines/reference/symbolDeclarationEmit14.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit14.symbols @@ -3,12 +3,12 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit14.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) get [Symbol.toStringTag]() { return ""; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit2.symbols b/tests/baselines/reference/symbolDeclarationEmit2.symbols index e0ba5ffc72a..bfcf6243d9e 100644 --- a/tests/baselines/reference/symbolDeclarationEmit2.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit2.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit2.ts, 0, 0)) [Symbol.toPrimitive] = ""; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit3.symbols b/tests/baselines/reference/symbolDeclarationEmit3.symbols index 712b233a744..fcfcd0efe14 100644 --- a/tests/baselines/reference/symbolDeclarationEmit3.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit3.symbols @@ -3,20 +3,20 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit3.ts, 0, 0)) [Symbol.toPrimitive](x: number); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 1, 25)) [Symbol.toPrimitive](x: string); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 2, 25)) [Symbol.toPrimitive](x: any) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 3, 25)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit4.symbols b/tests/baselines/reference/symbolDeclarationEmit4.symbols index 3a24de2f0e3..28d4602b181 100644 --- a/tests/baselines/reference/symbolDeclarationEmit4.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit4.symbols @@ -3,13 +3,13 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit4.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) set [Symbol.toPrimitive](x) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit4.ts, 2, 29)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit5.symbols b/tests/baselines/reference/symbolDeclarationEmit5.symbols index 5580b833c08..c8a7ab36e94 100644 --- a/tests/baselines/reference/symbolDeclarationEmit5.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit5.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(symbolDeclarationEmit5.ts, 0, 0)) [Symbol.isConcatSpreadable](): string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit6.symbols b/tests/baselines/reference/symbolDeclarationEmit6.symbols index 10c95ed620b..d535c8ce1ec 100644 --- a/tests/baselines/reference/symbolDeclarationEmit6.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit6.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(symbolDeclarationEmit6.ts, 0, 0)) [Symbol.isConcatSpreadable]: string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit7.symbols b/tests/baselines/reference/symbolDeclarationEmit7.symbols index 42f6b866867..0860dae4a27 100644 --- a/tests/baselines/reference/symbolDeclarationEmit7.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit7.symbols @@ -3,7 +3,7 @@ var obj: { >obj : Symbol(obj, Decl(symbolDeclarationEmit7.ts, 0, 3)) [Symbol.isConcatSpreadable]: string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols index 13331a49dc3..21faad44029 100644 --- a/tests/baselines/reference/symbolDeclarationEmit8.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols @@ -3,7 +3,7 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3)) [Symbol.isConcatSpreadable]: 0 ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols index 2b6984b6bae..9212123105d 100644 --- a/tests/baselines/reference/symbolDeclarationEmit9.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols @@ -3,7 +3,7 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3)) [Symbol.isConcatSpreadable]() { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) } diff --git a/tests/baselines/reference/symbolProperty11.symbols b/tests/baselines/reference/symbolProperty11.symbols index bff61ccc014..952846d768d 100644 --- a/tests/baselines/reference/symbolProperty11.symbols +++ b/tests/baselines/reference/symbolProperty11.symbols @@ -6,9 +6,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty11.ts, 0, 11)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty11.ts, 2, 25)) } diff --git a/tests/baselines/reference/symbolProperty13.symbols b/tests/baselines/reference/symbolProperty13.symbols index 1b0026c5ea4..3b5685d1d77 100644 --- a/tests/baselines/reference/symbolProperty13.symbols +++ b/tests/baselines/reference/symbolProperty13.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(symbolProperty13.ts, 0, 0)) [Symbol.iterator]: { x; y }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty13.ts, 1, 24)) >y : Symbol(y, Decl(symbolProperty13.ts, 1, 27)) } @@ -13,9 +13,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty13.ts, 2, 1)) [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty13.ts, 4, 24)) } diff --git a/tests/baselines/reference/symbolProperty14.symbols b/tests/baselines/reference/symbolProperty14.symbols index 358819f47b3..b47ae5d912d 100644 --- a/tests/baselines/reference/symbolProperty14.symbols +++ b/tests/baselines/reference/symbolProperty14.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(symbolProperty14.ts, 0, 0)) [Symbol.iterator]: { x; y }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty14.ts, 1, 24)) >y : Symbol(y, Decl(symbolProperty14.ts, 1, 27)) } @@ -13,9 +13,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty14.ts, 2, 1)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty14.ts, 4, 25)) } diff --git a/tests/baselines/reference/symbolProperty15.symbols b/tests/baselines/reference/symbolProperty15.symbols index fe630f8f82d..ac05eb6195e 100644 --- a/tests/baselines/reference/symbolProperty15.symbols +++ b/tests/baselines/reference/symbolProperty15.symbols @@ -6,9 +6,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty15.ts, 0, 11)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty15.ts, 2, 25)) } diff --git a/tests/baselines/reference/symbolProperty16.symbols b/tests/baselines/reference/symbolProperty16.symbols index d87416cd43a..c45b22056af 100644 --- a/tests/baselines/reference/symbolProperty16.symbols +++ b/tests/baselines/reference/symbolProperty16.symbols @@ -3,18 +3,18 @@ class C { >C : Symbol(C, Decl(symbolProperty16.ts, 0, 0)) private [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty16.ts, 1, 32)) } interface I { >I : Symbol(I, Decl(symbolProperty16.ts, 2, 1)) [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty16.ts, 4, 24)) } diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols index 4597eb81c0f..40c5a86c0e9 100644 --- a/tests/baselines/reference/symbolProperty18.symbols +++ b/tests/baselines/reference/symbolProperty18.symbols @@ -3,39 +3,39 @@ var i = { >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) [Symbol.iterator]: 0, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) [Symbol.toStringTag]() { return "" }, ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) set [Symbol.toPrimitive](p: boolean) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) >p : Symbol(p, Decl(symbolProperty18.ts, 3, 29)) } var it = i[Symbol.iterator]; >it : Symbol(it, Decl(symbolProperty18.ts, 6, 3)) >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) var str = i[Symbol.toStringTag](); >str : Symbol(str, Decl(symbolProperty18.ts, 7, 3)) >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) i[Symbol.toPrimitive] = false; >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols index d3295b6507e..909c6394ec2 100644 --- a/tests/baselines/reference/symbolProperty19.symbols +++ b/tests/baselines/reference/symbolProperty19.symbols @@ -3,15 +3,15 @@ var i = { >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) [Symbol.iterator]: { p: null }, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >p : Symbol(p, Decl(symbolProperty19.ts, 1, 24)) [Symbol.toStringTag]() { return { p: undefined }; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37)) >undefined : Symbol(undefined) } @@ -19,14 +19,14 @@ var i = { var it = i[Symbol.iterator]; >it : Symbol(it, Decl(symbolProperty19.ts, 5, 3)) >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) var str = i[Symbol.toStringTag](); >str : Symbol(str, Decl(symbolProperty19.ts, 6, 3)) >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols index ea698562ed2..9d618e7751f 100644 --- a/tests/baselines/reference/symbolProperty2.symbols +++ b/tests/baselines/reference/symbolProperty2.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/Symbols/symbolProperty2.ts === var s = Symbol(); >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) var x = { >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3)) diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols index 714b771b67e..b12874d028b 100644 --- a/tests/baselines/reference/symbolProperty20.symbols +++ b/tests/baselines/reference/symbolProperty20.symbols @@ -3,15 +3,15 @@ interface I { >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0)) [Symbol.iterator]: (s: string) => string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >s : Symbol(s, Decl(symbolProperty20.ts, 1, 24)) [Symbol.toStringTag](s: number): number; ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) >s : Symbol(s, Decl(symbolProperty20.ts, 2, 25)) } @@ -20,16 +20,16 @@ var i: I = { >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0)) [Symbol.iterator]: s => s, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22)) >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22)) [Symbol.toStringTag](n) { return n; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25)) >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25)) } diff --git a/tests/baselines/reference/symbolProperty21.symbols b/tests/baselines/reference/symbolProperty21.symbols index f2061b3bb2c..b0632e2eaae 100644 --- a/tests/baselines/reference/symbolProperty21.symbols +++ b/tests/baselines/reference/symbolProperty21.symbols @@ -5,15 +5,15 @@ interface I { >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14)) [Symbol.unscopables]: T; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) >T : Symbol(T, Decl(symbolProperty21.ts, 0, 12)) [Symbol.isConcatSpreadable]: U; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14)) } @@ -34,18 +34,18 @@ foo({ >foo : Symbol(foo, Decl(symbolProperty21.ts, 3, 1)) [Symbol.isConcatSpreadable]: "", ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) [Symbol.toPrimitive]: 0, ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) [Symbol.unscopables]: true ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) }); diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols index d1bee54bd7b..4c8ec1aa7f5 100644 --- a/tests/baselines/reference/symbolProperty22.symbols +++ b/tests/baselines/reference/symbolProperty22.symbols @@ -5,9 +5,9 @@ interface I { >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14)) [Symbol.unscopables](x: T): U; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) >x : Symbol(x, Decl(symbolProperty22.ts, 1, 25)) >T : Symbol(T, Decl(symbolProperty22.ts, 0, 12)) >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14)) @@ -27,9 +27,9 @@ declare function foo(p1: T, p2: I): U; foo("", { [Symbol.unscopables]: s => s.length }); >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1)) ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31)) >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31)) diff --git a/tests/baselines/reference/symbolProperty23.symbols b/tests/baselines/reference/symbolProperty23.symbols index 94dc416010e..a8ebaf95345 100644 --- a/tests/baselines/reference/symbolProperty23.symbols +++ b/tests/baselines/reference/symbolProperty23.symbols @@ -3,9 +3,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0)) [Symbol.toPrimitive]: () => boolean; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) } class C implements I { @@ -13,9 +13,9 @@ class C implements I { >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0)) [Symbol.toPrimitive]() { ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) return true; } diff --git a/tests/baselines/reference/symbolProperty26.symbols b/tests/baselines/reference/symbolProperty26.symbols index 0850ec9cdaa..b5c726712e4 100644 --- a/tests/baselines/reference/symbolProperty26.symbols +++ b/tests/baselines/reference/symbolProperty26.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) return ""; } @@ -16,9 +16,9 @@ class C2 extends C1 { >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) return ""; } diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols index ed56e55cca6..039963b02aa 100644 --- a/tests/baselines/reference/symbolProperty27.symbols +++ b/tests/baselines/reference/symbolProperty27.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) return {}; } @@ -16,9 +16,9 @@ class C2 extends C1 { >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) return ""; } diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols index e5cdbb0ea61..6ba9c126943 100644 --- a/tests/baselines/reference/symbolProperty28.symbols +++ b/tests/baselines/reference/symbolProperty28.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty28.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) return { x: "" }; >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) @@ -24,8 +24,8 @@ var obj = c[Symbol.toStringTag]().x; >obj : Symbol(obj, Decl(symbolProperty28.ts, 9, 3)) >c[Symbol.toStringTag]().x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) >c : Symbol(c, Decl(symbolProperty28.ts, 8, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols index 8a0d692de22..99961ec6629 100644 --- a/tests/baselines/reference/symbolProperty4.symbols +++ b/tests/baselines/reference/symbolProperty4.symbols @@ -3,13 +3,13 @@ var x = { >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3)) [Symbol()]: 0, ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) [Symbol()]() { }, ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) get [Symbol()]() { ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) return 0; } diff --git a/tests/baselines/reference/symbolProperty40.symbols b/tests/baselines/reference/symbolProperty40.symbols index 246d0952c89..62acefd45c2 100644 --- a/tests/baselines/reference/symbolProperty40.symbols +++ b/tests/baselines/reference/symbolProperty40.symbols @@ -3,21 +3,21 @@ class C { >C : Symbol(C, Decl(symbolProperty40.ts, 0, 0)) [Symbol.iterator](x: string): string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 1, 22)) [Symbol.iterator](x: number): number; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 2, 22)) [Symbol.iterator](x: any) { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 3, 22)) return undefined; @@ -31,13 +31,13 @@ var c = new C; c[Symbol.iterator](""); >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) c[Symbol.iterator](0); >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) diff --git a/tests/baselines/reference/symbolProperty41.symbols b/tests/baselines/reference/symbolProperty41.symbols index 2872f6cb134..1635419694d 100644 --- a/tests/baselines/reference/symbolProperty41.symbols +++ b/tests/baselines/reference/symbolProperty41.symbols @@ -3,24 +3,24 @@ class C { >C : Symbol(C, Decl(symbolProperty41.ts, 0, 0)) [Symbol.iterator](x: string): { x: string }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 1, 22)) >x : Symbol(x, Decl(symbolProperty41.ts, 1, 35)) [Symbol.iterator](x: "hello"): { x: string; hello: string }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 2, 22)) >x : Symbol(x, Decl(symbolProperty41.ts, 2, 36)) >hello : Symbol(hello, Decl(symbolProperty41.ts, 2, 47)) [Symbol.iterator](x: any) { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 3, 22)) return undefined; @@ -34,13 +34,13 @@ var c = new C; c[Symbol.iterator](""); >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) c[Symbol.iterator]("hello"); >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) diff --git a/tests/baselines/reference/symbolProperty45.symbols b/tests/baselines/reference/symbolProperty45.symbols index 1f691f8827d..67fce3aefab 100644 --- a/tests/baselines/reference/symbolProperty45.symbols +++ b/tests/baselines/reference/symbolProperty45.symbols @@ -3,16 +3,16 @@ class C { >C : Symbol(C, Decl(symbolProperty45.ts, 0, 0)) get [Symbol.hasInstance]() { ->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1233, 32)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1233, 32)) +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1234, 32)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1234, 32)) return ""; } get [Symbol.toPrimitive]() { ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) return ""; } diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols index e9bda77fd71..4dc58d689d8 100644 --- a/tests/baselines/reference/symbolProperty5.symbols +++ b/tests/baselines/reference/symbolProperty5.symbols @@ -3,19 +3,19 @@ var x = { >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3)) [Symbol.iterator]: 0, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) [Symbol.toPrimitive]() { }, ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) get [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) return 0; } diff --git a/tests/baselines/reference/symbolProperty50.symbols b/tests/baselines/reference/symbolProperty50.symbols index 69a695e6c5b..9201435c09e 100644 --- a/tests/baselines/reference/symbolProperty50.symbols +++ b/tests/baselines/reference/symbolProperty50.symbols @@ -9,8 +9,8 @@ module M { >C : Symbol(C, Decl(symbolProperty50.ts, 1, 24)) [Symbol.iterator]() { } ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) } } diff --git a/tests/baselines/reference/symbolProperty51.symbols b/tests/baselines/reference/symbolProperty51.symbols index e045d35f13f..199c51e65a3 100644 --- a/tests/baselines/reference/symbolProperty51.symbols +++ b/tests/baselines/reference/symbolProperty51.symbols @@ -9,8 +9,8 @@ module M { >C : Symbol(C, Decl(symbolProperty51.ts, 1, 21)) [Symbol.iterator]() { } ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) } } diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols index 077199e4969..95521c7e714 100644 --- a/tests/baselines/reference/symbolProperty55.symbols +++ b/tests/baselines/reference/symbolProperty55.symbols @@ -3,9 +3,9 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) }; @@ -14,13 +14,13 @@ module M { var Symbol: SymbolConstructor; >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7)) ->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 1207, 1)) +>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 1208, 1)) // The following should be of type 'any'. This is because even though obj has a property keyed by Symbol.iterator, // the key passed in here is the *wrong* Symbol.iterator. It is not the iterator property of the global Symbol. obj[Symbol.iterator]; >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) } diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols index a76ab0418cc..97f9966e196 100644 --- a/tests/baselines/reference/symbolProperty56.symbols +++ b/tests/baselines/reference/symbolProperty56.symbols @@ -3,9 +3,9 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) }; diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols index e98cf963807..bc1497aaa14 100644 --- a/tests/baselines/reference/symbolProperty57.symbols +++ b/tests/baselines/reference/symbolProperty57.symbols @@ -3,14 +3,14 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) }; // Should give type 'any'. obj[Symbol["nonsense"]]; >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) diff --git a/tests/baselines/reference/symbolProperty6.symbols b/tests/baselines/reference/symbolProperty6.symbols index 8b0e62e4068..0dbda66432f 100644 --- a/tests/baselines/reference/symbolProperty6.symbols +++ b/tests/baselines/reference/symbolProperty6.symbols @@ -3,24 +3,24 @@ class C { >C : Symbol(C, Decl(symbolProperty6.ts, 0, 0)) [Symbol.iterator] = 0; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) [Symbol.unscopables]: number; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) [Symbol.toPrimitive]() { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) get [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) return 0; } diff --git a/tests/baselines/reference/symbolProperty8.symbols b/tests/baselines/reference/symbolProperty8.symbols index a1a4d1d50df..07f572b03bc 100644 --- a/tests/baselines/reference/symbolProperty8.symbols +++ b/tests/baselines/reference/symbolProperty8.symbols @@ -3,12 +3,12 @@ interface I { >I : Symbol(I, Decl(symbolProperty8.ts, 0, 0)) [Symbol.unscopables]: number; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) [Symbol.toPrimitive](); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) } diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols index 6c4001fa4c8..11be00dba40 100644 --- a/tests/baselines/reference/symbolType11.symbols +++ b/tests/baselines/reference/symbolType11.symbols @@ -1,9 +1,9 @@ === tests/cases/conformance/es6/Symbols/symbolType11.ts === var s = Symbol.for("logical"); >s : Symbol(s, Decl(symbolType11.ts, 0, 3)) ->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1219, 42)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11)) ->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1219, 42)) +>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1220, 42)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1220, 42)) s && s; >s : Symbol(s, Decl(symbolType11.ts, 0, 3)) diff --git a/tests/baselines/reference/symbolType16.symbols b/tests/baselines/reference/symbolType16.symbols index 7a54b0efcbe..7791f4ee2ba 100644 --- a/tests/baselines/reference/symbolType16.symbols +++ b/tests/baselines/reference/symbolType16.symbols @@ -1,6 +1,6 @@ === tests/cases/conformance/es6/Symbols/symbolType16.ts === interface Symbol { ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11), Decl(symbolType16.ts, 0, 0)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11), Decl(symbolType16.ts, 0, 0)) newSymbolProp: number; >newSymbolProp : Symbol(newSymbolProp, Decl(symbolType16.ts, 0, 18)) diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols index a6e319c0dfa..7feac825ac9 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols +++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts === var x = `abc${ new String("Hi") }def`; >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1550, 1)) diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols index ef9f533bb58..66499f844d3 100644 --- a/tests/baselines/reference/typedArrays.symbols +++ b/tests/baselines/reference/typedArrays.symbols @@ -8,39 +8,39 @@ function CreateTypedArrayTypes() { typedArrays[0] = Int8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2119, 42), Decl(lib.d.ts, 2409, 11)) typedArrays[1] = Uint8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2409, 44), Decl(lib.d.ts, 2699, 11)) typedArrays[2] = Int16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2989, 60), Decl(lib.d.ts, 3279, 11)) typedArrays[3] = Uint16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3279, 46), Decl(lib.d.ts, 3569, 11)) typedArrays[4] = Int32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3569, 48), Decl(lib.d.ts, 3859, 11)) typedArrays[5] = Uint32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3859, 46), Decl(lib.d.ts, 4149, 11)) typedArrays[6] = Float32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4149, 48), Decl(lib.d.ts, 4439, 11)) typedArrays[7] = Float64Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4439, 50), Decl(lib.d.ts, 4729, 11)) typedArrays[8] = Uint8ClampedArray; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2699, 46), Decl(lib.d.ts, 2989, 11)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) @@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2119, 42), Decl(lib.d.ts, 2409, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2409, 44), Decl(lib.d.ts, 2699, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2989, 60), Decl(lib.d.ts, 3279, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3279, 46), Decl(lib.d.ts, 3569, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3569, 48), Decl(lib.d.ts, 3859, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3859, 46), Decl(lib.d.ts, 4149, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4149, 48), Decl(lib.d.ts, 4439, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4439, 50), Decl(lib.d.ts, 4729, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2699, 46), Decl(lib.d.ts, 2989, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) return typedArrays; @@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2119, 42), Decl(lib.d.ts, 2409, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2409, 44), Decl(lib.d.ts, 2699, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2989, 60), Decl(lib.d.ts, 3279, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3279, 46), Decl(lib.d.ts, 3569, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3569, 48), Decl(lib.d.ts, 3859, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3859, 46), Decl(lib.d.ts, 4149, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4149, 48), Decl(lib.d.ts, 4439, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4439, 50), Decl(lib.d.ts, 4729, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2699, 46), Decl(lib.d.ts, 2989, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) return typedArrays; @@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2399, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2119, 42), Decl(lib.d.ts, 2409, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2399, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2689, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2409, 44), Decl(lib.d.ts, 2699, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2689, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3269, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2989, 60), Decl(lib.d.ts, 3279, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3269, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3559, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3279, 46), Decl(lib.d.ts, 3569, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3559, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3849, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3569, 48), Decl(lib.d.ts, 3859, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3849, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4139, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3859, 46), Decl(lib.d.ts, 4149, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4139, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4429, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4149, 48), Decl(lib.d.ts, 4439, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4429, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4719, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4439, 50), Decl(lib.d.ts, 4729, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4719, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2979, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2699, 46), Decl(lib.d.ts, 2989, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2979, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) return typedArrays; @@ -235,72 +235,72 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >CreateIntegerTypedArraysFromArrayLike : Symbol(CreateIntegerTypedArraysFromArrayLike, Decl(typedArrays.ts, 59, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1446, 1)) var typedArrays = []; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2399, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2119, 42), Decl(lib.d.ts, 2409, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2399, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2689, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2409, 44), Decl(lib.d.ts, 2699, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2689, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3269, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2989, 60), Decl(lib.d.ts, 3279, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3269, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3559, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3279, 46), Decl(lib.d.ts, 3569, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3559, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3849, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3569, 48), Decl(lib.d.ts, 3859, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3849, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4139, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3859, 46), Decl(lib.d.ts, 4149, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4139, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4429, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4149, 48), Decl(lib.d.ts, 4439, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4429, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4719, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4439, 50), Decl(lib.d.ts, 4729, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4719, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2979, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2699, 46), Decl(lib.d.ts, 2989, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2979, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) return typedArrays; @@ -332,57 +332,57 @@ function CreateTypedArraysOf2() { typedArrays[0] = Int8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2392, 30)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) ->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2392, 30)) +>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2393, 30)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2119, 42), Decl(lib.d.ts, 2409, 11)) +>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2393, 30)) typedArrays[1] = Uint8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2682, 30)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) ->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2682, 30)) +>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2683, 30)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2409, 44), Decl(lib.d.ts, 2699, 11)) +>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2683, 30)) typedArrays[2] = Int16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3262, 30)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) ->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3262, 30)) +>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3263, 30)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2989, 60), Decl(lib.d.ts, 3279, 11)) +>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3263, 30)) typedArrays[3] = Uint16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3552, 30)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) ->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3552, 30)) +>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3553, 30)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3279, 46), Decl(lib.d.ts, 3569, 11)) +>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3553, 30)) typedArrays[4] = Int32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3842, 30)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) ->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3842, 30)) +>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3843, 30)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3569, 48), Decl(lib.d.ts, 3859, 11)) +>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3843, 30)) typedArrays[5] = Uint32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4132, 30)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) ->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4132, 30)) +>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4133, 30)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3859, 46), Decl(lib.d.ts, 4149, 11)) +>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4133, 30)) typedArrays[6] = Float32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4422, 30)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) ->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4422, 30)) +>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4423, 30)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4149, 48), Decl(lib.d.ts, 4439, 11)) +>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4423, 30)) typedArrays[7] = Float64Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4712, 30)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) ->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4712, 30)) +>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4713, 30)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4439, 50), Decl(lib.d.ts, 4729, 11)) +>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4713, 30)) typedArrays[8] = Uint8ClampedArray.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2972, 30)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) ->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2972, 30)) +>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2973, 30)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2699, 46), Decl(lib.d.ts, 2989, 11)) +>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2973, 30)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) @@ -391,7 +391,7 @@ function CreateTypedArraysOf2() { function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:number)=> number) { >CreateTypedArraysFromMapFn : Symbol(CreateTypedArraysFromMapFn, Decl(typedArrays.ts, 106, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1446, 1)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) >n : Symbol(n, Decl(typedArrays.ts, 108, 67)) >v : Symbol(v, Decl(typedArrays.ts, 108, 76)) @@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n typedArrays[0] = Int8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2399, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2119, 42), Decl(lib.d.ts, 2409, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2399, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[1] = Uint8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2689, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2409, 44), Decl(lib.d.ts, 2699, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2689, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[2] = Int16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3269, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2989, 60), Decl(lib.d.ts, 3279, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3269, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[3] = Uint16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3559, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3279, 46), Decl(lib.d.ts, 3569, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3559, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[4] = Int32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3849, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3569, 48), Decl(lib.d.ts, 3859, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3849, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[5] = Uint32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4139, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3859, 46), Decl(lib.d.ts, 4149, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4139, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[6] = Float32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4429, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4149, 48), Decl(lib.d.ts, 4439, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4429, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[7] = Float64Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4719, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4439, 50), Decl(lib.d.ts, 4729, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4719, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2979, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2699, 46), Decl(lib.d.ts, 2989, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2979, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) @@ -478,7 +478,7 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v:number)=> number, thisArg: {}) { >CreateTypedArraysFromThisObj : Symbol(CreateTypedArraysFromThisObj, Decl(typedArrays.ts, 121, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1446, 1)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >n : Symbol(n, Decl(typedArrays.ts, 123, 69)) >v : Symbol(v, Decl(typedArrays.ts, 123, 78)) @@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v typedArrays[0] = Int8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2399, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2119, 42), Decl(lib.d.ts, 2409, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2399, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2689, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2409, 44), Decl(lib.d.ts, 2699, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2689, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[2] = Int16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3269, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2989, 60), Decl(lib.d.ts, 3279, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3269, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3559, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3279, 46), Decl(lib.d.ts, 3569, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3559, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[4] = Int32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3849, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3569, 48), Decl(lib.d.ts, 3859, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3849, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4139, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3859, 46), Decl(lib.d.ts, 4149, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4139, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[6] = Float32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4429, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4149, 48), Decl(lib.d.ts, 4439, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4429, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[7] = Float64Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4719, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4439, 50), Decl(lib.d.ts, 4729, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4719, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2979, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2699, 46), Decl(lib.d.ts, 2989, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2979, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) From 655f2ec74eb07cd3a5e3f1717da521b27a71a879 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 8 May 2015 16:51:35 -0700 Subject: [PATCH 011/309] Cleanup and PR feedback --- src/compiler/checker.ts | 210 ++++++++++++------ .../diagnosticInformationMap.generated.ts | 6 +- src/compiler/diagnosticMessages.json | 2 +- src/compiler/parser.ts | 50 +++-- src/compiler/types.ts | 14 +- 5 files changed, 187 insertions(+), 95 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 0529b8012bf..d759eb1fc1a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7303,7 +7303,9 @@ module ts { if (globalPromiseType !== emptyObjectType) { // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type promisedType = getAwaitedType(promisedType); - return createTypeReference(globalPromiseType, [promisedType]); + if (promisedType !== unknownType) { + return createTypeReference(globalPromiseType, [promisedType]); + } } error(location, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); @@ -7319,17 +7321,23 @@ module ts { let isAsync = isAsyncFunctionLike(func); let type: Type; if (func.body.kind !== SyntaxKind.Block) { - type = isAsync - ? checkAwaitedExpressionCached(func.body, contextualMapper) - : checkExpressionCached(func.body, contextualMapper); + if (isAsync) { + type = checkAwaitedExpressionCached(func.body, contextualMapper); + } + else { + type = checkExpressionCached(func.body, contextualMapper); + } } else { // Aggregate the types of expressions within all the return statements. let types = checkAndAggregateReturnExpressionTypes(func.body, contextualMapper); if (types.length === 0) { - return isAsync - ? createPromiseType(voidType, func) - : voidType; + if (isAsync) { + return createPromiseType(voidType, func); + } + else { + return voidType; + } } // When return statements are contextually typed we allow the return type to be a union type. Otherwise we require the @@ -7340,14 +7348,18 @@ module ts { return unknownType; } } + if (!contextualSignature) { reportErrorsFromWidening(func, type); } let widenedType = getWidenedType(type); - return isAsync - ? createPromiseType(widenedType, func) - : widenedType; + if (isAsync) { + return createPromiseType(widenedType, func); + } + else { + return widenedType; + } } /// Returns a set of types relating to every return expression relating to a function block. @@ -7357,9 +7369,14 @@ module ts { forEachReturnStatement(body, returnStatement => { let expr = returnStatement.expression; if (expr) { - let type = isAsync - ? checkAwaitedExpressionCached(expr, contextualMapper) - : checkExpressionCached(expr, contextualMapper); + let type: Type; + if (isAsync) { + type = checkAwaitedExpressionCached(expr, contextualMapper); + } + else { + type = checkExpressionCached(expr, contextualMapper); + } + if (!contains(aggregatedTypes, type)) { aggregatedTypes.push(type); } @@ -7495,10 +7512,12 @@ module ts { else { let exprType = checkExpression(node.body); if (returnType) { - checkTypeAssignableTo( - isAsync ? getAwaitedType(exprType) : exprType, - isAsync ? promisedType : returnType, - node.body); + if (isAsync) { + checkTypeAssignableTo(getAwaitedType(exprType, node.body), promisedType, node.body); + } + else { + checkTypeAssignableTo(exprType, returnType, node.body); + } } checkFunctionExpressionBodies(node.body); } @@ -7619,8 +7638,8 @@ module ts { grammarErrorOnFirstToken(node, Diagnostics.await_expression_must_be_contained_within_an_async_function); } - var operandType = checkExpression(node.expression); - return getAwaitedType(operandType); + let operandType = checkExpression(node.expression); + return getAwaitedType(operandType, node); } function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type { @@ -8322,13 +8341,14 @@ module ts { break; } } + if (isAsyncFunctionLike(node)) { var promiseConstructor = getPromiseConstructor(node); if (promiseConstructor) { var promiseIdentifier = getFirstIdentifier(promiseConstructor); var promiseName = promiseIdentifier.text; - var typeSymbol = resolveName(node, promiseName, SymbolFlags.Type | SymbolFlags.Module, undefined, undefined); - var valueSymbol = resolveName(node, promiseName, SymbolFlags.Value, undefined, undefined); + var typeSymbol = resolveName(node, promiseName, SymbolFlags.Type | SymbolFlags.Module, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); + var valueSymbol = resolveName(node, promiseName, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); if (typeSymbol !== valueSymbol) { var valueLinks = getNodeLinks(valueSymbol.valueDeclaration); if (!(valueLinks.flags & NodeCheckFlags.PromiseCollision)) { @@ -8932,8 +8952,28 @@ module ts { } } + function checkNonThenableType(type: Type, location?: Node, message?: DiagnosticMessage) { + if (!(type.flags & TypeFlags.Any) && isTypeAssignableTo(type, getGlobalThenableType())) { + if (location) { + if (!message) { + message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; + } + + error(location, message); + } + + return false; + } + + return true; + } + + /** + * Gets the "promised type" of a promise. + * @param type The type of the promise. + * @remarks The "promised type" of a type is the type of the "value" argument of the "onfulfilled" callback. + */ function getPromisedType(type: Type): Type { - // the "promised type" of a type is the type of the "value" argument of the "onfulfilled" callback. let globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType(); if (globalPromiseLikeType !== emptyObjectType && isTypeAssignableTo(type, globalPromiseLikeType)) { let thenProp = getPropertyOfType(type, "then"); @@ -8954,67 +8994,100 @@ module ts { } return getUnionType(awaitedTypes); - } + } } - - return emptyObjectType; + + return unknownType; } - - function getAwaitedType(type: Type): Type { - // The "awaited type" of an expression is its "promised type" if the expression is a `Promise`; otherwise, it is the type of the expression. - + + /** + * Gets the "awaited type" of a type. + * @param type The type to await. + * @remarks The "awaited type" of an expression is its "promised type" if the expression is a + * Promise-like type; otherwise, it is the type of the expression. This is used to reflect + * The runtime behavior of the `await` keyword. + */ + function getAwaitedType(type: Type, location?: Node): Type { let promisedType = getPromisedType(type); - if (promisedType === emptyObjectType) { - return type; + if (promisedType === unknownType) { + // if we got the unknown type, the type wasn't a promise. We need to check to + // ensure it is not a thenable. + if (checkNonThenableType(type, location)) { + return type; + } + + return unknownType; + } + else if (promisedType === type) { + // if we have a bad actor in the form of a promise whose promised type is the same + // promise, return the unknown type as we cannot guess the shape. + // if this were the actual case in the JavaScript, this Promise would never resolve. + if (location) { + error(location, Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member); + } + + return unknownType; } - // if we have a bad actor in the form of a promise whose promised type is the same promise, return the empty type. - // if this were the actual case in the JavaScript, this Promise would never resolve. - if (promisedType === type) { - return emptyObjectType; - } + // `seen` keeps track of types we've tried to await to avoid cycles. + // This is to protect against a bad actor with a mutually recursive promised type: + // + // declare class PromiseA { + // then(onfulfilled: (value: PromiseB) => any, onrejected?); + // } + // declare class PromiseB { + // then(onfulfilled: (value: PromiseA) => any, onrejected?); + // } + // + let seen: boolean[]; // unwrap any nested promises - let seen: boolean[]; while (true) { let nestedPromisedType = getPromisedType(promisedType); - if (nestedPromisedType === emptyObjectType) { - // if this could not be unwrapped further, return the promised type - return promisedType; + if (nestedPromisedType === unknownType) { + // this type could not be unwrapped further. We need to check to + // ensure it is not a thenable + if (checkNonThenableType(promisedType, location)) { + return promisedType; + } + + return unknownType; } if (!seen) { - // `seen` keeps track of types we've tried to await to avoid cycles seen = []; seen[type.id] = true; seen[promisedType.id] = true; } else if (seen[nestedPromisedType.id]) { - // if we've already seen this type, this is a promise that would never resolve. As above, we return the empty type. - return emptyObjectType; + // if we've already seen this type, this is a promise that + // would never resolve. As above, we return the unknown type. + if (location) { + error(location, Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member); + } + + return unknownType; } seen[nestedPromisedType.id] = true; promisedType = nestedPromisedType; } - - return promisedType; - - // if we didn't get a promised type, check the type does not have a callable then member. - if (isTypeAssignableTo(type, getGlobalThenableType())) { - error(null, Diagnostics.Type_for_await_does_not_have_a_valid_callable_then_member); - return emptyObjectType; - } - - // if the type was not a "promise" or a "thenable", return the type. - return type; } - function checkAsyncFunctionReturnType(node: SignatureDeclaration, returnType: Type): Type { - // This checks that an async function has a valid Promise-compatible return type, and returns the *awaited type* of the promise. - // An async function has a valid Promise-compatible return type if the resolved value of the return type has a construct - // signature that takes in an `initializer` function that in turn supplies a `resolve` function as one of its arguments - // and results in an object with a callable `then` signature. + /** + * Checks the return type of an async function to ensure it is a compatible + * Promise implementation. + * @param node The signature to check + * @param returnType The return type for the function + * @remarks + * This checks that an async function has a valid Promise-compatible return type, + * and returns the *awaited type* of the promise. An async function has a valid + * Promise-compatible return type if the resolved value of the return type has a + * construct signature that takes in an `initializer` function that in turn supplies + * a `resolve` function as one of its arguments and results in an object with a + * callable `then` signature. + */ + function checkAsyncFunctionReturnType(node: SignatureDeclaration, returnType: Type): Type { let globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(); if (globalPromiseConstructorLikeType !== emptyObjectType) { if (!returnType) { @@ -9022,23 +9095,24 @@ module ts { } // get the constructor type of the return type - var declaredType = returnType.symbol ? getTypeOfSymbol(returnType.symbol) : emptyObjectType; + let declaredType = returnType.symbol ? getTypeOfSymbol(returnType.symbol) : emptyObjectType; if (isTypeAssignableTo(declaredType, globalPromiseConstructorLikeType)) { - var promisedType = getPromisedType(returnType); - if (promisedType !== emptyObjectType) { + let promisedType = getPromisedType(returnType); + if (promisedType !== unknownType) { // unwrap the promised type - var promiseConstructor = getPromiseConstructor(node); + let promiseConstructor = getPromiseConstructor(node); if (promiseConstructor) { - emitAwaiter = true; checkExpressionOrQualifiedName(promiseConstructor); - return getAwaitedType(promisedType); } + + emitAwaiter = true; + return getAwaitedType(promisedType, node); } } } error(node, ts.Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); - return emptyObjectType; + return unknownType; } /** Check a decorator */ @@ -12351,9 +12425,11 @@ module ts { let thenPropertySymbol = createSymbol(SymbolFlags.Transient | SymbolFlags.Property, "then"); getSymbolLinks(thenPropertySymbol).type = globalFunctionType; - let thenableType = createObjectType(TypeFlags.ObjectType); + let thenableType = createObjectType(TypeFlags.Anonymous); thenableType.properties = [thenPropertySymbol]; thenableType.members = createSymbolTable(thenableType.properties); + thenableType.callSignatures = []; + thenableType.constructSignatures = []; return thenableType; } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index ec2bca8a7ce..4a4ae961109 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -50,7 +50,7 @@ module ts { A_get_accessor_cannot_have_parameters: { code: 1054, category: DiagnosticCategory.Error, key: "A 'get' accessor cannot have parameters." }, Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." }, An_async_function_or_method_must_have_a_valid_awaitable_return_type: { code: 1057, category: DiagnosticCategory.Error, key: "An async function or method must have a valid awaitable return type." }, - Type_for_await_does_not_have_a_valid_callable_then_member: { code: 1058, category: DiagnosticCategory.Error, key: "Type for 'await' does not have a valid callable 'then' member." }, + Operand_for_await_does_not_have_a_valid_callable_then_member: { code: 1058, category: DiagnosticCategory.Error, key: "Operand for 'await' does not have a valid callable 'then' member." }, Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." }, An_export_assignment_cannot_be_used_in_a_namespace: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a namespace." }, Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." }, @@ -381,11 +381,11 @@ module ts { An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." }, A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." }, A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." }, + _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 2502, category: DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own type annotation." }, + Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." }, Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." }, The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression." }, - _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 2502, category: DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own type annotation." }, - Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 600c928a0dd..feb7730a8a3 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -187,7 +187,7 @@ "category": "Error", "code": 1057 }, - "Type for 'await' does not have a valid callable 'then' member.": { + "Operand for 'await' does not have a valid callable 'then' member.": { "category": "Error", "code": 1058 }, diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index db6a00ec9aa..f4ac24c5fc8 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -568,11 +568,15 @@ module ts { } function doOutsideOfContext(context: ParserContextFlags, func: () => T): T { - let setContextFlags = context & contextFlags; - if (setContextFlags) { - setContextFlag(false, setContextFlags); + // contextFlagsToClear will contain only the context flags that are + // currently set that we need to temporarily clear + let contextFlagsToClear = context & contextFlags; + if (contextFlagsToClear) { + // clear the requested context flags + setContextFlag(false, contextFlagsToClear); let result = func(); - setContextFlag(true, setContextFlags); + // restore the context flags we just cleared + setContextFlag(true, contextFlagsToClear); return result; } @@ -581,11 +585,15 @@ module ts { } function doInsideOfContext(context: ParserContextFlags, func: () => T): T { - let unsetContextFlags = context & ~contextFlags; - if (unsetContextFlags) { - setContextFlag(true, unsetContextFlags); + // contextFlagsToSet will contain only the context flags that + // are not currently set that we need to temporarily enable + let contextFlagsToSet = context & ~contextFlags; + if (contextFlagsToSet) { + // set the requested context flags + setContextFlag(true, contextFlagsToSet); let result = func(); - setContextFlag(false, unsetContextFlags); + // reset the context flags we just set + setContextFlag(false, contextFlagsToSet); return result; } @@ -1013,6 +1021,11 @@ module ts { } function canFollowModifier(isArrowFunction?: boolean): boolean { + // Arrow functions can have an `async` modifier, but the rules for what can follow that modifier + // differ from the rules for any other declaration. + // The `async` modifier on an async function can only be followed by an open parenthesis, + // or a less than token (in the case of a generic arrow function). + // In addition, the `async` modifier must appear on the same line as the following token. if (isArrowFunction) { if (scanner.hasPrecedingLineBreak()) { return false; @@ -1898,12 +1911,12 @@ module ts { function parseBindingElementInitializer(inParameter: boolean) { // BindingElement[Yield,GeneratorParameter,Await,AsyncParameter] : - // [+GeneratorParameter] BindingPattern[?Yield,?Await,GeneratorParameter] Initializer[In]opt - // [+AsyncParameter] BindingPattern[?Yield,?Await,AsyncParameter] Initializer[In]opt + // [+GeneratorParameter] BindingPattern[?Yield,?Await,?AsyncParameter,GeneratorParameter] Initializer[In]opt + // [+AsyncParameter] BindingPattern[?Yield,?GeneratorParameter,?Await,AsyncParameter] Initializer[In]opt // [~GeneratorParameter,~AsyncParameter] BindingPattern[?Yield,?Await] Initializer[In,?Yield,?Await]opt // SingleNameBinding[Yield,GeneratorParameter,Await,AsyncParameter] : - // [+GeneratorParameter] BindingIdentifier[Yield] Initializer[In]opt - // [+AsyncParameter] BindingIdentifier[Await] Initializer[In]opt + // [+GeneratorParameter] BindingIdentifier[Yield, ?Await] Initializer[In]opt + // [+AsyncParameter] BindingIdentifier[Await, ?Yield] Initializer[In]opt // [~GeneratorParameter,~AsyncParameter] BindingIdentifier[?Yield,?Await] Initializer[In,?Yield,?Await]opt let parseInitializer = inParameter ? parseParameterInitializer : parseNonParameterInitializer; return inGeneratorParameterOrAsyncParameterContext() @@ -2425,9 +2438,9 @@ module ts { case SyntaxKind.LessThanToken: case SyntaxKind.AwaitKeyword: case SyntaxKind.YieldKeyword: - // Yield always starts an expression. Either it is an identifier (in which case + // Yield/await always starts an expression. Either it is an identifier (in which case // it is definitely an expression). Or it's a keyword (either because we're in - // a generator, or in strict mode (or both)) and it started a yield expression. + // a generator or async function, or in strict mode (or both)) and it started a yield or await expression. return true; default: // Error tolerance. If we see the start of some binary operator, we consider @@ -3317,6 +3330,9 @@ module ts { case SyntaxKind.OpenBraceToken: return parseObjectLiteralExpression(); case SyntaxKind.AsyncKeyword: + // Async arrow functions are parsed earlier in parseAssignmentExpressionOrHigher. + // If we encounter `async [no LineTerminator here] function` then this is an async + // function; otherwise, its an identifier. if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) { break; } @@ -3450,7 +3466,7 @@ module ts { parseExpected(SyntaxKind.FunctionKeyword); node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); - let isGenerator = node.asteriskToken != undefined; + let isGenerator = !!node.asteriskToken; let isAsync = isAsyncFunctionLike(node); node.name = isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) : @@ -4092,7 +4108,7 @@ module ts { parseExpected(SyntaxKind.FunctionKeyword); node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier(); - let isGenerator = node.asteriskToken != undefined; + let isGenerator = !!node.asteriskToken; let isAsync = isAsyncFunctionLike(node); fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList:*/ false, node); node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, Diagnostics.or_expected); @@ -4116,7 +4132,7 @@ module ts { method.asteriskToken = asteriskToken; method.name = name; method.questionToken = questionToken; - let isGenerator = asteriskToken != undefined; + let isGenerator = !!asteriskToken; let isAsync = isAsyncFunctionLike(method); fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList:*/ false, method); method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 86b4113eecc..29206c53f39 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -344,16 +344,16 @@ module ts { // If this node was parsed as part of a decorator Decorator = 1 << 4, + // If this node was parsed in the parameters of an async function. + AsyncParameter = 1 << 5, + + // If this node was parsed in the 'await' context created when parsing an async function. + Await = 1 << 6, + // 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. - ThisNodeHasError = 1 << 5, - - // If this node was parsed in the parameters of an async function. - AsyncParameter = 1 << 6, - - // If this node was parsed in the 'await' context created when parsing an async function. - Await = 1 << 7, + ThisNodeHasError = 1 << 7, // Context flags set directly by the parser. ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | Decorator | ThisNodeHasError | AsyncParameter | Await, From 239166643592ddaa4708094d9d9aa5daa70e4614 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 8 May 2015 17:07:48 -0700 Subject: [PATCH 012/309] Updated declaration and symbol baselines --- src/lib/es6.d.ts | 1 + tests/baselines/reference/asyncArrowFunction1_es6.symbols | 2 +- tests/baselines/reference/asyncArrowFunction9_es6.symbols | 2 +- .../reference/asyncFunctionDeclaration10_es6.symbols | 2 +- .../reference/asyncFunctionDeclaration11_es6.symbols | 2 +- .../reference/asyncFunctionDeclaration14_es6.symbols | 2 +- .../reference/asyncFunctionDeclaration1_es6.symbols | 2 +- .../reference/awaitBinaryExpression1_es6.symbols | 4 ++-- .../reference/awaitBinaryExpression2_es6.symbols | 4 ++-- .../reference/awaitBinaryExpression3_es6.symbols | 4 ++-- .../reference/awaitBinaryExpression4_es6.symbols | 4 ++-- .../reference/awaitBinaryExpression5_es6.symbols | 4 ++-- .../baselines/reference/awaitCallExpression1_es6.symbols | 8 ++++---- .../baselines/reference/awaitCallExpression2_es6.symbols | 8 ++++---- .../baselines/reference/awaitCallExpression3_es6.symbols | 8 ++++---- .../baselines/reference/awaitCallExpression4_es6.symbols | 8 ++++---- .../baselines/reference/awaitCallExpression5_es6.symbols | 8 ++++---- .../baselines/reference/awaitCallExpression6_es6.symbols | 8 ++++---- .../baselines/reference/awaitCallExpression7_es6.symbols | 8 ++++---- .../baselines/reference/awaitCallExpression8_es6.symbols | 8 ++++---- .../baselines/reference/promiseVoidErrorCallback.symbols | 8 ++++---- 21 files changed, 53 insertions(+), 52 deletions(-) diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts index 2c1db00de9b..b6b8d8fc13b 100644 --- a/src/lib/es6.d.ts +++ b/src/lib/es6.d.ts @@ -3591,6 +3591,7 @@ interface Promise { * @returns A Promise for the completion of the callback. */ catch(onrejected?: (reason: any) => T | PromiseLike): Promise; + catch(onrejected?: (reason: any) => void): Promise; [Symbol.toStringTag]: string; } diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols index 405121287a6..3540c6d2498 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols @@ -2,6 +2,6 @@ var foo = async (): Promise => { >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) }; diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.symbols b/tests/baselines/reference/asyncArrowFunction9_es6.symbols index 7c50a463248..66612c34830 100644 --- a/tests/baselines/reference/asyncArrowFunction9_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction9_es6.symbols @@ -4,5 +4,5 @@ var foo = async (a = await => await): Promise => { >a : Symbol(a, Decl(asyncArrowFunction9_es6.ts, 0, 17)) >await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) >await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols index 76ed959e0af..cc3870c6d71 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols @@ -4,5 +4,5 @@ async function foo(a = await => await): Promise { >a : Symbol(a, Decl(asyncFunctionDeclaration10_es6.ts, 0, 19)) >await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) >await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols index ec477460202..58fe50df2cf 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts === async function await(): Promise { >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols index 0cbcb69685c..a88f3f752e0 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts === async function foo(): Promise { >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) return; } diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols index 9631076c084..ee10e306a42 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts === async function foo(): Promise { >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) } diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols index 6df30c99fa5..b33c26f7707 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = await p || a; diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols index af1c2e3395a..f36bc7f2019 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = await p && a; diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols index 6983f2c73ab..543a6e8659d 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols @@ -4,11 +4,11 @@ declare var a: number; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = await p + a; diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols index 42f6730ad66..142655b9997 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = await p, a; diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols index 4f5d853c68f..f883da2cd16 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var o: { a: boolean; }; diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols index 4065e1e0e02..1e7f17daa7c 100644 --- a/tests/baselines/reference/awaitCallExpression1_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = fn(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols index a4b36cbc13c..ad053c6a75f 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = fn(await p, a, a); diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols index 184c80fde62..ad6ec4b11a0 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = fn(a, await p, a); diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols index f8a7bbe037b..1ef55774114 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = (await pfn)(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols index 58a0553533e..11232eeb38c 100644 --- a/tests/baselines/reference/awaitCallExpression5_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = o.fn(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols index 48262825ed9..06ec12c99d3 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = o.fn(await p, a, a); diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols index 85f172d03e4..91cce6e9a33 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = o.fn(a, await p, a); diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols index a1b9798b4c2..2decfda811e 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) "before"; var b = (await po).fn(a, a, a); diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols index d9e329885aa..aa6b1b642ce 100644 --- a/tests/baselines/reference/promiseVoidErrorCallback.symbols +++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols @@ -22,13 +22,13 @@ interface T3 { function f1(): Promise { >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0)) return Promise.resolve({ __t1: "foo_t1" }); ->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) ->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4838, 39), Decl(lib.d.ts, 4845, 54)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4856, 11)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4838, 39), Decl(lib.d.ts, 4845, 54)) >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28)) } From 39a6cce78910ef410889f6993408720f4c2284df Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 8 May 2015 21:37:43 -0700 Subject: [PATCH 013/309] Cleaned up diagnostic messages --- src/compiler/checker.ts | 5 ++- .../diagnosticInformationMap.generated.ts | 11 +----- src/compiler/diagnosticMessages.json | 38 +------------------ 3 files changed, 6 insertions(+), 48 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d759eb1fc1a..650a65119b6 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7635,7 +7635,7 @@ module ts { function checkAwaitExpression(node: AwaitExpression): Type { // Grammar checking if (!(node.parserContextFlags & ParserContextFlags.Await)) { - grammarErrorOnFirstToken(node, Diagnostics.await_expression_must_be_contained_within_an_async_function); + grammarErrorOnFirstToken(node, Diagnostics.await_expression_is_only_allowed_within_an_async_function); } let operandType = checkExpression(node.expression); @@ -10069,6 +10069,9 @@ module ts { if (node.parserContextFlags & ParserContextFlags.StrictMode) { grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode); } + else if (node.parserContextFlags & ParserContextFlags.Await) { + grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_an_async_function_block); + } } checkExpression(node.expression); diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 4a4ae961109..f466d6bfe41 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -181,16 +181,7 @@ module ts { Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, with_statements_are_not_allowed_in_an_async_function_block: { code: 1300, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in an async function block." }, - _0_modifier_cannot_be_used_with_a_generator: { code: 1301, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a generator." }, - _0_modifier_cannot_be_used_with_a_module_declaration: { code: 1302, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a module declaration." }, - _0_modifier_cannot_be_used_with_an_enum_declaration: { code: 1303, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with an enum declaration." }, - _0_modifier_cannot_be_used_with_an_export_assignment_declaration: { code: 1304, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with an export assignment declaration." }, - _0_modifier_cannot_be_used_on_a_variable_statement: { code: 1305, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used on a variable statement." }, - _0_modifier_cannot_be_used_with_a_type_declaration: { code: 1306, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a type declaration." }, - _0_modifier_cannot_be_used_with_a_parameter_declaration: { code: 1307, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a parameter declaration." }, - await_expression_must_be_contained_within_an_async_function: { code: 1308, category: DiagnosticCategory.Error, key: "'await' expression must be contained within an async function." }, - _0_modifier_cannot_be_used_on_an_object_literal_element: { code: 1309, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used on an object literal element." }, - _0_expression_is_not_allowed_in_an_initializer: { code: 1310, category: DiagnosticCategory.Error, key: "'{0}' expression is not allowed in an initializer." }, + await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: DiagnosticCategory.Error, key: "'await' expression is only allowed within an async function." }, Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: DiagnosticCategory.Error, key: "Async functions are only available when targeting ECMAScript 6 and higher." }, 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." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index feb7730a8a3..aa8ec55f522 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -712,46 +712,10 @@ "category": "Error", "code": 1300 }, - "'{0}' modifier cannot be used with a generator.": { - "category": "Error", - "code": 1301 - }, - "'{0}' modifier cannot be used with a module declaration.": { - "category": "Error", - "code": 1302 - }, - "'{0}' modifier cannot be used with an enum declaration.": { - "category": "Error", - "code": 1303 - }, - "'{0}' modifier cannot be used with an export assignment declaration.": { - "category": "Error", - "code": 1304 - }, - "'{0}' modifier cannot be used on a variable statement.": { - "category": "Error", - "code": 1305 - }, - "'{0}' modifier cannot be used with a type declaration.": { - "category": "Error", - "code": 1306 - }, - "'{0}' modifier cannot be used with a parameter declaration.": { - "category": "Error", - "code": 1307 - }, - "'await' expression must be contained within an async function.": { + "'await' expression is only allowed within an async function.": { "category": "Error", "code": 1308 }, - "'{0}' modifier cannot be used on an object literal element.": { - "category": "Error", - "code": 1309 - }, - "'{0}' expression is not allowed in an initializer.": { - "category": "Error", - "code": 1310 - }, "Async functions are only available when targeting ECMAScript 6 and higher.": { "category": "Error", "code": 1311 From daa77935e31cb728401cc0a44881daba248a8d0f Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 8 May 2015 21:40:56 -0700 Subject: [PATCH 014/309] Additional clean up of diagnostic messages --- src/compiler/diagnosticInformationMap.generated.ts | 1 - src/compiler/diagnosticMessages.json | 4 ---- 2 files changed, 5 deletions(-) diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index f466d6bfe41..2beb3fd5cd1 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -519,7 +519,6 @@ module ts { Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." }, NEWLINE: { code: 6061, category: DiagnosticCategory.Message, key: "NEWLINE" }, Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." }, - Emit_async_functions_when_ECMAScript_target_version_is_lower_than_ES6: { code: 6063, category: DiagnosticCategory.Message, key: "Emit async functions when ECMAScript target version is lower than 'ES6'." }, Variable_0_implicitly_has_an_1_type: { code: 7005, category: DiagnosticCategory.Error, key: "Variable '{0}' implicitly has an '{1}' type." }, Parameter_0_implicitly_has_an_1_type: { code: 7006, category: DiagnosticCategory.Error, key: "Parameter '{0}' implicitly has an '{1}' type." }, Member_0_implicitly_has_an_1_type: { code: 7008, category: DiagnosticCategory.Error, key: "Member '{0}' implicitly has an '{1}' type." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index aa8ec55f522..3c1f3405db8 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2068,10 +2068,6 @@ "category": "Error", "code": 6062 }, - "Emit async functions when ECMAScript target version is lower than 'ES6'.": { - "category": "Message", - "code": 6063 - }, "Variable '{0}' implicitly has an '{1}' type.": { "category": "Error", From 2ee5beb3786e198e3d6cb1b9801958b2fe802257 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 8 May 2015 22:15:54 -0700 Subject: [PATCH 015/309] PR feedback --- src/compiler/parser.ts | 37 +++++++++++++++++-------------------- src/compiler/types.ts | 10 +++++----- src/compiler/utilities.ts | 2 +- 3 files changed, 23 insertions(+), 26 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index f4ac24c5fc8..ed7ecd6c9f6 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -983,25 +983,22 @@ module ts { } function nextTokenCanFollowModifierForArrowFunction() { - return nextTokenCanFollowModifier(/*isArrowFunction*/ true); + nextToken(); + return canFollowModifierForArrowFunction(); } - function nextTokenCanFollowModifier(isArrowFunction?: boolean) { + function nextTokenCanFollowModifier() { nextToken(); - return canFollowModifier(isArrowFunction); + return canFollowModifier(); } function parseAnyContextualModifier(isArrowFunction?: boolean): boolean { return isModifier(token) && tryParse(isArrowFunction - ? nextTokenCanFollowContextualModifierForArrowFunction + ? nextTokenCanFollowModifierForArrowFunction : nextTokenCanFollowContextualModifier); } - function nextTokenCanFollowContextualModifierForArrowFunction() { - return nextTokenCanFollowContextualModifier(/*isArrowFunction*/ true); - } - - function nextTokenCanFollowContextualModifier(isArrowFunction?: boolean) { + function nextTokenCanFollowContextualModifier() { if (token === SyntaxKind.ConstKeyword) { // 'const' is only a modifier if followed by 'enum'. return nextToken() === SyntaxKind.EnumKeyword; @@ -1017,24 +1014,24 @@ module ts { return nextTokenIsClassOrFunction(); } nextToken(); - return canFollowModifier(isArrowFunction); + return canFollowModifier(); } - - function canFollowModifier(isArrowFunction?: boolean): boolean { + + function canFollowModifierForArrowFunction(): boolean { // Arrow functions can have an `async` modifier, but the rules for what can follow that modifier // differ from the rules for any other declaration. // The `async` modifier on an async function can only be followed by an open parenthesis, // or a less than token (in the case of a generic arrow function). // In addition, the `async` modifier must appear on the same line as the following token. - if (isArrowFunction) { - if (scanner.hasPrecedingLineBreak()) { - return false; - } - - return token === SyntaxKind.OpenParenToken - || token === SyntaxKind.LessThanToken; + if (scanner.hasPrecedingLineBreak()) { + return false; } - + + return token === SyntaxKind.OpenParenToken + || token === SyntaxKind.LessThanToken; + } + + function canFollowModifier(): boolean { return token === SyntaxKind.OpenBracketToken || token === SyntaxKind.OpenBraceToken || token === SyntaxKind.AsteriskToken diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 29206c53f39..0b5df05ff00 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -344,11 +344,11 @@ module ts { // If this node was parsed as part of a decorator Decorator = 1 << 4, - // If this node was parsed in the parameters of an async function. - AsyncParameter = 1 << 5, - // If this node was parsed in the 'await' context created when parsing an async function. - Await = 1 << 6, + Await = 1 << 5, + + // If this node was parsed in the parameters of an async function. + AsyncParameter = 1 << 6, // 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 @@ -356,7 +356,7 @@ module ts { ThisNodeHasError = 1 << 7, // Context flags set directly by the parser. - ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | Decorator | ThisNodeHasError | AsyncParameter | Await, + ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | Decorator | ThisNodeHasError | Await | AsyncParameter, // Context flags passed as part of the modified ES6 grammar. YieldAndGeneratorParameterFlags = Yield | GeneratorParameter, diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 805bc877fee..b8aa89aca52 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1101,7 +1101,7 @@ module ts { } export function isAsyncFunctionLike(node: Node): boolean { - return isFunctionLike(node) && !isAccessor(node) && (node.flags & NodeFlags.Async) === NodeFlags.Async; + return isFunctionLike(node) && (node.flags & NodeFlags.Async) !== 0 && !isAccessor(node); } /** From 3d0991d27d1653943c10081d3687733a221826e0 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 13 May 2015 10:50:40 -0700 Subject: [PATCH 016/309] Better name for bitmask in ParserContextFlags --- src/compiler/parser.ts | 28 +++++++--------------------- src/compiler/types.ts | 4 +++- 2 files changed, 10 insertions(+), 22 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index db6a00ec9aa..7b293adadc2 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2363,7 +2363,7 @@ module ts { function parseType(): TypeNode { // The rules about 'yield' only apply to actual code/expression contexts. They don't // apply to 'type' contexts. So we disable these parameters here before moving on. - return doOutsideOfContext(ParserContextFlags.AllParameterFlags, parseTypeWorker); + return doOutsideOfContext(ParserContextFlags.TypeExcludesFlags, parseTypeWorker); } function parseTypeWorker(): TypeNode { @@ -4363,15 +4363,9 @@ module ts { node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause:*/ true); if (parseExpected(SyntaxKind.OpenBraceToken)) { - // ClassTail[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 14.5 - // [~GeneratorParameter,~AsyncParameter]ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } - // [+GeneratorParameter] ClassHeritageopt { ClassBodyopt } - // [+AsyncParameter] ClassHeritageopt { ClassBodyopt } - - node.members = inGeneratorParameterOrAsyncParameterContext() - ? doOutsideOfYieldAndAwaitContext(parseClassMembers) - : parseClassMembers(); - + // ClassTail[Yield,Await] : (Modified) See 14.5 + // ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } + node.members = parseClassMembers(); parseExpected(SyntaxKind.CloseBraceToken); } else { @@ -4384,24 +4378,16 @@ module ts { } function parseHeritageClauses(isClassHeritageClause: boolean): NodeArray { - // ClassTail[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 14.5 - // [~GeneratorParameter,~AsyncParameter]ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } - // [+GeneratorParameter] ClassHeritageopt { ClassBodyopt } - // [+AsyncParameter] ClassHeritageopt { ClassBodyopt } + // ClassTail[Yield,Await] : (Modified) See 14.5 + // ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } if (isHeritageClause()) { - return isClassHeritageClause && inGeneratorParameterOrAsyncParameterContext() - ? doOutsideOfYieldAndAwaitContext(parseHeritageClausesWorker) - : parseHeritageClausesWorker(); + return parseList(ParsingContext.HeritageClauses, /*checkForStrictMode:*/ false, parseHeritageClause); } return undefined; } - function parseHeritageClausesWorker() { - return parseList(ParsingContext.HeritageClauses, /*checkForStrictMode:*/ false, parseHeritageClause); - } - function parseHeritageClause() { if (token === SyntaxKind.ExtendsKeyword || token === SyntaxKind.ImplementsKeyword) { let node = createNode(SyntaxKind.HeritageClause); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 86b4113eecc..4de0f7fd98c 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -361,7 +361,9 @@ module ts { // Context flags passed as part of the modified ES6 grammar. YieldAndGeneratorParameterFlags = Yield | GeneratorParameter, AwaitAndAsyncParameterFlags = Await | AsyncParameter, - AllParameterFlags = YieldAndGeneratorParameterFlags | AwaitAndAsyncParameterFlags, + + // Exclude these flags when parsing a Type + TypeExcludesFlags = YieldAndGeneratorParameterFlags | AwaitAndAsyncParameterFlags, // Context flags computed by aggregating child flags upwards. From 9a6d308203f7bc8cc73f6ecb00ae1dbd5fc14267 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 13 May 2015 11:15:51 -0700 Subject: [PATCH 017/309] Simplified parenthesis check for await as yield. --- src/compiler/emitter.ts | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index e31989e6726..ba4b1010dba 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1381,14 +1381,13 @@ var __awaiter = (this && this.__awaiter) || function (generator, ctor) { } function needsParenthesisForAwaitExpressionAsYield(node: AwaitExpression) { - for (let current: Node = node; isExpression(current.parent); current = current.parent) { - if (current.parent.kind === SyntaxKind.BinaryExpression) { - if ((current.parent).left === current) { - return true; - } - } + if (node.parent.kind === SyntaxKind.BinaryExpression && !isAssignmentOperator((node.parent).operatorToken.kind)) { + return true; } - + else if (node.parent.kind === SyntaxKind.ConditionalExpression && (node.parent).condition === node) { + return true; + } + return false; } From 117b07bbf9da51615405131adb06ed39d8c072bf Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 13 May 2015 11:36:44 -0700 Subject: [PATCH 018/309] Added comments for emitAsyncSignatureAndBodyForES6 --- src/compiler/emitter.ts | 65 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 61 insertions(+), 4 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index ba4b1010dba..c7a0b1c27a7 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -3324,12 +3324,60 @@ var __awaiter = (this && this.__awaiter) || function (generator, ctor) { emitSignatureParameters(node); } - function emitAsyncSignatureAndBodyForES6(node: FunctionLikeDeclaration) { + function emitAsyncSignatureAndBodyForES6(node: FunctionLikeDeclaration) { let promiseConstructor = resolver.getPromiseConstructor(node); - let resolve = makeUniqueName("resolve"); let isArrowFunction = node.kind === SyntaxKind.ArrowFunction; let args: string; + + // An async function is emit as an outer function that calls an inner + // generator function. Any arguments of the outer function must be + // evaluated in the context of the generator function, to ensure the correct + // environment and bindings for things like binding patterns in the + // argument list. + // + // For async function declarations and function expressions, we want to + // pass the `arguments` object of the outer function to the inner generator + // function in the event the async function directly manipulates the `arguments` + // object. + // + // For async arrow functions, the `arguments` object is not bound to the arrow + // but its containing function. In that case, we must collect all of the passed + // arguments into an array which we then pass to the inner generator function to + // ensure the correct environment for any binding patterns. + // + // Async arrow functions do not have access to the lexical `arguments` of its + // lexical container. + // + // The emit for an async arrow without parameters will look something like this: + // + // let a = async () => await b; + // + // let a = () => __awaiter(function* () { + // return yield b; + // }.apply(this)); + // + // The emit for an async arrow with parameters will look something like this: + // + // let a = async (b) => await b; + // + // let a = (...arguments_1) => __awaiter(function* (b) { + // return yield b; + // }).apply(this, arguments_1); + // + // The emit for an async function expression will look something like this: + // + // let a = async function () { + // return await b; + // } + // + // let a = function () { + // return __awaiter(function* () { + // return yield b; + // }.apply(this, arguments)); + // } + // if (isArrowFunction) { + // Emit the outer signature for the async arrow if (node.parameters.length) { args = makeUniqueName("arguments"); write(`(...${args}) => `); @@ -3339,6 +3387,7 @@ var __awaiter = (this && this.__awaiter) || function (generator, ctor) { } } else { + // Emit the outer signature for the async function expression or declaration args = "arguments"; write("() {"); increaseIndent(); @@ -3346,29 +3395,37 @@ var __awaiter = (this && this.__awaiter) || function (generator, ctor) { write("return "); } + // Emit the call to __awaiter write("__awaiter(function *"); + // Emit the signature and body for the inner generator function emitSignatureParameters(node); emitFunctionBody(node); + + // Emit the call to `apply` to ensure the correct `this` and arguments. write(".apply(this"); if (args) { write(`, ${args}`); } write(")"); + + // If the function has an explicit type annotation for a promise, emit the + // constructor. if (promiseConstructor) { write(", "); emit(promiseConstructor); } write(")"); + // If this is not an async arrow, emit the closing brace of the outer function body if (!isArrowFunction) { write(";"); decreaseIndent(); writeLine(); write("}"); - } + } } - + function emitFunctionBody(node: FunctionLikeDeclaration) { if (!node.body) { // There can be no body when there are parse errors. Just emit an empty block From 379704ff4faf2dc4e33a950869b608c18fa586ea Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 13 May 2015 13:18:54 -0700 Subject: [PATCH 019/309] Cleaned up checker, added comments to parser based on PR feedback. --- src/compiler/checker.ts | 197 ++++++++++++++++++++++------------------ src/compiler/parser.ts | 10 +- 2 files changed, 116 insertions(+), 91 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 1a256809f10..85b63ad0d7a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -120,6 +120,7 @@ module ts { let getGlobalPropertyDecoratorType: () => ObjectType; let getGlobalMethodDecoratorType: () => ObjectType; let getGlobalPromiseType: () => ObjectType; + let tryGetGlobalPromiseType: () => ObjectType; let getGlobalPromiseLikeType: () => ObjectType; let getInstantiatedGlobalPromiseLikeType: () => ObjectType; let getGlobalPromiseConstructorLikeType: () => ObjectType; @@ -3501,6 +3502,10 @@ module ts { function getGlobalType(name: string, arity = 0): ObjectType { return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), arity); } + + function tryGetGlobalType(name: string, arity = 0): ObjectType { + return getTypeOfGlobalSymbol(getGlobalSymbol(name, SymbolFlags.Type, /*diagnostic*/ undefined), arity); + } function getGlobalESSymbolConstructorSymbol() { return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); @@ -7296,7 +7301,7 @@ module ts { } } - function createPromiseType(promisedType: Type, location: Node): Type { + function createPromiseType(promisedType: Type): Type { // creates a `Promise` type where `T` is the promisedType argument let globalPromiseType = getGlobalPromiseType(); if (globalPromiseType !== emptyObjectType) { @@ -7307,8 +7312,7 @@ module ts { } } - error(location, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); - return unknownType; + return undefined; } function getReturnTypeFromBody(func: FunctionLikeDeclaration, contextualMapper?: TypeMapper): Type { @@ -7321,6 +7325,11 @@ module ts { let type: Type; if (func.body.kind !== SyntaxKind.Block) { if (isAsync) { + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so the + // return type of the body is not the return type of the consise body, rather it + // is the awaited type of the consise body, which we will wrap in the native Promise type + // later in this function. type = checkAwaitedExpressionCached(func.body, contextualMapper); } else { @@ -7332,7 +7341,14 @@ module ts { let types = checkAndAggregateReturnExpressionTypes(func.body, contextualMapper); if (types.length === 0) { if (isAsync) { - return createPromiseType(voidType, func); + // For an async function, the return type will not be void, but rather a Promise for void. + let promiseType = createPromiseType(voidType); + if (!promiseType) { + error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return unknownType; + } + + return promiseType; } else { return voidType; @@ -7354,7 +7370,16 @@ module ts { let widenedType = getWidenedType(type); if (isAsync) { - return createPromiseType(widenedType, func); + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so the + // return type of the body is awaited type of the body, wrapped in a native Promise type. + let promiseType = createPromiseType(widenedType); + if (!promiseType) { + error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return unknownType; + } + + return promiseType; } else { return widenedType; @@ -7492,11 +7517,6 @@ module ts { let returnType = node.type && getTypeFromTypeNode(node.type); let promisedType: Type; if (returnType && isAsync) { - // From within an async function you can return either a non-promise value or a promise. Any - // Promise/A+ compatible implementation will always assimilate any foreign promise, so we - // should not be checking assignability of a promise to the return type. Instead, we need to - // check assignability of the awaited type of the concise body against the promised type of - // its return type annotation. promisedType = checkAsyncFunctionReturnType(node, returnType); } @@ -7509,6 +7529,11 @@ module ts { checkSourceElement(node.body); } else { + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so we + // should not be checking assignability of a promise to the return type. Instead, we need to + // check assignability of the awaited type of the concise body against the promised type of + // its return type annotation. let exprType = checkExpression(node.body); if (returnType) { if (isAsync) { @@ -8340,23 +8365,6 @@ module ts { break; } } - - if (isAsyncFunctionLike(node)) { - var promiseConstructor = getPromiseConstructor(node); - if (promiseConstructor) { - var promiseIdentifier = getFirstIdentifier(promiseConstructor); - var promiseName = promiseIdentifier.text; - var typeSymbol = resolveName(node, promiseName, SymbolFlags.Type | SymbolFlags.Module, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); - var valueSymbol = resolveName(node, promiseName, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); - if (typeSymbol !== valueSymbol) { - var valueLinks = getNodeLinks(valueSymbol.valueDeclaration); - if (!(valueLinks.flags & NodeCheckFlags.PromiseCollision)) { - valueLinks.flags |= NodeCheckFlags.PromiseCollision; - error(valueSymbol.valueDeclaration, Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, promiseName, getTextOfNode(promiseConstructor)); - } - } - } - } } checkSpecializedSignatureDeclaration(node); @@ -8952,7 +8960,7 @@ module ts { } function checkNonThenableType(type: Type, location?: Node, message?: DiagnosticMessage) { - if (!(type.flags & TypeFlags.Any) && isTypeAssignableTo(type, getGlobalThenableType())) { + if (!allConstituentTypesHaveKind(type, TypeFlags.Any) && isTypeAssignableTo(type, getGlobalThenableType())) { if (location) { if (!message) { message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; @@ -8970,33 +8978,58 @@ module ts { /** * Gets the "promised type" of a promise. * @param type The type of the promise. - * @remarks The "promised type" of a type is the type of the "value" argument of the "onfulfilled" callback. + * @remarks The "promised type" of a type is the type of the "value" parameter of the "onfulfilled" callback. */ - function getPromisedType(type: Type): Type { + function getPromisedType(promise: Type): Type { + // + // { // promise + // then( // thenFunction + // onfulfilled: ( // onfulfilledParameterType + // value: T // valueParameterType + // ) => any + // ): any; + // } + // + + if (allConstituentTypesHaveKind(promise, TypeFlags.Any)) { + return undefined; + } + + if ((promise.flags & TypeFlags.Reference) && (promise).target === tryGetGlobalPromiseType()) { + return (promise).typeArguments[0]; + } + let globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType(); - if (globalPromiseLikeType !== emptyObjectType && isTypeAssignableTo(type, globalPromiseLikeType)) { - let thenProp = getPropertyOfType(type, "then"); - if (thenProp) { - let awaitedTypes: Type[] = []; - let thenType = getTypeOfSymbol(thenProp); - let thenSignatures = getSignaturesOfType(thenType, SignatureKind.Call); - for (let thenSignature of thenSignatures) { - thenSignature = getErasedSignature(thenSignature); - let onfulfilledParameterType = getTypeAtPosition(thenSignature, 0); - let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call); - for (let onfulfilledParameterSignature of onfulfilledParameterSignatures) { - let valueParameterType = getTypeAtPosition(onfulfilledParameterSignature, 0); - if (valueParameterType !== type) { - awaitedTypes.push(valueParameterType); - } - } - } - - return getUnionType(awaitedTypes); - } + if (globalPromiseLikeType === emptyObjectType || !isTypeAssignableTo(promise, globalPromiseLikeType)) { + return undefined; } - return unknownType; + let thenFunction = getTypeOfPropertyOfType(promise, "then"); + if (thenFunction && allConstituentTypesHaveKind(thenFunction, TypeFlags.Any)) { + return undefined; + } + + let thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, SignatureKind.Call) : emptyArray; + if (thenSignatures.length === 0) { + return undefined; + } + + let onfulfilledParameterType = getUnionType(map(thenSignatures, getTypeOfFirstParameterOfSignature)); + if (allConstituentTypesHaveKind(onfulfilledParameterType, TypeFlags.Any)) { + return undefined; + } + + let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call); + if (onfulfilledParameterSignatures.length === 0) { + return undefined; + } + + let valueParameterType = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature)); + return valueParameterType; + } + + function getTypeOfFirstParameterOfSignature(signature: Signature) { + return getTypeAtPosition(signature, 0); } /** @@ -9006,28 +9039,7 @@ module ts { * Promise-like type; otherwise, it is the type of the expression. This is used to reflect * The runtime behavior of the `await` keyword. */ - function getAwaitedType(type: Type, location?: Node): Type { - let promisedType = getPromisedType(type); - if (promisedType === unknownType) { - // if we got the unknown type, the type wasn't a promise. We need to check to - // ensure it is not a thenable. - if (checkNonThenableType(type, location)) { - return type; - } - - return unknownType; - } - else if (promisedType === type) { - // if we have a bad actor in the form of a promise whose promised type is the same - // promise, return the unknown type as we cannot guess the shape. - // if this were the actual case in the JavaScript, this Promise would never resolve. - if (location) { - error(location, Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member); - } - - return unknownType; - } - + function getAwaitedType(type: Type, location?: Node): Type { // `seen` keeps track of types we've tried to await to avoid cycles. // This is to protect against a bad actor with a mutually recursive promised type: // @@ -9039,26 +9051,34 @@ module ts { // } // let seen: boolean[]; - - // unwrap any nested promises while (true) { - let nestedPromisedType = getPromisedType(promisedType); - if (nestedPromisedType === unknownType) { + let promisedType = getPromisedType(type); + if (!promisedType) { // this type could not be unwrapped further. We need to check to // ensure it is not a thenable - if (checkNonThenableType(promisedType, location)) { - return promisedType; + if (checkNonThenableType(type, location)) { + return type; } return unknownType; } if (!seen) { + if (promisedType === type) { + // if we have a bad actor in the form of a promise whose promised type is the same + // promise, return the unknown type as we cannot guess the shape. + // if this were the actual case in the JavaScript, this Promise would never resolve. + if (location) { + error(location, Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member); + } + + return unknownType; + } + seen = []; seen[type.id] = true; - seen[promisedType.id] = true; } - else if (seen[nestedPromisedType.id]) { + else if (seen[promisedType.id]) { // if we've already seen this type, this is a promise that // would never resolve. As above, we return the unknown type. if (location) { @@ -9068,8 +9088,8 @@ module ts { return unknownType; } - seen[nestedPromisedType.id] = true; - promisedType = nestedPromisedType; + seen[promisedType.id] = true; + type = promisedType; } } @@ -9089,15 +9109,11 @@ module ts { function checkAsyncFunctionReturnType(node: SignatureDeclaration, returnType: Type): Type { let globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(); if (globalPromiseConstructorLikeType !== emptyObjectType) { - if (!returnType) { - returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(node)); - } - - // get the constructor type of the return type + // get the constructor type of the return type let declaredType = returnType.symbol ? getTypeOfSymbol(returnType.symbol) : emptyObjectType; if (isTypeAssignableTo(declaredType, globalPromiseConstructorLikeType)) { let promisedType = getPromisedType(returnType); - if (promisedType !== unknownType) { + if (promisedType) { // unwrap the promised type let promiseConstructor = getPromiseConstructor(node); if (promiseConstructor) { @@ -10045,7 +10061,7 @@ module ts { } } else if (func.type && !isAccessor(func.kind) && isAsyncFunctionLike(func)) { - checkTypeAssignableTo(getAwaitedType(exprType), getPromisedType(returnType), node.expression); + checkTypeAssignableTo(getAwaitedType(exprType), getAwaitedType(returnType), node.expression); } else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) { checkTypeAssignableTo(exprType, returnType, node.expression); @@ -12379,6 +12395,7 @@ module ts { getGlobalMethodDecoratorType = memoize(() => getGlobalType("MethodDecorator")); getGlobalParameterDecoratorType = memoize(() => getGlobalType("ParameterDecorator")); getGlobalPromiseType = memoize(() => getGlobalType("Promise", /*arity*/ 1)); + tryGetGlobalPromiseType = memoize(() => getGlobalSymbol("Promise", SymbolFlags.Type, /*diagnostic*/ undefined) && getGlobalPromiseType()); getGlobalPromiseLikeType = memoize(() => getGlobalType("PromiseLike", /*arity*/ 1)); getInstantiatedGlobalPromiseLikeType = memoize(createInstantiatedPromiseLikeType); getGlobalPromiseConstructorSymbol = memoize(() => getGlobalValueSymbol("Promise")); diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 770f23b53b8..74f32488e5b 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -570,6 +570,10 @@ module ts { function doOutsideOfContext(context: ParserContextFlags, func: () => T): T { // contextFlagsToClear will contain only the context flags that are // currently set that we need to temporarily clear + // We don't just blindly reset to the previous flags to ensure + // that we do not mutate cached flags for the incremental + // parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and + // HasAggregatedChildData). let contextFlagsToClear = context & contextFlags; if (contextFlagsToClear) { // clear the requested context flags @@ -586,7 +590,11 @@ module ts { function doInsideOfContext(context: ParserContextFlags, func: () => T): T { // contextFlagsToSet will contain only the context flags that - // are not currently set that we need to temporarily enable + // are not currently set that we need to temporarily enable. + // We don't just blindly reset to the previous flags to ensure + // that we do not mutate cached flags for the incremental + // parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and + // HasAggregatedChildData). let contextFlagsToSet = context & ~contextFlags; if (contextFlagsToSet) { // set the requested context flags From b70e6a1ee549fb3ce6f0bc6714ef10d2dfcecc0c Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 13 May 2015 15:27:24 -0700 Subject: [PATCH 020/309] Added parseModifiersForArrowFunction --- src/compiler/parser.ts | 64 ++++++++++++++++++++---------------------- 1 file changed, 31 insertions(+), 33 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 74f32488e5b..9a35015cffb 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -984,17 +984,10 @@ module ts { return finishNode(node); } - function parseContextualModifier(t: SyntaxKind, isArrowFunction?: boolean): boolean { - return token === t && tryParse(isArrowFunction - ? nextTokenCanFollowModifierForArrowFunction - : nextTokenCanFollowModifier); + function parseContextualModifier(t: SyntaxKind): boolean { + return token === t && tryParse(nextTokenCanFollowModifier); } - function nextTokenCanFollowModifierForArrowFunction() { - nextToken(); - return canFollowModifierForArrowFunction(); - } - function nextTokenCanFollowModifier() { if (token === SyntaxKind.ConstKeyword) { // 'const' is only a modifier if followed by 'enum'. @@ -1014,24 +1007,8 @@ module ts { return canFollowModifier(); } - function parseAnyContextualModifier(isArrowFunction?: boolean): boolean { - return isModifier(token) && tryParse(isArrowFunction - ? nextTokenCanFollowModifierForArrowFunction - : nextTokenCanFollowModifier); - } - - function canFollowModifierForArrowFunction(): boolean { - // Arrow functions can have an `async` modifier, but the rules for what can follow that modifier - // differ from the rules for any other declaration. - // The `async` modifier on an async function can only be followed by an open parenthesis, - // or a less than token (in the case of a generic arrow function). - // In addition, the `async` modifier must appear on the same line as the following token. - if (scanner.hasPrecedingLineBreak()) { - return false; - } - - return token === SyntaxKind.OpenParenToken - || token === SyntaxKind.LessThanToken; + function parseAnyContextualModifier(): boolean { + return isModifier(token) && tryParse(nextTokenCanFollowModifier); } function canFollowModifier(): boolean { @@ -2709,8 +2686,11 @@ module ts { } function isParenthesizedArrowFunctionExpressionWorker() { - if (token === SyntaxKind.AsyncKeyword && !parseContextualModifier(SyntaxKind.AsyncKeyword, /*isArrowFunction*/ true)) { - return Tristate.False; + if (token === SyntaxKind.AsyncKeyword) { + nextToken(); + if (scanner.hasPrecedingLineBreak()) { + return Tristate.False; + } } let first = token; @@ -2788,7 +2768,7 @@ module ts { function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): ArrowFunction { let node = createNode(SyntaxKind.ArrowFunction); - setModifiers(node, parseModifiers(/*isArrowFunction*/ true)); + setModifiers(node, parseModifiersForArrowFunction()); let isAsync = isAsyncFunctionLike(node); // Arrow functions are never generators. @@ -3451,8 +3431,8 @@ module ts { return finishNode(node); } - function parseFunctionExpression(): FunctionExpression { // GeneratorExpression : + function parseFunctionExpression(): FunctionExpression { // function * BindingIdentifier[Yield]opt (FormalParameters[Yield, GeneratorParameter]) { GeneratorBody[Yield] } // FunctionExpression: // function BindingIdentifieropt(FormalParameters) { FunctionBody } @@ -4283,14 +4263,14 @@ module ts { return decorators; } - function parseModifiers(isArrowFunction?: boolean): ModifiersArray { + function parseModifiers(): ModifiersArray { let flags = 0; let modifiers: ModifiersArray; while (true) { let modifierStart = scanner.getStartPos(); let modifierKind = token; - if (!parseAnyContextualModifier(isArrowFunction)) { + if (!parseAnyContextualModifier()) { break; } @@ -4298,6 +4278,7 @@ module ts { modifiers = []; modifiers.pos = modifierStart; } + flags |= modifierToFlag(modifierKind); modifiers.push(finishNode(createNode(modifierKind, modifierStart))); } @@ -4308,6 +4289,23 @@ module ts { return modifiers; } + function parseModifiersForArrowFunction(): ModifiersArray { + let flags = 0; + let modifiers: ModifiersArray; + if (token === SyntaxKind.AsyncKeyword) { + let modifierStart = scanner.getStartPos(); + let modifierKind = token; + modifiers = []; + modifiers.pos = modifierStart; + flags |= modifierToFlag(modifierKind); + modifiers.push(finishNode(createNode(modifierKind, modifierStart))); + modifiers.flags = flags; + modifiers.end = scanner.getStartPos(); + } + + return modifiers; + } + function parseClassElement(): ClassElement { if (token === SyntaxKind.SemicolonToken) { let result = createNode(SyntaxKind.SemicolonClassElement); From 890a5d81d1101fd9c5636e543205976f63e9dc6e Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 13 May 2015 15:50:30 -0700 Subject: [PATCH 021/309] Fixed missing call to nextToken() --- src/compiler/parser.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 9a35015cffb..425741ec3cc 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -4295,6 +4295,7 @@ module ts { if (token === SyntaxKind.AsyncKeyword) { let modifierStart = scanner.getStartPos(); let modifierKind = token; + nextToken(); modifiers = []; modifiers.pos = modifierStart; flags |= modifierToFlag(modifierKind); From a565a023ebee17ae2a96b75ca29f94375d1dfb44 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 13 May 2015 17:26:28 -0700 Subject: [PATCH 022/309] Fixes missing check in isParenthesizedArrowFunctionExpressionWorker --- src/compiler/parser.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 425741ec3cc..6e9b37c97e7 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2691,6 +2691,9 @@ module ts { if (scanner.hasPrecedingLineBreak()) { return Tristate.False; } + if (token !== SyntaxKind.OpenParenToken && token !== SyntaxKind.LessThanToken) { + return Tristate.False; + } } let first = token; From b85d56b8570ce6bdb4ec0ee4dd5e8694dc0cabb9 Mon Sep 17 00:00:00 2001 From: SaschaNaz Date: Fri, 15 May 2015 21:00:32 +0900 Subject: [PATCH 023/309] block form indentation --- src/services/formatting/smartIndenter.ts | 28 ++++++++++++++++++- .../fourslash/formattingOnChainedCallbacks.ts | 2 ++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 9cd28a40a54..35bc015d66b 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -26,7 +26,7 @@ module ts.formatting { precedingToken.kind === SyntaxKind.TemplateHead || precedingToken.kind === SyntaxKind.TemplateMiddle || precedingToken.kind === SyntaxKind.TemplateTail; - if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && precedingToken.end > position) { + if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && precedingToken.end > position) { return 0; } @@ -110,6 +110,12 @@ module ts.formatting { if (actualIndentation !== Value.Unknown) { return actualIndentation + indentationDelta; } + + // check if current node is a block-form item - if yes, take indentation from it + actualIndentation = getActualIndentationForBlockFormItem(current, sourceFile, options); + if (actualIndentation !== Value.Unknown) { + return actualIndentation + indentationDelta; + } } parentStart = getParentStart(parent, current, sourceFile); let parentAndChildShareLine = @@ -277,6 +283,15 @@ module ts.formatting { return undefined; } + function getActualIndentationForBlockFormItem(node: Node, sourceFile: SourceFile, options: EditorOptions): number { + if (isPassableBlockForm(node.kind)) { + let firstChild = node.getChildAt(0); + let lineAndCharacter = getStartLineAndCharacterForNode(firstChild, sourceFile); + return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options); + } + return Value.Unknown; + } + function getActualIndentationForListItem(node: Node, sourceFile: SourceFile, options: EditorOptions): number { let containingList = getContainingList(node, sourceFile); return containingList ? getActualIndentationFromList(containingList) : Value.Unknown; @@ -400,5 +415,16 @@ module ts.formatting { return false; } } + + export function isPassableBlockForm(kind: SyntaxKind): boolean { + switch (kind) { + case SyntaxKind.ArrowFunction: + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrayLiteralExpression: + case SyntaxKind.ObjectLiteralExpression: + return true; + } + return false; + } } } \ No newline at end of file diff --git a/tests/cases/fourslash/formattingOnChainedCallbacks.ts b/tests/cases/fourslash/formattingOnChainedCallbacks.ts index 37fa6ff03f1..98f91de56fb 100644 --- a/tests/cases/fourslash/formattingOnChainedCallbacks.ts +++ b/tests/cases/fourslash/formattingOnChainedCallbacks.ts @@ -17,6 +17,8 @@ goTo.marker('1'); edit.insertLine(''); goTo.marker('2'); verify.currentLineContentIs(' ""'); +edit.insertLine(''); +verify.indentationIs(8); goTo.marker('4'); edit.insertLine(''); goTo.marker('3'); From a9eba62b68611bfb4aa75446ad6b147086dbe541 Mon Sep 17 00:00:00 2001 From: SaschaNaz Date: Sat, 16 May 2015 16:24:50 +0900 Subject: [PATCH 024/309] getLineIndentation --- src/services/formatting/smartIndenter.ts | 62 +++++++++++++----------- 1 file changed, 35 insertions(+), 27 deletions(-) diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 35bc015d66b..77e70a1ceaf 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -110,12 +110,6 @@ module ts.formatting { if (actualIndentation !== Value.Unknown) { return actualIndentation + indentationDelta; } - - // check if current node is a block-form item - if yes, take indentation from it - actualIndentation = getActualIndentationForBlockFormItem(current, sourceFile, options); - if (actualIndentation !== Value.Unknown) { - return actualIndentation + indentationDelta; - } } parentStart = getParentStart(parent, current, sourceFile); let parentAndChildShareLine = @@ -283,23 +277,48 @@ module ts.formatting { return undefined; } - function getActualIndentationForBlockFormItem(node: Node, sourceFile: SourceFile, options: EditorOptions): number { - if (isPassableBlockForm(node.kind)) { - let firstChild = node.getChildAt(0); - let lineAndCharacter = getStartLineAndCharacterForNode(firstChild, sourceFile); - return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options); - } - return Value.Unknown; - } - function getActualIndentationForListItem(node: Node, sourceFile: SourceFile, options: EditorOptions): number { let containingList = getContainingList(node, sourceFile); - return containingList ? getActualIndentationFromList(containingList) : Value.Unknown; + + if (containingList) { + let lineIndentation = getLineIndentationWhenExpressionIsInMultiLine(); + if (lineIndentation !== Value.Unknown) + return lineIndentation; + return getActualIndentationFromList(containingList); + } + return Value.Unknown; function getActualIndentationFromList(list: Node[]): number { let index = indexOf(list, node); return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : Value.Unknown; } + + function getLineIndentationWhenExpressionIsInMultiLine() { + if (node.parent.kind === SyntaxKind.CallExpression) { + let parentExpression = (node.parent).expression; + let startingExpression = getStartingExpression(parentExpression); + + if (parentExpression === startingExpression) { + return Value.Unknown; + } + + let parentExpressionEnd = sourceFile.getLineAndCharacterOfPosition(parentExpression.end); + let startingExpressionEnd = sourceFile.getLineAndCharacterOfPosition(startingExpression.end); + + if (parentExpressionEnd.line === startingExpressionEnd.line) { + return Value.Unknown; + } + + return findColumnForFirstNonWhitespaceCharacterInLine(parentExpressionEnd, sourceFile, options); + } + return Value.Unknown; + } + + function getStartingExpression(expression: CallExpression) { + while (expression.expression) + expression = expression.expression; + return expression; + } } function deriveActualIndentationFromList(list: Node[], index: number, sourceFile: SourceFile, options: EditorOptions): number { @@ -415,16 +434,5 @@ module ts.formatting { return false; } } - - export function isPassableBlockForm(kind: SyntaxKind): boolean { - switch (kind) { - case SyntaxKind.ArrowFunction: - case SyntaxKind.FunctionExpression: - case SyntaxKind.ArrayLiteralExpression: - case SyntaxKind.ObjectLiteralExpression: - return true; - } - return false; - } } } \ No newline at end of file From 4b4fc0147e6480033ccfb50cc2a8a8168c1fde76 Mon Sep 17 00:00:00 2001 From: SaschaNaz Date: Sat, 16 May 2015 17:08:09 +0900 Subject: [PATCH 025/309] take the function out --- src/services/formatting/smartIndenter.ts | 38 ++++++++++++------------ 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 77e70a1ceaf..a02dc4454fa 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -281,7 +281,7 @@ module ts.formatting { let containingList = getContainingList(node, sourceFile); if (containingList) { - let lineIndentation = getLineIndentationWhenExpressionIsInMultiLine(); + let lineIndentation = getLineIndentationWhenExpressionIsInMultiLine(node, sourceFile, options); if (lineIndentation !== Value.Unknown) return lineIndentation; return getActualIndentationFromList(containingList); @@ -292,28 +292,28 @@ module ts.formatting { let index = indexOf(list, node); return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : Value.Unknown; } + } - function getLineIndentationWhenExpressionIsInMultiLine() { - if (node.parent.kind === SyntaxKind.CallExpression) { - let parentExpression = (node.parent).expression; - let startingExpression = getStartingExpression(parentExpression); + function getLineIndentationWhenExpressionIsInMultiLine(node: Node, sourceFile: SourceFile, options: EditorOptions): number { + if (node.parent.kind === SyntaxKind.CallExpression) { + let parentExpression = (node.parent).expression; + let startingExpression = getStartingExpression(parentExpression); - if (parentExpression === startingExpression) { - return Value.Unknown; - } - - let parentExpressionEnd = sourceFile.getLineAndCharacterOfPosition(parentExpression.end); - let startingExpressionEnd = sourceFile.getLineAndCharacterOfPosition(startingExpression.end); - - if (parentExpressionEnd.line === startingExpressionEnd.line) { - return Value.Unknown; - } - - return findColumnForFirstNonWhitespaceCharacterInLine(parentExpressionEnd, sourceFile, options); + if (parentExpression === startingExpression) { + return Value.Unknown; } - return Value.Unknown; - } + let parentExpressionEnd = sourceFile.getLineAndCharacterOfPosition(parentExpression.end); + let startingExpressionEnd = sourceFile.getLineAndCharacterOfPosition(startingExpression.end); + + if (parentExpressionEnd.line === startingExpressionEnd.line) { + return Value.Unknown; + } + + return findColumnForFirstNonWhitespaceCharacterInLine(parentExpressionEnd, sourceFile, options); + } + return Value.Unknown; + function getStartingExpression(expression: CallExpression) { while (expression.expression) expression = expression.expression; From a2c50732e8866575dbfd872e02e15edab6f3a134 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 19 May 2015 12:49:47 -0700 Subject: [PATCH 026/309] Some cleanup and additional comments following PR feedback --- src/compiler/checker.ts | 211 +++++++++++------- .../diagnosticInformationMap.generated.ts | 4 +- src/compiler/diagnosticMessages.json | 10 +- ...owFunctionCapturesArguments_es6.errors.txt | 4 +- 4 files changed, 144 insertions(+), 85 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 85b63ad0d7a..734cae63881 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7324,21 +7324,18 @@ module ts { let isAsync = isAsyncFunctionLike(func); let type: Type; if (func.body.kind !== SyntaxKind.Block) { + type = checkExpressionCached(func.body, contextualMapper); if (isAsync) { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so the - // return type of the body is not the return type of the consise body, rather it - // is the awaited type of the consise body, which we will wrap in the native Promise type - // later in this function. - type = checkAwaitedExpressionCached(func.body, contextualMapper); - } - else { - type = checkExpressionCached(func.body, contextualMapper); + // return type of the body should be unwrapped to its awaited type, which we will wrap in + // the native Promise type later in this function. + type = getAwaitedType(type, func, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); } } else { // Aggregate the types of expressions within all the return statements. - let types = checkAndAggregateReturnExpressionTypes(func.body, contextualMapper); + let types = checkAndAggregateReturnExpressionTypes(func.body, contextualMapper, isAsync); if (types.length === 0) { if (isAsync) { // For an async function, the return type will not be void, but rather a Promise for void. @@ -7393,12 +7390,13 @@ module ts { forEachReturnStatement(body, returnStatement => { let expr = returnStatement.expression; if (expr) { - let type: Type; + let type = checkExpressionCached(expr, contextualMapper); if (isAsync) { - type = checkAwaitedExpressionCached(expr, contextualMapper); - } - else { - type = checkExpressionCached(expr, contextualMapper); + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so the + // return type of the body should be unwrapped to its awaited type, which should be wrapped in + // the native Promise type by the caller. + type = getAwaitedType(type, body.parent, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); } if (!contains(aggregatedTypes, type)) { @@ -7515,6 +7513,7 @@ module ts { let isAsync = isAsyncFunctionLike(node); let returnType = node.type && getTypeFromTypeNode(node.type); + let promisedType: Type; if (returnType && isAsync) { promisedType = checkAsyncFunctionReturnType(node, returnType); @@ -7532,17 +7531,19 @@ module ts { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so we // should not be checking assignability of a promise to the return type. Instead, we need to - // check assignability of the awaited type of the concise body against the promised type of + // check assignability of the awaited type of the expression body against the promised type of // its return type annotation. let exprType = checkExpression(node.body); if (returnType) { if (isAsync) { - checkTypeAssignableTo(getAwaitedType(exprType, node.body), promisedType, node.body); + let awaitedType = getAwaitedType(exprType, node.body, Diagnostics.Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member); + checkTypeAssignableTo(awaitedType, promisedType, node.body); } else { checkTypeAssignableTo(exprType, returnType, node.body); } } + checkFunctionExpressionBodies(node.body); } } @@ -8108,15 +8109,6 @@ module ts { return result; } - function checkAwaitedExpressionCached(node: Expression, contextualMapper?: TypeMapper): Type { - let links = getNodeLinks(node); - if (!links.resolvedAwaitedType) { - links.resolvedAwaitedType = getAwaitedType(checkExpressionCached(node, contextualMapper)); - } - - return links.resolvedAwaitedType; - } - function checkExpressionCached(node: Expression, contextualMapper?: TypeMapper): Type { let links = getNodeLinks(node); if (!links.resolvedType) { @@ -8960,7 +8952,7 @@ module ts { } function checkNonThenableType(type: Type, location?: Node, message?: DiagnosticMessage) { - if (!allConstituentTypesHaveKind(type, TypeFlags.Any) && isTypeAssignableTo(type, getGlobalThenableType())) { + if (!(type.flags & TypeFlags.Any) && isTypeAssignableTo(type, getGlobalThenableType())) { if (location) { if (!message) { message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; @@ -8991,7 +8983,7 @@ module ts { // } // - if (allConstituentTypesHaveKind(promise, TypeFlags.Any)) { + if (promise.flags & TypeFlags.Any) { return undefined; } @@ -9005,7 +8997,7 @@ module ts { } let thenFunction = getTypeOfPropertyOfType(promise, "then"); - if (thenFunction && allConstituentTypesHaveKind(thenFunction, TypeFlags.Any)) { + if (thenFunction && (thenFunction.flags & TypeFlags.Any)) { return undefined; } @@ -9015,7 +9007,7 @@ module ts { } let onfulfilledParameterType = getUnionType(map(thenSignatures, getTypeOfFirstParameterOfSignature)); - if (allConstituentTypesHaveKind(onfulfilledParameterType, TypeFlags.Any)) { + if (onfulfilledParameterType.flags & TypeFlags.Any) { return undefined; } @@ -9032,6 +9024,8 @@ module ts { return getTypeAtPosition(signature, 0); } + let alreadySeenTypesForAwait: boolean[] = []; + /** * Gets the "awaited type" of a type. * @param type The type to await. @@ -9039,58 +9033,81 @@ module ts { * Promise-like type; otherwise, it is the type of the expression. This is used to reflect * The runtime behavior of the `await` keyword. */ - function getAwaitedType(type: Type, location?: Node): Type { - // `seen` keeps track of types we've tried to await to avoid cycles. - // This is to protect against a bad actor with a mutually recursive promised type: - // - // declare class PromiseA { - // then(onfulfilled: (value: PromiseB) => any, onrejected?); - // } - // declare class PromiseB { - // then(onfulfilled: (value: PromiseA) => any, onrejected?); - // } - // - let seen: boolean[]; + function getAwaitedType(type: Type, location?: Node, message?: DiagnosticMessage): Type { + // reset the set of visited types + alreadySeenTypesForAwait.length = 0; while (true) { let promisedType = getPromisedType(type); - if (!promisedType) { - // this type could not be unwrapped further. We need to check to - // ensure it is not a thenable - if (checkNonThenableType(type, location)) { - return type; + if (promisedType === undefined) { + // The type was not a PromiseLike, so it could not be unwrapped any further. + // As long as the type does not have a known callable "then" property, then it is + // safe to return the type; otherwise, an error will have been reported in + // the call to checkNonThenableType and we will return unknownType. + // + // An example of a non-promise "thenable" might be: + // + // await { then(): void {} } + // + // The "thenable" does not match the minimal definition for a PromiseLike. When + // a Promise/A+-compatible or ES6 promise tries to adopt this value, the promise + // will never settle. We treat this as an error to help flag an early indicator + // of a runtime problem. If the user wants to return this value from an async + // function, they would need to wrap it in some other value. If they want it to + // be treated as a promise, they can cast to . + if (checkNonThenableType(type, location, message)) { + break; } - return unknownType; + type = unknownType; + break; } - if (!seen) { - if (promisedType === type) { - // if we have a bad actor in the form of a promise whose promised type is the same - // promise, return the unknown type as we cannot guess the shape. - // if this were the actual case in the JavaScript, this Promise would never resolve. - if (location) { - error(location, Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member); + // Keep track of the type we're about to unwrap to avoid bad recursive promise types. + // See the comments below for more information. + alreadySeenTypesForAwait[type.id] = true; + + if (alreadySeenTypesForAwait[promisedType.id]) { + // We have a bad actor in the form of a promise whose promised type is the same + // promise type, or a mutually recursive promise. Return the unknown type as we cannot guess + // the shape. If this were the actual case in the JavaScript, this Promise would never resolve. + // + // An example of a bad actor with a singly-recursive promise type might be: + // + // interface BadPromise { + // then(onfulfilled: (value: BadPromise) => any, onrejected: (error: any) => any): BadPromise; + // } + // + // The above interface will pass the PromiseLike check, and return a promised type of `BadPromise`. + // Since this is a self reference, we don't want to keep recursing ad infinitum. + // + // An example of a bad actor in the form of a mutually-recursive promise type might be: + // + // interface BadPromiseA { + // then(onfulfilled: (value: BadPromiseB) => any, onrejected: (error: any) => any): BadPromiseB; + // } + // + // interface BadPromiseB { + // then(onfulfilled: (value: BadPromiseA) => any, onrejected: (error: any) => any): BadPromiseA; + // } + // + if (location) { + if (!message) { + message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; } - return unknownType; + error(location, message); } - seen = []; - seen[type.id] = true; - } - else if (seen[promisedType.id]) { - // if we've already seen this type, this is a promise that - // would never resolve. As above, we return the unknown type. - if (location) { - error(location, Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member); - } - - return unknownType; + type = unknownType; + break; } - seen[promisedType.id] = true; type = promisedType; } + + // Cleanup, reset the set of visited types + alreadySeenTypesForAwait.length = 0; + return type; } /** @@ -9109,20 +9126,48 @@ module ts { function checkAsyncFunctionReturnType(node: SignatureDeclaration, returnType: Type): Type { let globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(); if (globalPromiseConstructorLikeType !== emptyObjectType) { - // get the constructor type of the return type + // The return type of an async function will be the type of the instance. For this + // to be a type compatible with our async function emit, we must also check that + // the type of the declaration (e.g. the static side or "constructor" type of the + // promise) is a compatible `PromiseConstructorLike`. + // + // An example might be (from lib.es6.d.ts): + // + // interface Promise { ... } + // interface PromiseConstructor { + // new (...): Promise; + // } + // declare var Promise: PromiseConstructor; + // + // When an async function declares a return type annotation of `Promise`, we + // need to get the type of the `Promise` variable declaration above, which would + // be `PromiseConstructor`. + // + // The same case applies to a class: + // + // declare class Promise { + // constructor(...); + // then(...): Promise; + // } + // + // When we get the type of the `Promise` symbol here, we get the type of the static + // side of the `Promise` class, which would be `{ new (...): Promise }`. let declaredType = returnType.symbol ? getTypeOfSymbol(returnType.symbol) : emptyObjectType; if (isTypeAssignableTo(declaredType, globalPromiseConstructorLikeType)) { - let promisedType = getPromisedType(returnType); - if (promisedType) { - // unwrap the promised type - let promiseConstructor = getPromiseConstructor(node); - if (promiseConstructor) { - checkExpressionOrQualifiedName(promiseConstructor); - } - - emitAwaiter = true; - return getAwaitedType(promisedType, node); + // Ensure we will emit the `__awaiter` helper. + emitAwaiter = true; + + // When we emit the async function, we need to ensure we emit any imports that might + // otherwise have been elided if the return type were only ever referenced in a type + // position. As such, we get the entity name of the type reference from the return + // type and check it as an expression. + let promiseConstructor = getPromiseConstructor(node); + if (promiseConstructor) { + checkExpressionOrQualifiedName(promiseConstructor); } + + // Get and return the awaited type of the return type. + return getAwaitedType(returnType, node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); } } @@ -10060,11 +10105,15 @@ module ts { error(node.expression, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } } - else if (func.type && !isAccessor(func.kind) && isAsyncFunctionLike(func)) { - checkTypeAssignableTo(getAwaitedType(exprType), getAwaitedType(returnType), node.expression); - } else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) { - checkTypeAssignableTo(exprType, returnType, node.expression); + if (isAsyncFunctionLike(func)) { + let promisedType = getPromisedType(returnType); + let awaitedType = getAwaitedType(exprType, node.expression, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + checkTypeAssignableTo(awaitedType, promisedType, node.expression); + } + else { + checkTypeAssignableTo(exprType, returnType, node.expression); + } } } } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 3f781a26809..6469bf8b1bb 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -51,6 +51,8 @@ module ts { Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." }, An_async_function_or_method_must_have_a_valid_awaitable_return_type: { code: 1057, category: DiagnosticCategory.Error, key: "An async function or method must have a valid awaitable return type." }, Operand_for_await_does_not_have_a_valid_callable_then_member: { code: 1058, category: DiagnosticCategory.Error, key: "Operand for 'await' does not have a valid callable 'then' member." }, + Return_expression_in_async_function_does_not_have_a_valid_callable_then_member: { code: 1059, category: DiagnosticCategory.Error, key: "Return expression in async function does not have a valid callable 'then' member." }, + Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member: { code: 1060, category: DiagnosticCategory.Error, key: "Expression body for async arrow function does not have a valid callable 'then' member." }, Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." }, An_export_assignment_cannot_be_used_in_a_namespace: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a namespace." }, Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." }, @@ -376,7 +378,7 @@ module ts { Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." }, Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." }, - The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression." }, + The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index df419f7ec8c..b1e8f565790 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -191,6 +191,14 @@ "category": "Error", "code": 1058 }, + "Return expression in async function does not have a valid callable 'then' member.": { + "category": "Error", + "code": 1059 + }, + "Expression body for async arrow function does not have a valid callable 'then' member.": { + "category": "Error", + "code": 1060 + }, "Enum member must have initializer.": { "category": "Error", "code": 1061 @@ -1494,7 +1502,7 @@ "category": "Error", "code": 2521 }, - "The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression.": { + "The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression.": { "category": "Error", "code": 2522 }, diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt index 6b80a53f529..dcaba564e23 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts(4,52): error TS2522: The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts(4,52): error TS2522: The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression. ==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts (1 errors) ==== @@ -7,7 +7,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesA function other() {} var fn = async () => await other.apply(this, arguments); ~~~~~~~~~ -!!! error TS2522: The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression. +!!! error TS2522: The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression. } } \ No newline at end of file From ac447f1f513fbbe3eb16eb7f0dcaf795ef080792 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 21 May 2015 16:45:23 -0700 Subject: [PATCH 027/309] Migrated decorator checks to call resolution --- src/compiler/checker.ts | 368 +++++++++++++++--- .../diagnosticInformationMap.generated.ts | 2 + src/compiler/diagnosticMessages.json | 8 + src/compiler/types.ts | 2 +- src/compiler/utilities.ts | 3 + .../decoratedClassFromExternalModule.js | 4 +- .../decoratedClassFromExternalModule.symbols | 5 +- .../decoratedClassFromExternalModule.types | 7 +- .../decoratorChecksFunctionBodies.errors.txt | 2 +- .../decoratorChecksFunctionBodies.js | 4 +- ...ratorInstantiateModulesInFunctionBodies.js | 4 +- ...InstantiateModulesInFunctionBodies.symbols | 3 +- ...orInstantiateModulesInFunctionBodies.types | 11 +- .../reference/decoratorOnClass8.errors.txt | 6 +- .../decoratorOnClassMethod10.errors.txt | 16 +- .../reference/decoratorOnClassMethod13.js | 2 +- .../decoratorOnClassMethod13.symbols | 16 +- .../reference/decoratorOnClassMethod13.types | 8 +- .../decoratorOnClassMethod6.errors.txt | 13 + .../reference/decoratorOnClassMethod6.symbols | 18 - .../reference/decoratorOnClassMethod6.types | 19 - .../decoratorOnClassMethod8.errors.txt | 13 + .../reference/decoratorOnClassMethod8.symbols | 15 - .../reference/decoratorOnClassMethod8.types | 15 - .../decoratorOnClassMethodParameter1.js | 2 +- .../decoratorOnClassMethodParameter1.symbols | 10 +- .../decoratorOnClassMethodParameter1.types | 10 +- .../decoratorOnClassProperty11.errors.txt | 13 + .../decoratorOnClassProperty11.symbols | 14 - .../decoratorOnClassProperty11.types | 14 - .../decoratorOnClassProperty6.errors.txt | 13 + .../decoratorOnClassProperty6.symbols | 13 - .../reference/decoratorOnClassProperty6.types | 13 - .../decoratorOnClassProperty7.errors.txt | 6 +- .../reference/missingDecoratorType.errors.txt | 22 +- .../reference/missingDecoratorType.js | 15 +- tests/baselines/reference/noEmitHelpers2.js | 3 +- .../reference/noEmitHelpers2.symbols | 10 +- .../baselines/reference/noEmitHelpers2.types | 8 +- .../sourceMapValidationDecorators.js | 4 +- ...ourceMapValidationDecorators.sourcemap.txt | 4 +- .../sourceMapValidationDecorators.symbols | 36 +- .../sourceMapValidationDecorators.types | 40 +- tests/cases/compiler/noEmitHelpers2.ts | 2 +- .../compiler/sourceMapValidationDecorators.ts | 4 +- .../class/decoratedClassFromExternalModule.ts | 2 +- .../class/decoratorChecksFunctionBodies.ts | 2 +- ...ratorInstantiateModulesInFunctionBodies.ts | 2 +- .../class/method/decoratorOnClassMethod13.ts | 2 +- .../decoratorOnClassMethodParameter1.ts | 2 +- .../decorators/missingDecoratorType.ts | 9 +- 51 files changed, 533 insertions(+), 306 deletions(-) create mode 100644 tests/baselines/reference/decoratorOnClassMethod6.errors.txt delete mode 100644 tests/baselines/reference/decoratorOnClassMethod6.symbols delete mode 100644 tests/baselines/reference/decoratorOnClassMethod6.types create mode 100644 tests/baselines/reference/decoratorOnClassMethod8.errors.txt delete mode 100644 tests/baselines/reference/decoratorOnClassMethod8.symbols delete mode 100644 tests/baselines/reference/decoratorOnClassMethod8.types create mode 100644 tests/baselines/reference/decoratorOnClassProperty11.errors.txt delete mode 100644 tests/baselines/reference/decoratorOnClassProperty11.symbols delete mode 100644 tests/baselines/reference/decoratorOnClassProperty11.types create mode 100644 tests/baselines/reference/decoratorOnClassProperty6.errors.txt delete mode 100644 tests/baselines/reference/decoratorOnClassProperty6.symbols delete mode 100644 tests/baselines/reference/decoratorOnClassProperty6.types diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9bd0d6475fe..e99dd7eeb4e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -114,10 +114,7 @@ module ts { let globalIterableType: ObjectType; let anyArrayType: Type; - let getGlobalClassDecoratorType: () => ObjectType; - let getGlobalParameterDecoratorType: () => ObjectType; - let getGlobalPropertyDecoratorType: () => ObjectType; - let getGlobalMethodDecoratorType: () => ObjectType; + let getGlobalTypedPropertyDescriptorType: () => ObjectType; let tupleTypes: Map = {}; let unionTypes: Map = {}; @@ -3975,8 +3972,8 @@ module ts { return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage): boolean { - return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage); + function checkTypeAssignableTo(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source: Signature, target: Signature): boolean { @@ -6539,7 +6536,7 @@ module ts { if (node.kind === SyntaxKind.TaggedTemplateExpression) { checkExpression((node).template); } - else { + else if (node.kind !== SyntaxKind.Decorator) { forEach((node).arguments, argument => { checkExpression(argument); }); @@ -6645,6 +6642,41 @@ module ts { callIsIncomplete = !!templateLiteral.isUnterminated; } } + else if (node.kind === SyntaxKind.Decorator) { + let decorator = node; + switch (decorator.parent.kind) { + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + // A class decorator will have one argument (see `ClassDecorator` in core.d.ts) + adjustedArgCount = 1; + typeArguments = undefined; + break; + + case SyntaxKind.PropertyDeclaration: + // A property declaration decorator will have two arguments (see + // `PropertyDecorator` in core.d.ts) + adjustedArgCount = 2; + typeArguments = undefined; + break; + + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // A method or accessor declaration decorator will have two or three arguments (see + // `MethodDecorator` in core.d.ts) + adjustedArgCount = signature.parameters.length >= 3 ? 3 : 2; + typeArguments = undefined; + break; + + case SyntaxKind.Parameter: + // A parameter declaration decorator will have three arguments (see + // `ParameterDecorator` in core.d.ts) + + adjustedArgCount = 3; + typeArguments = undefined; + break; + } + } else { let callExpression = node; if (!callExpression.arguments) { @@ -6742,11 +6774,8 @@ module ts { let arg = args[i]; if (arg.kind !== SyntaxKind.OmittedExpression) { let paramType = getTypeAtPosition(signature, i); - let argType: Type; - if (i === 0 && args[i].parent.kind === SyntaxKind.TaggedTemplateExpression) { - argType = globalTemplateStringsArrayType; - } - else { + let argType = getSyntheticArgumentType(i, arg); + if (argType === undefined) { // For context sensitive arguments we pass the identityMapper, which is a signal to treat all // context sensitive function expressions as wildcards let mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; @@ -6773,7 +6802,7 @@ module ts { getInferredTypes(context); } - function checkTypeArguments(signature: Signature, typeArguments: TypeNode[], typeArgumentResultTypes: Type[], reportErrors: boolean): boolean { + function checkTypeArguments(signature: Signature, typeArguments: TypeNode[], typeArgumentResultTypes: Type[], reportErrors: boolean, containingMessageChain?: DiagnosticMessageChain): boolean { let typeParameters = signature.typeParameters; let typeArgumentsAreAssignable = true; for (let i = 0; i < typeParameters.length; i++) { @@ -6785,14 +6814,147 @@ module ts { let constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, - Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + Diagnostics.Type_0_does_not_satisfy_the_constraint_1, containingMessageChain); } } } return typeArgumentsAreAssignable; } + + function getTypeOfParentOfClassElement(node: ClassElement) { + let classSymbol = getSymbolOfNode(node.parent); + if (node.flags & NodeFlags.Static) { + return getTypeOfSymbol(classSymbol); + } + else { + return getDeclaredTypeOfSymbol(classSymbol); + } + } + + function createTypedPropertyDescriptorType(propertyType: Type): Type { + let globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); + return globalTypedPropertyDescriptorType !== emptyObjectType + ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) + : emptyObjectType; + } + + /** + * Gets the type for a synthetic argument when resolving the first argument for a TaggedTemplateExpression + * or any arguments to a Decorator. + */ + function getSyntheticArgumentType(argumentIndex: number, arg: Expression): Type { + if (arg.parent.kind === SyntaxKind.Decorator) { + let decorator = arg.parent; + let parent = decorator.parent; + if (argumentIndex === 0) { + // The first argument to a decorator is its `target`. + switch (parent.kind) { + case SyntaxKind.ClassDeclaration: + // For a class decorator, the `target` is the type of the class (e.g. the + // "static" or "constructor" side of the class) + let classSymbol = getSymbolOfNode(parent); + return getTypeOfSymbol(classSymbol); + + case SyntaxKind.Parameter: + // For a parameter decorator, the `target` is the parent type of the + // parameter's containing method. + parent = parent.parent; + if (parent.kind === SyntaxKind.Constructor) { + let classSymbol = getSymbolOfNode(parent); + return getTypeOfSymbol(classSymbol); + } + + // fall-through + + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // For a property or method decorator, the `target` is the + // "static"-side type of the parent of the member if the member is + // declared "static"; otherwise, it is the "instance"-side type of the + // parent of the member. + return getTypeOfParentOfClassElement(parent); + } + } + else if (argumentIndex === 1) { + // The second argument to a decorator is its `propertyKey` + switch (parent.kind) { + case SyntaxKind.ClassDeclaration: + Debug.fail("Class decorators should not have a second synthetic argument."); + + case SyntaxKind.Parameter: + parent = parent.parent; + if (parent.kind === SyntaxKind.Constructor) { + // For a constructor parameter decorator, the `propertyKey` will be `undefined`. + return anyType; + } + + // For a non-constructor parameter decorator, the `propertyKey` will be either + // a string or a symbol, based on the name of the parameter's containing method. + + // fall-through + + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // The `propertyKey` for a property or method decorator will be a + // string literal type if the member name is an identifier, number, or string; + // otherwise, if the member name is a computed property name it will + // be either string or symbol. + let element = decorator.parent; + switch (element.name.kind) { + case SyntaxKind.Identifier: + case SyntaxKind.NumericLiteral: + case SyntaxKind.StringLiteral: + return getStringLiteralType(element.name); + + case SyntaxKind.ComputedPropertyName: + let nameType = checkComputedPropertyName(element.name); + if (allConstituentTypesHaveKind(nameType, TypeFlags.ESSymbol)) { + return nameType; + } + else { + return stringType; + } + } + } + } + else if (argumentIndex === 2) { + // The third argument to a decorator is either its `descriptor` for a method decorator + // or its `parameterIndex` for a paramter decorator + switch (parent.kind) { + case SyntaxKind.ClassDeclaration: + Debug.fail("Class decorators should not have a third synthetic argument."); + break; - function checkApplicableSignature(node: CallLikeExpression, args: Expression[], signature: Signature, relation: Map, excludeArgument: boolean[], reportErrors: boolean) { + case SyntaxKind.Parameter: + // The `parameterIndex` for a parameter decorator is always a number + return numberType; + + case SyntaxKind.PropertyDeclaration: + Debug.fail("Property decorators should not have a third synthetic argument."); + break; + + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor` + // for the type of the member. + let propertyType: Type = getTypeOfNode(parent); + return createTypedPropertyDescriptorType(propertyType); + } + } + } + else if (argumentIndex === 0 && arg.parent.kind === SyntaxKind.TaggedTemplateExpression) { + return globalTemplateStringsArrayType; + } + + return undefined; + } + + function checkApplicableSignature(node: CallLikeExpression, args: Expression[], signature: Signature, relation: Map, excludeArgument: boolean[], reportErrors: boolean, containingMessageChain?: DiagnosticMessageChain) { for (let i = 0; i < args.length; i++) { let arg = args[i]; if (arg.kind !== SyntaxKind.OmittedExpression) { @@ -6800,15 +6962,16 @@ module ts { let paramType = getTypeAtPosition(signature, i); // A tagged template expression provides a special first argument, and string literals get string literal types // unless we're reporting errors - let argType = i === 0 && node.kind === SyntaxKind.TaggedTemplateExpression - ? globalTemplateStringsArrayType - : arg.kind === SyntaxKind.StringLiteral && !reportErrors + let argType = getSyntheticArgumentType(i, arg); + if (argType === undefined) { + argType = arg.kind === SyntaxKind.StringLiteral && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + } // Use argument expression as error location when reporting errors if (!checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, - Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1)) { + Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1, containingMessageChain)) { return false; } } @@ -6822,6 +6985,8 @@ module ts { * If 'node' is a CallExpression or a NewExpression, then its argument list is returned. * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution * expressions, where the first element of the list is the template for error reporting purposes. + * If 'node' is a Decorator, a new argument list is constructed with the decorator + * expression as a placeholder. */ function getEffectiveCallArguments(node: CallLikeExpression): Expression[] { let args: Expression[]; @@ -6835,6 +7000,23 @@ module ts { }); } } + else if (node.kind === SyntaxKind.Decorator) { + let decorator = node; + switch (decorator.parent.kind) { + case SyntaxKind.ClassDeclaration: + args = [decorator.expression]; + break; + case SyntaxKind.PropertyDeclaration: + args = [decorator.expression, decorator.expression]; + break; + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.Parameter: + args = [decorator.expression, decorator.expression, decorator.expression]; + break; + } + } else { args = (node).arguments || emptyArray; } @@ -6863,13 +7045,14 @@ module ts { return callExpression.typeArguments; } } - - function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[]): Signature { + + function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[], containingMessageChain?: DiagnosticMessageChain): Signature { let isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression; + let isDecorator = node.kind === SyntaxKind.Decorator; let typeArguments: TypeNode[]; - if (!isTaggedTemplate) { + if (!isTaggedTemplate && !isDecorator) { typeArguments = getEffectiveTypeArguments(node); // We already perform checking on the type arguments on the class declaration itself. @@ -6882,7 +7065,7 @@ module ts { // reorderCandidates fills up the candidates array directly reorderCandidates(signatures, candidates); if (!candidates.length) { - error(node, Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); return resolveErrorCall(node); } @@ -6900,12 +7083,14 @@ module ts { // For a tagged template, then the first argument be 'undefined' if necessary // because it represents a TemplateStringsArray. let excludeArgument: boolean[]; - for (let i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { - if (isContextSensitive(args[i])) { - if (!excludeArgument) { - excludeArgument = new Array(args.length); + if (!isDecorator) { + for (let i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { + if (isContextSensitive(args[i])) { + if (!excludeArgument) { + excludeArgument = new Array(args.length); + } + excludeArgument[i] = true; } - excludeArgument[i] = true; } } @@ -6969,11 +7154,11 @@ module ts { // in arguments too early. If possible, we'd like to only type them once we know the correct // overload. However, this matters for the case where the call is correct. When the call is // an error, we don't need to exclude any arguments, although it would cause no harm to do so. - checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true); + checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true, containingMessageChain); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && (node).typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, (node).typeArguments, [], /*reportErrors*/ true) + if (!isTaggedTemplate && !isDecorator && (node).typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, (node).typeArguments, [], /*reportErrors*/ true, containingMessageChain) } else { Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); @@ -6983,12 +7168,16 @@ module ts { let diagnosticChainHead = chainDiagnosticMessages(/*details*/ undefined, // details will be provided by call to reportNoCommonSupertypeError Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, typeToString(failedTypeParameter)); + + if (containingMessageChain) { + diagnosticChainHead = concatenateDiagnosticMessageChains(containingMessageChain, diagnosticChainHead); + } reportNoCommonSupertypeError(inferenceCandidates, (node).expression || (node).tag, diagnosticChainHead); } } else { - error(node, Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); } // No signature was applicable. We have already reported the errors for the invalid signature. @@ -7005,6 +7194,15 @@ module ts { } return resolveErrorCall(node); + + function reportError(message: DiagnosticMessage, arg0?: string, arg1?: string, arg2?: string): void { + let errorInfo = chainDiagnosticMessages(/*details*/ undefined, message, arg0, arg1, arg2); + if (containingMessageChain) { + errorInfo = concatenateDiagnosticMessageChains(containingMessageChain, errorInfo); + } + + diagnostics.add(createDiagnosticForNodeFromMessageChain(node, errorInfo)); + } function chooseOverload(candidates: Signature[], relation: Map) { for (let originalCandidate of candidates) { @@ -7205,6 +7403,55 @@ module ts { return resolveCall(node, callSignatures, candidatesOutArray); } + function resolveDecorator(node: Decorator, candidatesOutArray: Signature[]): Signature { + let funcType = checkExpression(node.expression); + let apparentType = getApparentType(funcType); + if (apparentType === unknownType) { + return resolveErrorCall(node); + } + + let callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call); + if (funcType === anyType || (!callSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) { + return resolveUntypedCall(node); + } + + let decoratorKind: string; + switch (node.parent.kind) { + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + decoratorKind = "class"; + break; + + case SyntaxKind.Parameter: + decoratorKind = "parameter"; + break; + + case SyntaxKind.PropertyDeclaration: + decoratorKind = "property"; + break; + + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + decoratorKind = "method"; + break; + + default: + Debug.fail("Invalid decorator target."); + break; + } + + let diagnosticChainHead = chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Invalid_expression_for_0_decorator, decoratorKind); + if (!callSignatures.length) { + let errorInfo = chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); + errorInfo = concatenateDiagnosticMessageChains(diagnosticChainHead, errorInfo); + diagnostics.add(createDiagnosticForNodeFromMessageChain(node, errorInfo)); + return resolveErrorCall(node); + } + + return resolveCall(node, callSignatures, candidatesOutArray, diagnosticChainHead); + } + // candidatesOutArray is passed by signature help in the language service, and collectCandidates // must fill it up with the appropriate candidate signatures function getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature { @@ -7225,6 +7472,9 @@ module ts { else if (node.kind === SyntaxKind.TaggedTemplateExpression) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } + else if (node.kind === SyntaxKind.Decorator) { + links.resolvedSignature = resolveDecorator(node, candidatesOutArray); + } else { Debug.fail("Branch in 'getResolvedSignature' should be unreachable."); } @@ -8844,35 +9094,58 @@ module ts { /** Check a decorator */ function checkDecorator(node: Decorator): void { - let expression: Expression = node.expression; - let exprType = checkExpression(expression); - + let signature = getResolvedSignature(node); + let returnType = getReturnTypeOfSignature(signature); + if (returnType.flags & TypeFlags.Any) { + return; + } + + let expectedReturnType: Type; + let diagnosticChainHead: DiagnosticMessageChain; + let decoratorKind: string; switch (node.parent.kind) { case SyntaxKind.ClassDeclaration: let classSymbol = getSymbolOfNode(node.parent); let classConstructorType = getTypeOfSymbol(classSymbol); - let classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); - checkTypeAssignableTo(exprType, classDecoratorType, node); + expectedReturnType = getUnionType([classConstructorType, voidType]); + decoratorKind = "class"; + break; + + case SyntaxKind.Parameter: + expectedReturnType = voidType; + decoratorKind = "parameter"; break; case SyntaxKind.PropertyDeclaration: - checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); + expectedReturnType = voidType; + decoratorKind = "property"; break; case SyntaxKind.MethodDeclaration: case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: let methodType = getTypeOfNode(node.parent); - let methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); - checkTypeAssignableTo(exprType, methodDecoratorType, node); - break; - - case SyntaxKind.Parameter: - checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); + let descriptorType = createTypedPropertyDescriptorType(methodType); + expectedReturnType = getUnionType([descriptorType, voidType]); + decoratorKind = "method"; break; } + + if (expectedReturnType === voidType) { + diagnosticChainHead = chainDiagnosticMessages( + diagnosticChainHead, + Diagnostics.The_return_type_of_a_0_decorator_function_must_be_either_void_or_any, + decoratorKind); + } + + diagnosticChainHead = chainDiagnosticMessages( + diagnosticChainHead, + Diagnostics.Invalid_expression_for_0_decorator, + decoratorKind); + + checkTypeAssignableTo(returnType, expectedReturnType, node, /*headMessage*/ undefined, diagnosticChainHead); } - + /** Checks a type reference node as an expression. */ function checkTypeNodeAsExpression(node: TypeNode) { // When we are emitting type metadata for decorators, we need to try to check the type @@ -12043,10 +12316,7 @@ module ts { globalNumberType = getGlobalType("Number"); globalBooleanType = getGlobalType("Boolean"); globalRegExpType = getGlobalType("RegExp"); - getGlobalClassDecoratorType = memoize(() => getGlobalType("ClassDecorator")); - getGlobalPropertyDecoratorType = memoize(() => getGlobalType("PropertyDecorator")); - getGlobalMethodDecoratorType = memoize(() => getGlobalType("MethodDecorator")); - getGlobalParameterDecoratorType = memoize(() => getGlobalType("ParameterDecorator")); + getGlobalTypedPropertyDescriptorType = memoize(() => getGlobalType("TypedPropertyDescriptor", /*arity*/ 1)); // If we're in ES6 mode, load the TemplateStringsArray. // Otherwise, default to 'unknown' for the purposes of type checking in LS scenarios. diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 2a852716846..1eaf69d8886 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -174,6 +174,8 @@ module ts { Type_expected_0_is_a_reserved_word_in_strict_mode: { code: 1215, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode" }, Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, + The_return_type_of_a_0_decorator_function_must_be_either_void_or_any: { code: 1219, category: DiagnosticCategory.Error, key: "The return type of a {0} decorator function must be either 'void' or 'any'." }, + Invalid_expression_for_0_decorator: { code: 1220, category: DiagnosticCategory.Error, key: "Invalid expression for {0} decorator." }, 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." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index cf1645b1407..36f7505fc65 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -683,6 +683,14 @@ "category": "Error", "code": 1218 }, + "The return type of a {0} decorator function must be either 'void' or 'any'.": { + "category": "Error", + "code": 1219 + }, + "Invalid expression for {0} decorator.": { + "category": "Error", + "code": 1220 + }, "Duplicate identifier '{0}'.": { "category": "Error", diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 86e680ca8b0..2c63241fdf2 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -753,7 +753,7 @@ module ts { template: LiteralExpression | TemplateExpression; } - export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression; + export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator; export interface TypeAssertion extends UnaryExpression { type: TypeNode; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 356337e1315..e720c7a112e 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -620,6 +620,9 @@ module ts { if (node.kind === SyntaxKind.TaggedTemplateExpression) { return (node).tag; } + else if (node.kind === SyntaxKind.Decorator) { + return (node).expression; + } // Will either be a CallExpression or NewExpression. return (node).expression; diff --git a/tests/baselines/reference/decoratedClassFromExternalModule.js b/tests/baselines/reference/decoratedClassFromExternalModule.js index 163a4a094b4..aca1d28b952 100644 --- a/tests/baselines/reference/decoratedClassFromExternalModule.js +++ b/tests/baselines/reference/decoratedClassFromExternalModule.js @@ -1,7 +1,7 @@ //// [tests/cases/conformance/decorators/class/decoratedClassFromExternalModule.ts] //// //// [decorated.ts] -function decorate() { } +function decorate(target: any) { } @decorate export default class Decorated { } @@ -18,7 +18,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key, case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); } }; -function decorate() { } +function decorate(target) { } let Decorated = class { }; Decorated = __decorate([ diff --git a/tests/baselines/reference/decoratedClassFromExternalModule.symbols b/tests/baselines/reference/decoratedClassFromExternalModule.symbols index aa17dde616a..60e4a892ec0 100644 --- a/tests/baselines/reference/decoratedClassFromExternalModule.symbols +++ b/tests/baselines/reference/decoratedClassFromExternalModule.symbols @@ -1,12 +1,13 @@ === tests/cases/conformance/decorators/class/decorated.ts === -function decorate() { } +function decorate(target: any) { } >decorate : Symbol(decorate, Decl(decorated.ts, 0, 0)) +>target : Symbol(target, Decl(decorated.ts, 0, 18)) @decorate >decorate : Symbol(decorate, Decl(decorated.ts, 0, 0)) export default class Decorated { } ->Decorated : Symbol(Decorated, Decl(decorated.ts, 0, 23)) +>Decorated : Symbol(Decorated, Decl(decorated.ts, 0, 34)) === tests/cases/conformance/decorators/class/undecorated.ts === import Decorated from 'decorated'; diff --git a/tests/baselines/reference/decoratedClassFromExternalModule.types b/tests/baselines/reference/decoratedClassFromExternalModule.types index 4234b6a4b15..d4bc3239e46 100644 --- a/tests/baselines/reference/decoratedClassFromExternalModule.types +++ b/tests/baselines/reference/decoratedClassFromExternalModule.types @@ -1,9 +1,10 @@ === tests/cases/conformance/decorators/class/decorated.ts === -function decorate() { } ->decorate : () => void +function decorate(target: any) { } +>decorate : (target: any) => void +>target : any @decorate ->decorate : () => void +>decorate : (target: any) => void export default class Decorated { } >Decorated : Decorated diff --git a/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt b/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt index c8166b538fd..cef2f90f704 100644 --- a/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt +++ b/tests/baselines/reference/decoratorChecksFunctionBodies.errors.txt @@ -8,7 +8,7 @@ tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts(9,14): } class A { - @(x => { + @((x, p) => { var a = 3; func(a); ~ diff --git a/tests/baselines/reference/decoratorChecksFunctionBodies.js b/tests/baselines/reference/decoratorChecksFunctionBodies.js index 020bc775aea..adb710efccc 100644 --- a/tests/baselines/reference/decoratorChecksFunctionBodies.js +++ b/tests/baselines/reference/decoratorChecksFunctionBodies.js @@ -5,7 +5,7 @@ function func(s: string): void { } class A { - @(x => { + @((x, p) => { var a = 3; func(a); return x; @@ -34,7 +34,7 @@ var A = (function () { }; Object.defineProperty(A.prototype, "m", __decorate([ - (function (x) { + (function (x, p) { var a = 3; func(a); return x; diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js index 313d77fa5ce..08ba6e9ea7e 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js @@ -9,7 +9,7 @@ export var test = 'abc'; import { test } from './a'; function filter(handler: any) { - return function (target: any) { + return function (target: any, propertyKey: string) { // ... }; } @@ -35,7 +35,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key, }; var a_1 = require('./a'); function filter(handler) { - return function (target) { + return function (target, propertyKey) { // ... }; } diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols index 5088e740a57..f7c96097caf 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.symbols @@ -12,8 +12,9 @@ function filter(handler: any) { >filter : Symbol(filter, Decl(b.ts, 0, 27)) >handler : Symbol(handler, Decl(b.ts, 2, 16)) - return function (target: any) { + return function (target: any, propertyKey: string) { >target : Symbol(target, Decl(b.ts, 3, 21)) +>propertyKey : Symbol(propertyKey, Decl(b.ts, 3, 33)) // ... }; diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types index 18d993af9bb..d0f930b7ad4 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.types @@ -10,12 +10,13 @@ import { test } from './a'; >test : string function filter(handler: any) { ->filter : (handler: any) => (target: any) => void +>filter : (handler: any) => (target: any, propertyKey: string) => void >handler : any - return function (target: any) { ->function (target: any) { // ... } : (target: any) => void + return function (target: any, propertyKey: string) { +>function (target: any, propertyKey: string) { // ... } : (target: any, propertyKey: string) => void >target : any +>propertyKey : string // ... }; @@ -25,8 +26,8 @@ class Wat { >Wat : Wat @filter(() => test == 'abc') ->filter(() => test == 'abc') : (target: any) => void ->filter : (handler: any) => (target: any) => void +>filter(() => test == 'abc') : (target: any, propertyKey: string) => void +>filter : (handler: any) => (target: any, propertyKey: string) => void >() => test == 'abc' : () => boolean >test == 'abc' : boolean >test : string diff --git a/tests/baselines/reference/decoratorOnClass8.errors.txt b/tests/baselines/reference/decoratorOnClass8.errors.txt index 0a9fbf2956c..31abd9e2300 100644 --- a/tests/baselines/reference/decoratorOnClass8.errors.txt +++ b/tests/baselines/reference/decoratorOnClass8.errors.txt @@ -1,4 +1,5 @@ -tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS2322: Type '(target: Function, paramIndex: number) => void' is not assignable to type '(target: typeof C) => void | typeof C'. +tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS1220: Invalid expression for class decorator. + Supplied parameters do not match any signature of call target. ==== tests/cases/conformance/decorators/class/decoratorOnClass8.ts (1 errors) ==== @@ -6,6 +7,7 @@ tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS2322 @dec() ~~~~~~ -!!! error TS2322: Type '(target: Function, paramIndex: number) => void' is not assignable to type '(target: typeof C) => void | typeof C'. +!!! error TS1220: Invalid expression for class decorator. +!!! error TS1220: Supplied parameters do not match any signature of call target. class C { } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod10.errors.txt b/tests/baselines/reference/decoratorOnClassMethod10.errors.txt index cd331473b7c..bfc56717e6c 100644 --- a/tests/baselines/reference/decoratorOnClassMethod10.errors.txt +++ b/tests/baselines/reference/decoratorOnClassMethod10.errors.txt @@ -1,7 +1,6 @@ -tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,5): error TS2322: Type '(target: Function, paramIndex: number) => void' is not assignable to type '(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<() => void>) => void | TypedPropertyDescriptor<() => void>'. - Types of parameters 'paramIndex' and 'propertyKey' are incompatible. - Type 'number' is not assignable to type 'string | symbol'. - Type 'number' is not assignable to type 'symbol'. +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,6): error TS1220: Invalid expression for method decorator. + Argument of type 'C' is not assignable to parameter of type 'Function'. + Property 'apply' is missing in type 'C'. ==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts (1 errors) ==== @@ -9,9 +8,8 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,5) class C { @dec method() {} - ~~~~ -!!! error TS2322: Type '(target: Function, paramIndex: number) => void' is not assignable to type '(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<() => void>) => void | TypedPropertyDescriptor<() => void>'. -!!! error TS2322: Types of parameters 'paramIndex' and 'propertyKey' are incompatible. -!!! error TS2322: Type 'number' is not assignable to type 'string | symbol'. -!!! error TS2322: Type 'number' is not assignable to type 'symbol'. + ~~~ +!!! error TS1220: Invalid expression for method decorator. +!!! error TS1220: Argument of type 'C' is not assignable to parameter of type 'Function'. +!!! error TS1220: Property 'apply' is missing in type 'C'. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod13.js b/tests/baselines/reference/decoratorOnClassMethod13.js index 967cc05ba4d..b39fa63686a 100644 --- a/tests/baselines/reference/decoratorOnClassMethod13.js +++ b/tests/baselines/reference/decoratorOnClassMethod13.js @@ -1,5 +1,5 @@ //// [decoratorOnClassMethod13.ts] -declare function dec(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor; +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; class C { @dec ["1"]() { } diff --git a/tests/baselines/reference/decoratorOnClassMethod13.symbols b/tests/baselines/reference/decoratorOnClassMethod13.symbols index af3819924f4..42f44d885ee 100644 --- a/tests/baselines/reference/decoratorOnClassMethod13.symbols +++ b/tests/baselines/reference/decoratorOnClassMethod13.symbols @@ -1,17 +1,17 @@ === tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts === -declare function dec(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor; +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; >dec : Symbol(dec, Decl(decoratorOnClassMethod13.ts, 0, 0)) ->T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 25)) ->target : Symbol(target, Decl(decoratorOnClassMethod13.ts, 0, 28)) ->propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod13.ts, 0, 40)) ->descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod13.ts, 0, 61)) +>T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21)) +>target : Symbol(target, Decl(decoratorOnClassMethod13.ts, 0, 24)) +>propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod13.ts, 0, 36)) +>descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod13.ts, 0, 57)) >TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) ->T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 25)) +>T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21)) >TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) ->T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 25)) +>T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21)) class C { ->C : Symbol(C, Decl(decoratorOnClassMethod13.ts, 0, 132)) +>C : Symbol(C, Decl(decoratorOnClassMethod13.ts, 0, 126)) @dec ["1"]() { } >dec : Symbol(dec, Decl(decoratorOnClassMethod13.ts, 0, 0)) diff --git a/tests/baselines/reference/decoratorOnClassMethod13.types b/tests/baselines/reference/decoratorOnClassMethod13.types index 2858f8877bd..5fdbe071828 100644 --- a/tests/baselines/reference/decoratorOnClassMethod13.types +++ b/tests/baselines/reference/decoratorOnClassMethod13.types @@ -1,6 +1,6 @@ === tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts === -declare function dec(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor; ->dec : () => (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; +>dec : (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor >T : T >target : any >propertyKey : string @@ -14,10 +14,10 @@ class C { >C : C @dec ["1"]() { } ->dec : () => (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor +>dec : (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor >"1" : string @dec ["b"]() { } ->dec : () => (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor +>dec : (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor >"b" : string } diff --git a/tests/baselines/reference/decoratorOnClassMethod6.errors.txt b/tests/baselines/reference/decoratorOnClassMethod6.errors.txt new file mode 100644 index 00000000000..ade416aefbc --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassMethod6.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): error TS1220: Invalid expression for method decorator. + Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts (1 errors) ==== + declare function dec(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor; + + class C { + @dec ["method"]() {} + ~~~~ +!!! error TS1220: Invalid expression for method decorator. +!!! error TS1220: Supplied parameters do not match any signature of call target. + } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod6.symbols b/tests/baselines/reference/decoratorOnClassMethod6.symbols deleted file mode 100644 index 8dcdd99a8e9..00000000000 --- a/tests/baselines/reference/decoratorOnClassMethod6.symbols +++ /dev/null @@ -1,18 +0,0 @@ -=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts === -declare function dec(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor; ->dec : Symbol(dec, Decl(decoratorOnClassMethod6.ts, 0, 0)) ->T : Symbol(T, Decl(decoratorOnClassMethod6.ts, 0, 25)) ->target : Symbol(target, Decl(decoratorOnClassMethod6.ts, 0, 28)) ->propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod6.ts, 0, 40)) ->descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod6.ts, 0, 61)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) ->T : Symbol(T, Decl(decoratorOnClassMethod6.ts, 0, 25)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) ->T : Symbol(T, Decl(decoratorOnClassMethod6.ts, 0, 25)) - -class C { ->C : Symbol(C, Decl(decoratorOnClassMethod6.ts, 0, 132)) - - @dec ["method"]() {} ->dec : Symbol(dec, Decl(decoratorOnClassMethod6.ts, 0, 0)) -} diff --git a/tests/baselines/reference/decoratorOnClassMethod6.types b/tests/baselines/reference/decoratorOnClassMethod6.types deleted file mode 100644 index 9da71791763..00000000000 --- a/tests/baselines/reference/decoratorOnClassMethod6.types +++ /dev/null @@ -1,19 +0,0 @@ -=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts === -declare function dec(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor; ->dec : () => (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor ->T : T ->target : any ->propertyKey : string ->descriptor : TypedPropertyDescriptor ->TypedPropertyDescriptor : TypedPropertyDescriptor ->T : T ->TypedPropertyDescriptor : TypedPropertyDescriptor ->T : T - -class C { ->C : C - - @dec ["method"]() {} ->dec : () => (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor ->"method" : string -} diff --git a/tests/baselines/reference/decoratorOnClassMethod8.errors.txt b/tests/baselines/reference/decoratorOnClassMethod8.errors.txt new file mode 100644 index 00000000000..d0635b4f5f3 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassMethod8.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts(4,5): error TS1220: Invalid expression for method decorator. + Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts (1 errors) ==== + declare function dec(target: T): T; + + class C { + @dec method() {} + ~~~~ +!!! error TS1220: Invalid expression for method decorator. +!!! error TS1220: Supplied parameters do not match any signature of call target. + } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod8.symbols b/tests/baselines/reference/decoratorOnClassMethod8.symbols deleted file mode 100644 index 84b68b81421..00000000000 --- a/tests/baselines/reference/decoratorOnClassMethod8.symbols +++ /dev/null @@ -1,15 +0,0 @@ -=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts === -declare function dec(target: T): T; ->dec : Symbol(dec, Decl(decoratorOnClassMethod8.ts, 0, 0)) ->T : Symbol(T, Decl(decoratorOnClassMethod8.ts, 0, 21)) ->target : Symbol(target, Decl(decoratorOnClassMethod8.ts, 0, 24)) ->T : Symbol(T, Decl(decoratorOnClassMethod8.ts, 0, 21)) ->T : Symbol(T, Decl(decoratorOnClassMethod8.ts, 0, 21)) - -class C { ->C : Symbol(C, Decl(decoratorOnClassMethod8.ts, 0, 38)) - - @dec method() {} ->dec : Symbol(dec, Decl(decoratorOnClassMethod8.ts, 0, 0)) ->method : Symbol(method, Decl(decoratorOnClassMethod8.ts, 2, 9)) -} diff --git a/tests/baselines/reference/decoratorOnClassMethod8.types b/tests/baselines/reference/decoratorOnClassMethod8.types deleted file mode 100644 index 20890b09846..00000000000 --- a/tests/baselines/reference/decoratorOnClassMethod8.types +++ /dev/null @@ -1,15 +0,0 @@ -=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts === -declare function dec(target: T): T; ->dec : (target: T) => T ->T : T ->target : T ->T : T ->T : T - -class C { ->C : C - - @dec method() {} ->dec : (target: T) => T ->method : () => void -} diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.js b/tests/baselines/reference/decoratorOnClassMethodParameter1.js index 4a3ed36eec5..a6ab1704acc 100644 --- a/tests/baselines/reference/decoratorOnClassMethodParameter1.js +++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.js @@ -1,5 +1,5 @@ //// [decoratorOnClassMethodParameter1.ts] -declare function dec(target: Function, propertyKey: string | symbol, parameterIndex: number): void; +declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; class C { method(@dec p: number) {} diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols b/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols index 0ced8829766..47c5999ff47 100644 --- a/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols +++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols @@ -1,13 +1,13 @@ === tests/cases/conformance/decorators/class/method/parameter/decoratorOnClassMethodParameter1.ts === -declare function dec(target: Function, propertyKey: string | symbol, parameterIndex: number): void; +declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; >dec : Symbol(dec, Decl(decoratorOnClassMethodParameter1.ts, 0, 0)) >target : Symbol(target, Decl(decoratorOnClassMethodParameter1.ts, 0, 21)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) ->propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethodParameter1.ts, 0, 38)) ->parameterIndex : Symbol(parameterIndex, Decl(decoratorOnClassMethodParameter1.ts, 0, 68)) +>Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethodParameter1.ts, 0, 36)) +>parameterIndex : Symbol(parameterIndex, Decl(decoratorOnClassMethodParameter1.ts, 0, 66)) class C { ->C : Symbol(C, Decl(decoratorOnClassMethodParameter1.ts, 0, 99)) +>C : Symbol(C, Decl(decoratorOnClassMethodParameter1.ts, 0, 97)) method(@dec p: number) {} >method : Symbol(method, Decl(decoratorOnClassMethodParameter1.ts, 2, 9)) diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.types b/tests/baselines/reference/decoratorOnClassMethodParameter1.types index 0b75471471f..74aa04a8985 100644 --- a/tests/baselines/reference/decoratorOnClassMethodParameter1.types +++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.types @@ -1,8 +1,8 @@ === tests/cases/conformance/decorators/class/method/parameter/decoratorOnClassMethodParameter1.ts === -declare function dec(target: Function, propertyKey: string | symbol, parameterIndex: number): void; ->dec : (target: Function, propertyKey: string | symbol, parameterIndex: number) => void ->target : Function ->Function : Function +declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; +>dec : (target: Object, propertyKey: string | symbol, parameterIndex: number) => void +>target : Object +>Object : Object >propertyKey : string | symbol >parameterIndex : number @@ -11,6 +11,6 @@ class C { method(@dec p: number) {} >method : (p: number) => void ->dec : (target: Function, propertyKey: string | symbol, parameterIndex: number) => void +>dec : (target: Object, propertyKey: string | symbol, parameterIndex: number) => void >p : number } diff --git a/tests/baselines/reference/decoratorOnClassProperty11.errors.txt b/tests/baselines/reference/decoratorOnClassProperty11.errors.txt new file mode 100644 index 00000000000..92b89b0b430 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassProperty11.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts(4,5): error TS1220: Invalid expression for property decorator. + Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts (1 errors) ==== + declare function dec(): (target: any, propertyKey: string) => void; + + class C { + @dec prop; + ~~~~ +!!! error TS1220: Invalid expression for property decorator. +!!! error TS1220: Supplied parameters do not match any signature of call target. + } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassProperty11.symbols b/tests/baselines/reference/decoratorOnClassProperty11.symbols deleted file mode 100644 index c7d6e39c713..00000000000 --- a/tests/baselines/reference/decoratorOnClassProperty11.symbols +++ /dev/null @@ -1,14 +0,0 @@ -=== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts === -declare function dec(): (target: any, propertyKey: string) => void; ->dec : Symbol(dec, Decl(decoratorOnClassProperty11.ts, 0, 0)) ->T : Symbol(T, Decl(decoratorOnClassProperty11.ts, 0, 25)) ->target : Symbol(target, Decl(decoratorOnClassProperty11.ts, 0, 28)) ->propertyKey : Symbol(propertyKey, Decl(decoratorOnClassProperty11.ts, 0, 40)) - -class C { ->C : Symbol(C, Decl(decoratorOnClassProperty11.ts, 0, 70)) - - @dec prop; ->dec : Symbol(dec, Decl(decoratorOnClassProperty11.ts, 0, 0)) ->prop : Symbol(prop, Decl(decoratorOnClassProperty11.ts, 2, 9)) -} diff --git a/tests/baselines/reference/decoratorOnClassProperty11.types b/tests/baselines/reference/decoratorOnClassProperty11.types deleted file mode 100644 index 5caa467d3ba..00000000000 --- a/tests/baselines/reference/decoratorOnClassProperty11.types +++ /dev/null @@ -1,14 +0,0 @@ -=== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts === -declare function dec(): (target: any, propertyKey: string) => void; ->dec : () => (target: any, propertyKey: string) => void ->T : T ->target : any ->propertyKey : string - -class C { ->C : C - - @dec prop; ->dec : () => (target: any, propertyKey: string) => void ->prop : any -} diff --git a/tests/baselines/reference/decoratorOnClassProperty6.errors.txt b/tests/baselines/reference/decoratorOnClassProperty6.errors.txt new file mode 100644 index 00000000000..441ff38a421 --- /dev/null +++ b/tests/baselines/reference/decoratorOnClassProperty6.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts(4,5): error TS1220: Invalid expression for property decorator. + Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts (1 errors) ==== + declare function dec(target: Function): void; + + class C { + @dec prop; + ~~~~ +!!! error TS1220: Invalid expression for property decorator. +!!! error TS1220: Supplied parameters do not match any signature of call target. + } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassProperty6.symbols b/tests/baselines/reference/decoratorOnClassProperty6.symbols deleted file mode 100644 index 7b9857e0a19..00000000000 --- a/tests/baselines/reference/decoratorOnClassProperty6.symbols +++ /dev/null @@ -1,13 +0,0 @@ -=== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts === -declare function dec(target: Function): void; ->dec : Symbol(dec, Decl(decoratorOnClassProperty6.ts, 0, 0)) ->target : Symbol(target, Decl(decoratorOnClassProperty6.ts, 0, 21)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) - -class C { ->C : Symbol(C, Decl(decoratorOnClassProperty6.ts, 0, 45)) - - @dec prop; ->dec : Symbol(dec, Decl(decoratorOnClassProperty6.ts, 0, 0)) ->prop : Symbol(prop, Decl(decoratorOnClassProperty6.ts, 2, 9)) -} diff --git a/tests/baselines/reference/decoratorOnClassProperty6.types b/tests/baselines/reference/decoratorOnClassProperty6.types deleted file mode 100644 index 59d03678330..00000000000 --- a/tests/baselines/reference/decoratorOnClassProperty6.types +++ /dev/null @@ -1,13 +0,0 @@ -=== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts === -declare function dec(target: Function): void; ->dec : (target: Function) => void ->target : Function ->Function : Function - -class C { ->C : C - - @dec prop; ->dec : (target: Function) => void ->prop : any -} diff --git a/tests/baselines/reference/decoratorOnClassProperty7.errors.txt b/tests/baselines/reference/decoratorOnClassProperty7.errors.txt index 8b93d0ab38e..e061ce446ac 100644 --- a/tests/baselines/reference/decoratorOnClassProperty7.errors.txt +++ b/tests/baselines/reference/decoratorOnClassProperty7.errors.txt @@ -1,4 +1,5 @@ -tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4,5): error TS2322: Type '(target: Function, propertyKey: string | symbol, paramIndex: number) => void' is not assignable to type '(target: Object, propertyKey: string | symbol) => void'. +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4,5): error TS1220: Invalid expression for property decorator. + Supplied parameters do not match any signature of call target. ==== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts (1 errors) ==== @@ -7,5 +8,6 @@ tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4 class C { @dec prop; ~~~~ -!!! error TS2322: Type '(target: Function, propertyKey: string | symbol, paramIndex: number) => void' is not assignable to type '(target: Object, propertyKey: string | symbol) => void'. +!!! error TS1220: Invalid expression for property decorator. +!!! error TS1220: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/missingDecoratorType.errors.txt b/tests/baselines/reference/missingDecoratorType.errors.txt index 0b159a8fcb2..91b54fde54a 100644 --- a/tests/baselines/reference/missingDecoratorType.errors.txt +++ b/tests/baselines/reference/missingDecoratorType.errors.txt @@ -1,7 +1,17 @@ -error TS2318: Cannot find global type 'ClassDecorator'. +error TS2318: Cannot find global type 'TypedPropertyDescriptor'. -!!! error TS2318: Cannot find global type 'ClassDecorator'. +!!! error TS2318: Cannot find global type 'TypedPropertyDescriptor'. +==== tests/cases/conformance/decorators/b.ts (0 errors) ==== + /// + declare function dec(t, k, d); + + class C { + @dec + method() {} + } + + ==== tests/cases/conformance/decorators/a.ts (0 errors) ==== interface Object { } @@ -12,12 +22,4 @@ error TS2318: Cannot find global type 'ClassDecorator'. interface Function { } interface RegExp { } interface IArguments { } - -==== tests/cases/conformance/decorators/b.ts (0 errors) ==== - declare var dec: any; - - @dec - class C { - } - \ No newline at end of file diff --git a/tests/baselines/reference/missingDecoratorType.js b/tests/baselines/reference/missingDecoratorType.js index 4460abdc798..e65ca7dc341 100644 --- a/tests/baselines/reference/missingDecoratorType.js +++ b/tests/baselines/reference/missingDecoratorType.js @@ -12,10 +12,12 @@ interface RegExp { } interface IArguments { } //// [b.ts] -declare var dec: any; +/// +declare function dec(t, k, d); -@dec class C { + @dec + method() {} } @@ -30,11 +32,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key, case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); } }; +/// var C = (function () { function C() { } - C = __decorate([ - dec - ], C); + C.prototype.method = function () { }; + Object.defineProperty(C.prototype, "method", + __decorate([ + dec + ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); return C; })(); diff --git a/tests/baselines/reference/noEmitHelpers2.js b/tests/baselines/reference/noEmitHelpers2.js index 1bd42377679..66e2ff78b64 100644 --- a/tests/baselines/reference/noEmitHelpers2.js +++ b/tests/baselines/reference/noEmitHelpers2.js @@ -1,6 +1,6 @@ //// [noEmitHelpers2.ts] -function decorator() { } +declare var decorator: any; @decorator class A { @@ -9,7 +9,6 @@ class A { } //// [noEmitHelpers2.js] -function decorator() { } var A = (function () { function A(a, b) { } diff --git a/tests/baselines/reference/noEmitHelpers2.symbols b/tests/baselines/reference/noEmitHelpers2.symbols index 3a3e3ec94c7..044026a3db7 100644 --- a/tests/baselines/reference/noEmitHelpers2.symbols +++ b/tests/baselines/reference/noEmitHelpers2.symbols @@ -1,17 +1,17 @@ === tests/cases/compiler/noEmitHelpers2.ts === -function decorator() { } ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 0)) +declare var decorator: any; +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) @decorator ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 0)) +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) class A { ->A : Symbol(A, Decl(noEmitHelpers2.ts, 1, 24)) +>A : Symbol(A, Decl(noEmitHelpers2.ts, 1, 27)) constructor(a: number, @decorator b: string) { >a : Symbol(a, Decl(noEmitHelpers2.ts, 5, 16)) ->decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 0, 0)) +>decorator : Symbol(decorator, Decl(noEmitHelpers2.ts, 1, 11)) >b : Symbol(b, Decl(noEmitHelpers2.ts, 5, 26)) } } diff --git a/tests/baselines/reference/noEmitHelpers2.types b/tests/baselines/reference/noEmitHelpers2.types index 2a5b5413a7e..14260e4f95c 100644 --- a/tests/baselines/reference/noEmitHelpers2.types +++ b/tests/baselines/reference/noEmitHelpers2.types @@ -1,17 +1,17 @@ === tests/cases/compiler/noEmitHelpers2.ts === -function decorator() { } ->decorator : () => void +declare var decorator: any; +>decorator : any @decorator ->decorator : () => void +>decorator : any class A { >A : A constructor(a: number, @decorator b: string) { >a : number ->decorator : () => void +>decorator : any >b : string } } diff --git a/tests/baselines/reference/sourceMapValidationDecorators.js b/tests/baselines/reference/sourceMapValidationDecorators.js index f858aeff586..5196d3b0dd8 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.js +++ b/tests/baselines/reference/sourceMapValidationDecorators.js @@ -3,8 +3,8 @@ declare function ClassDecorator1(target: Function): void; declare function ClassDecorator2(x: number): (target: Function) => void; declare function PropertyDecorator1(target: Object, key: string | symbol, descriptor?: PropertyDescriptor): void; declare function PropertyDecorator2(x: number): (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void; -declare function ParameterDecorator1(target: Function, key: string | symbol, paramIndex: number): void; -declare function ParameterDecorator2(x: number): (target: Function, key: string | symbol, paramIndex: number) => void; +declare function ParameterDecorator1(target: Object, key: string | symbol, paramIndex: number): void; +declare function ParameterDecorator2(x: number): (target: Object, key: string | symbol, paramIndex: number) => void; @ClassDecorator1 @ClassDecorator2(10) diff --git a/tests/baselines/reference/sourceMapValidationDecorators.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDecorators.sourcemap.txt index 68ad353db9f..b7036723a85 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDecorators.sourcemap.txt @@ -26,8 +26,8 @@ sourceFile:sourceMapValidationDecorators.ts >declare function ClassDecorator2(x: number): (target: Function) => void; >declare function PropertyDecorator1(target: Object, key: string | symbol, descriptor?: PropertyDescriptor): void; >declare function PropertyDecorator2(x: number): (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void; - >declare function ParameterDecorator1(target: Function, key: string | symbol, paramIndex: number): void; - >declare function ParameterDecorator2(x: number): (target: Function, key: string | symbol, paramIndex: number) => void; + >declare function ParameterDecorator1(target: Object, key: string | symbol, paramIndex: number): void; + >declare function ParameterDecorator2(x: number): (target: Object, key: string | symbol, paramIndex: number) => void; > > 1 >Emitted(12, 1) Source(8, 1) + SourceIndex(0) diff --git a/tests/baselines/reference/sourceMapValidationDecorators.symbols b/tests/baselines/reference/sourceMapValidationDecorators.symbols index 37db95d3e05..e22afb7b7fc 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.symbols +++ b/tests/baselines/reference/sourceMapValidationDecorators.symbols @@ -27,20 +27,20 @@ declare function PropertyDecorator2(x: number): (target: Object, key: string | s >descriptor : Symbol(descriptor, Decl(sourceMapValidationDecorators.ts, 3, 86)) >PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66)) -declare function ParameterDecorator1(target: Function, key: string | symbol, paramIndex: number): void; +declare function ParameterDecorator1(target: Object, key: string | symbol, paramIndex: number): void; >ParameterDecorator1 : Symbol(ParameterDecorator1, Decl(sourceMapValidationDecorators.ts, 3, 128)) >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 4, 37)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) ->key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 4, 54)) ->paramIndex : Symbol(paramIndex, Decl(sourceMapValidationDecorators.ts, 4, 76)) +>Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 4, 52)) +>paramIndex : Symbol(paramIndex, Decl(sourceMapValidationDecorators.ts, 4, 74)) -declare function ParameterDecorator2(x: number): (target: Function, key: string | symbol, paramIndex: number) => void; ->ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 103)) +declare function ParameterDecorator2(x: number): (target: Object, key: string | symbol, paramIndex: number) => void; +>ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 101)) >x : Symbol(x, Decl(sourceMapValidationDecorators.ts, 5, 37)) >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 5, 50)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) ->key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 5, 67)) ->paramIndex : Symbol(paramIndex, Decl(sourceMapValidationDecorators.ts, 5, 89)) +>Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 5, 65)) +>paramIndex : Symbol(paramIndex, Decl(sourceMapValidationDecorators.ts, 5, 87)) @ClassDecorator1 >ClassDecorator1 : Symbol(ClassDecorator1, Decl(sourceMapValidationDecorators.ts, 0, 0)) @@ -49,14 +49,14 @@ declare function ParameterDecorator2(x: number): (target: Function, key: string >ClassDecorator2 : Symbol(ClassDecorator2, Decl(sourceMapValidationDecorators.ts, 0, 57)) class Greeter { ->Greeter : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 118)) +>Greeter : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 116)) constructor( @ParameterDecorator1 >ParameterDecorator1 : Symbol(ParameterDecorator1, Decl(sourceMapValidationDecorators.ts, 3, 128)) @ParameterDecorator2(20) ->ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 103)) +>ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 101)) public greeting: string, >greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) @@ -65,7 +65,7 @@ class Greeter { >ParameterDecorator1 : Symbol(ParameterDecorator1, Decl(sourceMapValidationDecorators.ts, 3, 128)) @ParameterDecorator2(30) ->ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 103)) +>ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 101)) ...b: string[]) { >b : Symbol(b, Decl(sourceMapValidationDecorators.ts, 13, 30)) @@ -82,7 +82,7 @@ class Greeter { return "

" + this.greeting + "

"; >this.greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) ->this : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 118)) +>this : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 116)) >greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) } @@ -111,14 +111,14 @@ class Greeter { >ParameterDecorator1 : Symbol(ParameterDecorator1, Decl(sourceMapValidationDecorators.ts, 3, 128)) @ParameterDecorator2(70) ->ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 103)) +>ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 101)) x: number) { >x : Symbol(x, Decl(sourceMapValidationDecorators.ts, 34, 15)) return this.greeting; >this.greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) ->this : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 118)) +>this : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 116)) >greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) } @@ -133,7 +133,7 @@ class Greeter { return this.greeting; >this.greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) ->this : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 118)) +>this : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 116)) >greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) } @@ -144,14 +144,14 @@ class Greeter { >ParameterDecorator1 : Symbol(ParameterDecorator1, Decl(sourceMapValidationDecorators.ts, 3, 128)) @ParameterDecorator2(90) ->ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 103)) +>ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 101)) greetings: string) { >greetings : Symbol(greetings, Decl(sourceMapValidationDecorators.ts, 47, 18)) this.greeting = greetings; >this.greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) ->this : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 118)) +>this : Symbol(Greeter, Decl(sourceMapValidationDecorators.ts, 5, 116)) >greeting : Symbol(greeting, Decl(sourceMapValidationDecorators.ts, 10, 16)) >greetings : Symbol(greetings, Decl(sourceMapValidationDecorators.ts, 47, 18)) } diff --git a/tests/baselines/reference/sourceMapValidationDecorators.types b/tests/baselines/reference/sourceMapValidationDecorators.types index 182f68570bc..9e83bb03509 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.types +++ b/tests/baselines/reference/sourceMapValidationDecorators.types @@ -27,18 +27,18 @@ declare function PropertyDecorator2(x: number): (target: Object, key: string | s >descriptor : PropertyDescriptor >PropertyDescriptor : PropertyDescriptor -declare function ParameterDecorator1(target: Function, key: string | symbol, paramIndex: number): void; ->ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void ->target : Function ->Function : Function +declare function ParameterDecorator1(target: Object, key: string | symbol, paramIndex: number): void; +>ParameterDecorator1 : (target: Object, key: string | symbol, paramIndex: number) => void +>target : Object +>Object : Object >key : string | symbol >paramIndex : number -declare function ParameterDecorator2(x: number): (target: Function, key: string | symbol, paramIndex: number) => void; ->ParameterDecorator2 : (x: number) => (target: Function, key: string | symbol, paramIndex: number) => void +declare function ParameterDecorator2(x: number): (target: Object, key: string | symbol, paramIndex: number) => void; +>ParameterDecorator2 : (x: number) => (target: Object, key: string | symbol, paramIndex: number) => void >x : number ->target : Function ->Function : Function +>target : Object +>Object : Object >key : string | symbol >paramIndex : number @@ -55,22 +55,22 @@ class Greeter { constructor( @ParameterDecorator1 ->ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void +>ParameterDecorator1 : (target: Object, key: string | symbol, paramIndex: number) => void @ParameterDecorator2(20) ->ParameterDecorator2(20) : (target: Function, key: string | symbol, paramIndex: number) => void ->ParameterDecorator2 : (x: number) => (target: Function, key: string | symbol, paramIndex: number) => void +>ParameterDecorator2(20) : (target: Object, key: string | symbol, paramIndex: number) => void +>ParameterDecorator2 : (x: number) => (target: Object, key: string | symbol, paramIndex: number) => void >20 : number public greeting: string, >greeting : string @ParameterDecorator1 ->ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void +>ParameterDecorator1 : (target: Object, key: string | symbol, paramIndex: number) => void @ParameterDecorator2(30) ->ParameterDecorator2(30) : (target: Function, key: string | symbol, paramIndex: number) => void ->ParameterDecorator2 : (x: number) => (target: Function, key: string | symbol, paramIndex: number) => void +>ParameterDecorator2(30) : (target: Object, key: string | symbol, paramIndex: number) => void +>ParameterDecorator2 : (x: number) => (target: Object, key: string | symbol, paramIndex: number) => void >30 : number ...b: string[]) { @@ -125,11 +125,11 @@ class Greeter { >fn : (x: number) => string @ParameterDecorator1 ->ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void +>ParameterDecorator1 : (target: Object, key: string | symbol, paramIndex: number) => void @ParameterDecorator2(70) ->ParameterDecorator2(70) : (target: Function, key: string | symbol, paramIndex: number) => void ->ParameterDecorator2 : (x: number) => (target: Function, key: string | symbol, paramIndex: number) => void +>ParameterDecorator2(70) : (target: Object, key: string | symbol, paramIndex: number) => void +>ParameterDecorator2 : (x: number) => (target: Object, key: string | symbol, paramIndex: number) => void >70 : number x: number) { @@ -162,11 +162,11 @@ class Greeter { >greetings : string @ParameterDecorator1 ->ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void +>ParameterDecorator1 : (target: Object, key: string | symbol, paramIndex: number) => void @ParameterDecorator2(90) ->ParameterDecorator2(90) : (target: Function, key: string | symbol, paramIndex: number) => void ->ParameterDecorator2 : (x: number) => (target: Function, key: string | symbol, paramIndex: number) => void +>ParameterDecorator2(90) : (target: Object, key: string | symbol, paramIndex: number) => void +>ParameterDecorator2 : (x: number) => (target: Object, key: string | symbol, paramIndex: number) => void >90 : number greetings: string) { diff --git a/tests/cases/compiler/noEmitHelpers2.ts b/tests/cases/compiler/noEmitHelpers2.ts index df71f4fae82..c794261c65f 100644 --- a/tests/cases/compiler/noEmitHelpers2.ts +++ b/tests/cases/compiler/noEmitHelpers2.ts @@ -2,7 +2,7 @@ // @emitdecoratormetadata: true // @target: es5 -function decorator() { } +declare var decorator: any; @decorator class A { diff --git a/tests/cases/compiler/sourceMapValidationDecorators.ts b/tests/cases/compiler/sourceMapValidationDecorators.ts index c8bd16be80f..f755700197a 100644 --- a/tests/cases/compiler/sourceMapValidationDecorators.ts +++ b/tests/cases/compiler/sourceMapValidationDecorators.ts @@ -4,8 +4,8 @@ declare function ClassDecorator1(target: Function): void; declare function ClassDecorator2(x: number): (target: Function) => void; declare function PropertyDecorator1(target: Object, key: string | symbol, descriptor?: PropertyDescriptor): void; declare function PropertyDecorator2(x: number): (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void; -declare function ParameterDecorator1(target: Function, key: string | symbol, paramIndex: number): void; -declare function ParameterDecorator2(x: number): (target: Function, key: string | symbol, paramIndex: number) => void; +declare function ParameterDecorator1(target: Object, key: string | symbol, paramIndex: number): void; +declare function ParameterDecorator2(x: number): (target: Object, key: string | symbol, paramIndex: number) => void; @ClassDecorator1 @ClassDecorator2(10) diff --git a/tests/cases/conformance/decorators/class/decoratedClassFromExternalModule.ts b/tests/cases/conformance/decorators/class/decoratedClassFromExternalModule.ts index cb622265b44..979bb28965a 100644 --- a/tests/cases/conformance/decorators/class/decoratedClassFromExternalModule.ts +++ b/tests/cases/conformance/decorators/class/decoratedClassFromExternalModule.ts @@ -1,6 +1,6 @@ // @target: es6 // @Filename: decorated.ts -function decorate() { } +function decorate(target: any) { } @decorate export default class Decorated { } diff --git a/tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts b/tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts index 31f5fe82551..8a9cb6a7ecf 100644 --- a/tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts +++ b/tests/cases/conformance/decorators/class/decoratorChecksFunctionBodies.ts @@ -5,7 +5,7 @@ function func(s: string): void { } class A { - @(x => { + @((x, p) => { var a = 3; func(a); return x; diff --git a/tests/cases/conformance/decorators/class/decoratorInstantiateModulesInFunctionBodies.ts b/tests/cases/conformance/decorators/class/decoratorInstantiateModulesInFunctionBodies.ts index 7fa7ab8dd84..ce153d2fef0 100644 --- a/tests/cases/conformance/decorators/class/decoratorInstantiateModulesInFunctionBodies.ts +++ b/tests/cases/conformance/decorators/class/decoratorInstantiateModulesInFunctionBodies.ts @@ -9,7 +9,7 @@ export var test = 'abc'; import { test } from './a'; function filter(handler: any) { - return function (target: any) { + return function (target: any, propertyKey: string) { // ... }; } diff --git a/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts index df0b847e99d..f506af5d841 100644 --- a/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts +++ b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts @@ -1,5 +1,5 @@ // @target: ES6 -declare function dec(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor; +declare function dec(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor): TypedPropertyDescriptor; class C { @dec ["1"]() { } diff --git a/tests/cases/conformance/decorators/class/method/parameter/decoratorOnClassMethodParameter1.ts b/tests/cases/conformance/decorators/class/method/parameter/decoratorOnClassMethodParameter1.ts index e525933fb6a..fa9c85c6f8e 100644 --- a/tests/cases/conformance/decorators/class/method/parameter/decoratorOnClassMethodParameter1.ts +++ b/tests/cases/conformance/decorators/class/method/parameter/decoratorOnClassMethodParameter1.ts @@ -1,5 +1,5 @@ // @target:es5 -declare function dec(target: Function, propertyKey: string | symbol, parameterIndex: number): void; +declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; class C { method(@dec p: number) {} diff --git a/tests/cases/conformance/decorators/missingDecoratorType.ts b/tests/cases/conformance/decorators/missingDecoratorType.ts index 1407e00b7a3..286595d450e 100644 --- a/tests/cases/conformance/decorators/missingDecoratorType.ts +++ b/tests/cases/conformance/decorators/missingDecoratorType.ts @@ -1,4 +1,4 @@ -// @target: ES5 +// @target: ES5 // @noLib: true // @Filename: a.ts @@ -11,11 +11,12 @@ interface Function { } interface RegExp { } interface IArguments { } -// @Filename: b.ts +// @Filename: b.ts /// -declare var dec: any; +declare function dec(t, k, d); -@dec class C { + @dec + method() {} } From 666a0db6ae646e2f0eba192055ad6c70269dac13 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 22 May 2015 23:56:41 -0700 Subject: [PATCH 028/309] PR Feedback --- src/compiler/checker.ts | 279 ++++++++++-------- .../diagnosticInformationMap.generated.ts | 2 +- src/compiler/diagnosticMessages.json | 2 +- src/compiler/utilities.ts | 7 +- .../reference/decoratorOnClass8.errors.txt | 4 +- .../decoratorOnClassMethod10.errors.txt | 4 +- .../decoratorOnClassMethod6.errors.txt | 4 +- .../decoratorOnClassMethod8.errors.txt | 4 +- .../decoratorOnClassProperty11.errors.txt | 4 +- .../decoratorOnClassProperty6.errors.txt | 4 +- .../decoratorOnClassProperty7.errors.txt | 4 +- 11 files changed, 174 insertions(+), 144 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e99dd7eeb4e..6cd98c43529 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6774,13 +6774,29 @@ module ts { let arg = args[i]; if (arg.kind !== SyntaxKind.OmittedExpression) { let paramType = getTypeAtPosition(signature, i); - let argType = getSyntheticArgumentType(i, arg); + let argType: Type; + if (arg.parent.kind === SyntaxKind.Decorator) { + if (i === 0) { + argType = getDecoratorTargetArgumentType(arg.parent.parent); + } + else if (i === 1) { + argType = getDecoratorPropertyKeyArgumentType(arg.parent.parent); + } + else if (i === 2) { + argType = getDecoratorPropertyIndexOrDescriptorArgumentType(arg.parent.parent); + } + } + else if (i === 0 && arg.parent.kind === SyntaxKind.TaggedTemplateExpression) { + argType = globalTemplateStringsArrayType; + } + if (argType === undefined) { // For context sensitive arguments we pass the identityMapper, which is a signal to treat all // context sensitive function expressions as wildcards let mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; argType = checkExpressionWithContextualType(arg, paramType, mapper); } + inferTypes(context, argType, paramType); } } @@ -6838,140 +6854,151 @@ module ts { : emptyObjectType; } - /** - * Gets the type for a synthetic argument when resolving the first argument for a TaggedTemplateExpression - * or any arguments to a Decorator. - */ - function getSyntheticArgumentType(argumentIndex: number, arg: Expression): Type { - if (arg.parent.kind === SyntaxKind.Decorator) { - let decorator = arg.parent; - let parent = decorator.parent; - if (argumentIndex === 0) { - // The first argument to a decorator is its `target`. - switch (parent.kind) { - case SyntaxKind.ClassDeclaration: - // For a class decorator, the `target` is the type of the class (e.g. the - // "static" or "constructor" side of the class) - let classSymbol = getSymbolOfNode(parent); - return getTypeOfSymbol(classSymbol); - - case SyntaxKind.Parameter: - // For a parameter decorator, the `target` is the parent type of the - // parameter's containing method. - parent = parent.parent; - if (parent.kind === SyntaxKind.Constructor) { - let classSymbol = getSymbolOfNode(parent); - return getTypeOfSymbol(classSymbol); - } - - // fall-through - - case SyntaxKind.PropertyDeclaration: - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - // For a property or method decorator, the `target` is the - // "static"-side type of the parent of the member if the member is - // declared "static"; otherwise, it is the "instance"-side type of the - // parent of the member. - return getTypeOfParentOfClassElement(parent); + function getDecoratorTargetArgumentType(target: Node): Type { + // The first argument to a decorator is its `target`. + switch (target.kind) { + case SyntaxKind.ClassDeclaration: + // For a class decorator, the `target` is the type of the class (e.g. the + // "static" or "constructor" side of the class) + let classSymbol = getSymbolOfNode(target); + return getTypeOfSymbol(classSymbol); + + case SyntaxKind.Parameter: + // For a parameter decorator, the `target` is the parent type of the + // parameter's containing method. + target = target.parent; + if (target.kind === SyntaxKind.Constructor) { + let classSymbol = getSymbolOfNode(target); + return getTypeOfSymbol(classSymbol); } - } - else if (argumentIndex === 1) { - // The second argument to a decorator is its `propertyKey` - switch (parent.kind) { - case SyntaxKind.ClassDeclaration: - Debug.fail("Class decorators should not have a second synthetic argument."); - - case SyntaxKind.Parameter: - parent = parent.parent; - if (parent.kind === SyntaxKind.Constructor) { - // For a constructor parameter decorator, the `propertyKey` will be `undefined`. - return anyType; - } - - // For a non-constructor parameter decorator, the `propertyKey` will be either - // a string or a symbol, based on the name of the parameter's containing method. - - // fall-through - - case SyntaxKind.PropertyDeclaration: - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - // The `propertyKey` for a property or method decorator will be a - // string literal type if the member name is an identifier, number, or string; - // otherwise, if the member name is a computed property name it will - // be either string or symbol. - let element = decorator.parent; - switch (element.name.kind) { - case SyntaxKind.Identifier: - case SyntaxKind.NumericLiteral: - case SyntaxKind.StringLiteral: - return getStringLiteralType(element.name); - - case SyntaxKind.ComputedPropertyName: - let nameType = checkComputedPropertyName(element.name); - if (allConstituentTypesHaveKind(nameType, TypeFlags.ESSymbol)) { - return nameType; - } - else { - return stringType; - } - } - } - } - else if (argumentIndex === 2) { - // The third argument to a decorator is either its `descriptor` for a method decorator - // or its `parameterIndex` for a paramter decorator - switch (parent.kind) { - case SyntaxKind.ClassDeclaration: - Debug.fail("Class decorators should not have a third synthetic argument."); - break; - - case SyntaxKind.Parameter: - // The `parameterIndex` for a parameter decorator is always a number - return numberType; - - case SyntaxKind.PropertyDeclaration: - Debug.fail("Property decorators should not have a third synthetic argument."); - break; - - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor` - // for the type of the member. - let propertyType: Type = getTypeOfNode(parent); - return createTypedPropertyDescriptorType(propertyType); - } - } + + // fall-through + + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // For a property or method decorator, the `target` is the + // "static"-side type of the parent of the member if the member is + // declared "static"; otherwise, it is the "instance"-side type of the + // parent of the member. + return getTypeOfParentOfClassElement(target); + + default: + return undefined; } - else if (argumentIndex === 0 && arg.parent.kind === SyntaxKind.TaggedTemplateExpression) { - return globalTemplateStringsArrayType; - } - - return undefined; } + + function getDecoratorPropertyKeyArgumentType(target: Node) { + // The second argument to a decorator is its `propertyKey` + switch (target.kind) { + case SyntaxKind.ClassDeclaration: + Debug.fail("Class decorators should not have a second synthetic argument."); + + case SyntaxKind.Parameter: + target = target.parent; + if (target.kind === SyntaxKind.Constructor) { + // For a constructor parameter decorator, the `propertyKey` will be `undefined`. + return anyType; + } + + // For a non-constructor parameter decorator, the `propertyKey` will be either + // a string or a symbol, based on the name of the parameter's containing method. + + // fall-through + + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // The `propertyKey` for a property or method decorator will be a + // string literal type if the member name is an identifier, number, or string; + // otherwise, if the member name is a computed property name it will + // be either string or symbol. + let element = target; + switch (element.name.kind) { + case SyntaxKind.Identifier: + case SyntaxKind.NumericLiteral: + case SyntaxKind.StringLiteral: + return getStringLiteralType(element.name); + + case SyntaxKind.ComputedPropertyName: + let nameType = checkComputedPropertyName(element.name); + if (allConstituentTypesHaveKind(nameType, TypeFlags.ESSymbol)) { + return nameType; + } + else { + return stringType; + } + } + } + } + + function getDecoratorPropertyIndexOrDescriptorArgumentType(parent: Node) { + // The third argument to a decorator is either its `descriptor` for a method decorator + // or its `parameterIndex` for a paramter decorator + switch (parent.kind) { + case SyntaxKind.ClassDeclaration: + Debug.fail("Class decorators should not have a third synthetic argument."); + break; + case SyntaxKind.Parameter: + // The `parameterIndex` for a parameter decorator is always a number + return numberType; + + case SyntaxKind.PropertyDeclaration: + Debug.fail("Property decorators should not have a third synthetic argument."); + break; + + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor` + // for the type of the member. + let propertyType: Type = getTypeOfNode(parent); + return createTypedPropertyDescriptorType(propertyType); + } + } + function checkApplicableSignature(node: CallLikeExpression, args: Expression[], signature: Signature, relation: Map, excludeArgument: boolean[], reportErrors: boolean, containingMessageChain?: DiagnosticMessageChain) { for (let i = 0; i < args.length; i++) { let arg = args[i]; if (arg.kind !== SyntaxKind.OmittedExpression) { // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) let paramType = getTypeAtPosition(signature, i); - // A tagged template expression provides a special first argument, and string literals get string literal types + + // Decorators provide special arguments, a tagged template expression provides + // a special first argument, and string literals get string literal types // unless we're reporting errors - let argType = getSyntheticArgumentType(i, arg); + let argType: Type; + if (arg.parent.kind === SyntaxKind.Decorator) { + if (i === 0) { + argType = getDecoratorTargetArgumentType(arg.parent.parent); + } + else if (i === 1) { + argType = getDecoratorPropertyKeyArgumentType(arg.parent.parent); + } + else if (i === 2) { + argType = getDecoratorPropertyIndexOrDescriptorArgumentType(arg.parent.parent); + } + } + else if (i === 0 && arg.parent.kind === SyntaxKind.TaggedTemplateExpression) { + argType = globalTemplateStringsArrayType; + } + if (argType === undefined) { - argType = arg.kind === SyntaxKind.StringLiteral && !reportErrors - ? getStringLiteralType(arg) - : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + if (arg.kind === SyntaxKind.StringLiteral && !reportErrors) { + argType = getStringLiteralType(arg); + } + else { + argType = checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + } } // Use argument expression as error location when reporting errors - if (!checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, - Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1, containingMessageChain)) { + let errorNode = reportErrors ? arg : undefined; + let headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; + if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage, containingMessageChain)) { return false; } } @@ -6986,7 +7013,8 @@ module ts { * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution * expressions, where the first element of the list is the template for error reporting purposes. * If 'node' is a Decorator, a new argument list is constructed with the decorator - * expression as a placeholder. + * expression as a placeholder to help when choosing an applicable signature and + * for error reporting purposes. */ function getEffectiveCallArguments(node: CallLikeExpression): Expression[] { let args: Expression[]; @@ -7082,6 +7110,9 @@ module ts { // // For a tagged template, then the first argument be 'undefined' if necessary // because it represents a TemplateStringsArray. + // + // For a decorator, no arguments are susceptible to contextual typing due to the fact + // decorators are applied to a declaration by the emitter, and not to an expression. let excludeArgument: boolean[]; if (!isDecorator) { for (let i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { @@ -7441,7 +7472,9 @@ module ts { break; } - let diagnosticChainHead = chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Invalid_expression_for_0_decorator, decoratorKind); + let diagnosticChainHead = chainDiagnosticMessages( + /*details*/ undefined, + Diagnostics.Unable_to_resolve_signature_of_0_decorator_when_called_as_an_expression, decoratorKind); if (!callSignatures.length) { let errorInfo = chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); errorInfo = concatenateDiagnosticMessageChains(diagnosticChainHead, errorInfo); @@ -9140,7 +9173,7 @@ module ts { diagnosticChainHead = chainDiagnosticMessages( diagnosticChainHead, - Diagnostics.Invalid_expression_for_0_decorator, + Diagnostics.Unable_to_resolve_signature_of_0_decorator_when_called_as_an_expression, decoratorKind); checkTypeAssignableTo(returnType, expectedReturnType, node, /*headMessage*/ undefined, diagnosticChainHead); diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 1eaf69d8886..a1b776611f7 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -175,7 +175,7 @@ module ts { Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, The_return_type_of_a_0_decorator_function_must_be_either_void_or_any: { code: 1219, category: DiagnosticCategory.Error, key: "The return type of a {0} decorator function must be either 'void' or 'any'." }, - Invalid_expression_for_0_decorator: { code: 1220, category: DiagnosticCategory.Error, key: "Invalid expression for {0} decorator." }, + Unable_to_resolve_signature_of_0_decorator_when_called_as_an_expression: { code: 1220, category: DiagnosticCategory.Error, key: "Unable to resolve signature of {0} decorator when called as an expression." }, 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." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 36f7505fc65..27238db5d95 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -687,7 +687,7 @@ "category": "Error", "code": 1219 }, - "Invalid expression for {0} decorator.": { + "Unable to resolve signature of {0} decorator when called as an expression.": { "category": "Error", "code": 1220 }, diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index e720c7a112e..f1239b87629 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -620,12 +620,9 @@ module ts { if (node.kind === SyntaxKind.TaggedTemplateExpression) { return (node).tag; } - else if (node.kind === SyntaxKind.Decorator) { - return (node).expression; - } - // Will either be a CallExpression or NewExpression. - return (node).expression; + // Will either be a CallExpression, NewExpression, or Decorator. + return (node).expression; } export function nodeCanBeDecorated(node: Node): boolean { diff --git a/tests/baselines/reference/decoratorOnClass8.errors.txt b/tests/baselines/reference/decoratorOnClass8.errors.txt index 31abd9e2300..b5e27b4b3cb 100644 --- a/tests/baselines/reference/decoratorOnClass8.errors.txt +++ b/tests/baselines/reference/decoratorOnClass8.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS1220: Invalid expression for class decorator. +tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS1220: Unable to resolve signature of class decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -7,7 +7,7 @@ tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS1220 @dec() ~~~~~~ -!!! error TS1220: Invalid expression for class decorator. +!!! error TS1220: Unable to resolve signature of class decorator when called as an expression. !!! error TS1220: Supplied parameters do not match any signature of call target. class C { } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod10.errors.txt b/tests/baselines/reference/decoratorOnClassMethod10.errors.txt index bfc56717e6c..1d94f08f2a2 100644 --- a/tests/baselines/reference/decoratorOnClassMethod10.errors.txt +++ b/tests/baselines/reference/decoratorOnClassMethod10.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,6): error TS1220: Invalid expression for method decorator. +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,6): error TS1220: Unable to resolve signature of method decorator when called as an expression. Argument of type 'C' is not assignable to parameter of type 'Function'. Property 'apply' is missing in type 'C'. @@ -9,7 +9,7 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,6) class C { @dec method() {} ~~~ -!!! error TS1220: Invalid expression for method decorator. +!!! error TS1220: Unable to resolve signature of method decorator when called as an expression. !!! error TS1220: Argument of type 'C' is not assignable to parameter of type 'Function'. !!! error TS1220: Property 'apply' is missing in type 'C'. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod6.errors.txt b/tests/baselines/reference/decoratorOnClassMethod6.errors.txt index ade416aefbc..2231d0da56d 100644 --- a/tests/baselines/reference/decoratorOnClassMethod6.errors.txt +++ b/tests/baselines/reference/decoratorOnClassMethod6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): error TS1220: Invalid expression for method decorator. +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): error TS1220: Unable to resolve signature of method decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): class C { @dec ["method"]() {} ~~~~ -!!! error TS1220: Invalid expression for method decorator. +!!! error TS1220: Unable to resolve signature of method decorator when called as an expression. !!! error TS1220: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod8.errors.txt b/tests/baselines/reference/decoratorOnClassMethod8.errors.txt index d0635b4f5f3..d80fe7e05f7 100644 --- a/tests/baselines/reference/decoratorOnClassMethod8.errors.txt +++ b/tests/baselines/reference/decoratorOnClassMethod8.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts(4,5): error TS1220: Invalid expression for method decorator. +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts(4,5): error TS1220: Unable to resolve signature of method decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts(4,5): class C { @dec method() {} ~~~~ -!!! error TS1220: Invalid expression for method decorator. +!!! error TS1220: Unable to resolve signature of method decorator when called as an expression. !!! error TS1220: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassProperty11.errors.txt b/tests/baselines/reference/decoratorOnClassProperty11.errors.txt index 92b89b0b430..8dad5dc955f 100644 --- a/tests/baselines/reference/decoratorOnClassProperty11.errors.txt +++ b/tests/baselines/reference/decoratorOnClassProperty11.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts(4,5): error TS1220: Invalid expression for property decorator. +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts(4,5): error TS1220: Unable to resolve signature of property decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts( class C { @dec prop; ~~~~ -!!! error TS1220: Invalid expression for property decorator. +!!! error TS1220: Unable to resolve signature of property decorator when called as an expression. !!! error TS1220: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassProperty6.errors.txt b/tests/baselines/reference/decoratorOnClassProperty6.errors.txt index 441ff38a421..eca97e803e0 100644 --- a/tests/baselines/reference/decoratorOnClassProperty6.errors.txt +++ b/tests/baselines/reference/decoratorOnClassProperty6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts(4,5): error TS1220: Invalid expression for property decorator. +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts(4,5): error TS1220: Unable to resolve signature of property decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts(4 class C { @dec prop; ~~~~ -!!! error TS1220: Invalid expression for property decorator. +!!! error TS1220: Unable to resolve signature of property decorator when called as an expression. !!! error TS1220: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassProperty7.errors.txt b/tests/baselines/reference/decoratorOnClassProperty7.errors.txt index e061ce446ac..7f2249e5934 100644 --- a/tests/baselines/reference/decoratorOnClassProperty7.errors.txt +++ b/tests/baselines/reference/decoratorOnClassProperty7.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4,5): error TS1220: Invalid expression for property decorator. +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4,5): error TS1220: Unable to resolve signature of property decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4 class C { @dec prop; ~~~~ -!!! error TS1220: Invalid expression for property decorator. +!!! error TS1220: Unable to resolve signature of property decorator when called as an expression. !!! error TS1220: Supplied parameters do not match any signature of call target. } \ No newline at end of file From e20be958122788560753e67dda48792f7bca6fc6 Mon Sep 17 00:00:00 2001 From: SaschaNaz Date: Sat, 23 May 2015 17:47:13 +0900 Subject: [PATCH 029/309] fixing some types --- src/services/formatting/smartIndenter.ts | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index a02dc4454fa..712c8a2f93f 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -295,9 +295,11 @@ module ts.formatting { } function getLineIndentationWhenExpressionIsInMultiLine(node: Node, sourceFile: SourceFile, options: EditorOptions): number { - if (node.parent.kind === SyntaxKind.CallExpression) { - let parentExpression = (node.parent).expression; - let startingExpression = getStartingExpression(parentExpression); + if (node.parent.kind === SyntaxKind.CallExpression || + node.parent.kind === SyntaxKind.NewExpression) { + + let parentExpression = (node.parent).expression; + let startingExpression = getStartingExpression(parentExpression); if (parentExpression === startingExpression) { return Value.Unknown; @@ -314,9 +316,9 @@ module ts.formatting { } return Value.Unknown; - function getStartingExpression(expression: CallExpression) { + function getStartingExpression(expression: PropertyAccessExpression | CallExpression | ElementAccessExpression) { while (expression.expression) - expression = expression.expression; + expression = expression.expression; return expression; } } From 50a02237d1fc2deb2001214843ab01f0b9cae61c Mon Sep 17 00:00:00 2001 From: SaschaNaz Date: Sun, 24 May 2015 14:38:17 +0900 Subject: [PATCH 030/309] getLineIndentation for others --- src/services/formatting/smartIndenter.ts | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 712c8a2f93f..4bd7fd66411 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -66,6 +66,10 @@ module ts.formatting { if (actualIndentation !== Value.Unknown) { return actualIndentation; } + actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options); + if (actualIndentation !== Value.Unknown) { + return actualIndentation + options.IndentSize; + } previous = current; current = current.parent; @@ -122,6 +126,10 @@ module ts.formatting { if (actualIndentation !== Value.Unknown) { return actualIndentation + indentationDelta; } + actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options); + if (actualIndentation !== Value.Unknown) { + return actualIndentation + indentationDelta; + } } // increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line @@ -279,14 +287,7 @@ module ts.formatting { function getActualIndentationForListItem(node: Node, sourceFile: SourceFile, options: EditorOptions): number { let containingList = getContainingList(node, sourceFile); - - if (containingList) { - let lineIndentation = getLineIndentationWhenExpressionIsInMultiLine(node, sourceFile, options); - if (lineIndentation !== Value.Unknown) - return lineIndentation; - return getActualIndentationFromList(containingList); - } - return Value.Unknown; + return containingList ? getActualIndentationFromList(containingList) : Value.Unknown; function getActualIndentationFromList(list: Node[]): number { let index = indexOf(list, node); @@ -295,8 +296,9 @@ module ts.formatting { } function getLineIndentationWhenExpressionIsInMultiLine(node: Node, sourceFile: SourceFile, options: EditorOptions): number { - if (node.parent.kind === SyntaxKind.CallExpression || - node.parent.kind === SyntaxKind.NewExpression) { + if (node.parent && ( + node.parent.kind === SyntaxKind.CallExpression || + node.parent.kind === SyntaxKind.NewExpression)) { let parentExpression = (node.parent).expression; let startingExpression = getStartingExpression(parentExpression); From f559d061eceefe539c117f544dba254c7a98731e Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 27 May 2015 10:19:37 -0700 Subject: [PATCH 031/309] PR feedback and minor refactoring --- src/compiler/checker.ts | 714 ++++++++++-------- .../diagnosticInformationMap.generated.ts | 8 +- src/compiler/diagnosticMessages.json | 21 +- .../reference/decoratorOnClass8.errors.txt | 6 +- .../decoratorOnClassMethod10.errors.txt | 10 +- .../decoratorOnClassMethod6.errors.txt | 6 +- .../decoratorOnClassMethod8.errors.txt | 6 +- .../decoratorOnClassProperty11.errors.txt | 6 +- .../decoratorOnClassProperty6.errors.txt | 6 +- .../decoratorOnClassProperty7.errors.txt | 6 +- 10 files changed, 455 insertions(+), 334 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6cd98c43529..57e1f8190f0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3504,6 +3504,16 @@ module ts { return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); } + /** + * Creates a TypeReference for a generic `TypedPropertyDescriptor`. + */ + function createTypedPropertyDescriptorType(propertyType: Type): Type { + let globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); + return globalTypedPropertyDescriptorType !== emptyObjectType + ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) + : emptyObjectType; + } + function createIterableType(elementType: Type): Type { return globalIterableType !== emptyObjectType ? createTypeReference(globalIterableType, [elementType]) : emptyObjectType; } @@ -6605,7 +6615,8 @@ module ts { function getSpreadArgumentIndex(args: Expression[]): number { for (let i = 0; i < args.length; i++) { - if (args[i].kind === SyntaxKind.SpreadElementExpression) { + let arg = args[i]; + if (arg && arg.kind === SyntaxKind.SpreadElementExpression) { return i; } } @@ -6616,7 +6627,8 @@ module ts { let adjustedArgCount: number; // Apparent number of arguments we will have in this call let typeArguments: NodeArray; // Type arguments (undefined if none) let callIsIncomplete: boolean; // In incomplete call we want to be lenient when we have too few arguments - + let isDecorator: boolean; + if (node.kind === SyntaxKind.TaggedTemplateExpression) { let tagExpression = node; @@ -6643,39 +6655,9 @@ module ts { } } else if (node.kind === SyntaxKind.Decorator) { - let decorator = node; - switch (decorator.parent.kind) { - case SyntaxKind.ClassDeclaration: - case SyntaxKind.ClassExpression: - // A class decorator will have one argument (see `ClassDecorator` in core.d.ts) - adjustedArgCount = 1; - typeArguments = undefined; - break; - - case SyntaxKind.PropertyDeclaration: - // A property declaration decorator will have two arguments (see - // `PropertyDecorator` in core.d.ts) - adjustedArgCount = 2; - typeArguments = undefined; - break; - - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - // A method or accessor declaration decorator will have two or three arguments (see - // `MethodDecorator` in core.d.ts) - adjustedArgCount = signature.parameters.length >= 3 ? 3 : 2; - typeArguments = undefined; - break; - - case SyntaxKind.Parameter: - // A parameter declaration decorator will have three arguments (see - // `ParameterDecorator` in core.d.ts) - - adjustedArgCount = 3; - typeArguments = undefined; - break; - } + isDecorator = true; + typeArguments = undefined; + adjustedArgCount = getEffectiveArgumentCount(node, /*args*/ undefined, signature); } else { let callExpression = node; @@ -6705,7 +6687,7 @@ module ts { // If spread arguments are present, check that they correspond to a rest parameter. If so, no // further checking is necessary. - let spreadArgIndex = getSpreadArgumentIndex(args); + let spreadArgIndex = !isDecorator ? getSpreadArgumentIndex(args) : -1; if (spreadArgIndex >= 0) { return signature.hasRestParameter && spreadArgIndex >= signature.parameters.length - 1; } @@ -6742,7 +6724,7 @@ module ts { return getSignatureInstantiation(signature, getInferredTypes(context)); } - function inferTypeArguments(signature: Signature, args: Expression[], excludeArgument: boolean[], context: InferenceContext): void { + function inferTypeArguments(node: CallLikeExpression, signature: Signature, args: Expression[], excludeArgument: boolean[], context: InferenceContext): void { let typeParameters = signature.typeParameters; let inferenceMapper = createInferenceMapper(context); @@ -6770,33 +6752,12 @@ module ts { // We perform two passes over the arguments. In the first pass we infer from all arguments, but use // wildcards for all context sensitive function expressions. - for (let i = 0; i < args.length; i++) { - let arg = args[i]; - if (arg.kind !== SyntaxKind.OmittedExpression) { + let argCount = getEffectiveArgumentCount(node, args, signature); + for (let i = 0; i < argCount; i++) { + let arg = getEffectiveArgument(node, args, i); + if (!arg || arg.kind !== SyntaxKind.OmittedExpression) { let paramType = getTypeAtPosition(signature, i); - let argType: Type; - if (arg.parent.kind === SyntaxKind.Decorator) { - if (i === 0) { - argType = getDecoratorTargetArgumentType(arg.parent.parent); - } - else if (i === 1) { - argType = getDecoratorPropertyKeyArgumentType(arg.parent.parent); - } - else if (i === 2) { - argType = getDecoratorPropertyIndexOrDescriptorArgumentType(arg.parent.parent); - } - } - else if (i === 0 && arg.parent.kind === SyntaxKind.TaggedTemplateExpression) { - argType = globalTemplateStringsArrayType; - } - - if (argType === undefined) { - // For context sensitive arguments we pass the identityMapper, which is a signal to treat all - // context sensitive function expressions as wildcards - let mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; - argType = checkExpressionWithContextualType(arg, paramType, mapper); - } - + let argType = getEffectiveArgumentType(node, i, arg, paramType, excludeArgument, inferenceMapper, /*reportErrors*/ false); inferTypes(context, argType, paramType); } } @@ -6804,8 +6765,10 @@ module ts { // In the second pass we visit only context sensitive arguments, and only those that aren't excluded, this // time treating function expressions normally (which may cause previously inferred type arguments to be fixed // as we construct types for contextually typed parameters) + // Decorators will not have `excludeArgument`, as their arguments cannot be contextually typed. + // Tagged template expressions will always have `undefined` for `excludeArgument[0]`. if (excludeArgument) { - for (let i = 0; i < args.length; i++) { + for (let i = 0; i < argCount; i++) { // No need to check for omitted args and template expressions, their exlusion value is always undefined if (excludeArgument[i] === false) { let arg = args[i]; @@ -6818,7 +6781,7 @@ module ts { getInferredTypes(context); } - function checkTypeArguments(signature: Signature, typeArguments: TypeNode[], typeArgumentResultTypes: Type[], reportErrors: boolean, containingMessageChain?: DiagnosticMessageChain): boolean { + function checkTypeArguments(signature: Signature, typeArguments: TypeNode[], typeArgumentResultTypes: Type[], reportErrors: boolean, headMessage?: DiagnosticMessage): boolean { let typeParameters = signature.typeParameters; let typeArgumentsAreAssignable = true; for (let i = 0; i < typeParameters.length; i++) { @@ -6829,180 +6792,44 @@ module ts { if (typeArgumentsAreAssignable /* so far */) { let constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { - typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, - Diagnostics.Type_0_does_not_satisfy_the_constraint_1, containingMessageChain); + let errorInfo: DiagnosticMessageChain; + let typeArgumentHeadMessage = Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (reportErrors && headMessage) { + errorInfo = chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); + typeArgumentHeadMessage = headMessage; + } + + typeArgumentsAreAssignable = checkTypeAssignableTo( + typeArgument, + constraint, + reportErrors ? typeArgNode : undefined, + typeArgumentHeadMessage, + errorInfo); } } } + return typeArgumentsAreAssignable; } - - function getTypeOfParentOfClassElement(node: ClassElement) { - let classSymbol = getSymbolOfNode(node.parent); - if (node.flags & NodeFlags.Static) { - return getTypeOfSymbol(classSymbol); - } - else { - return getDeclaredTypeOfSymbol(classSymbol); - } - } - - function createTypedPropertyDescriptorType(propertyType: Type): Type { - let globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); - return globalTypedPropertyDescriptorType !== emptyObjectType - ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) - : emptyObjectType; - } - - function getDecoratorTargetArgumentType(target: Node): Type { - // The first argument to a decorator is its `target`. - switch (target.kind) { - case SyntaxKind.ClassDeclaration: - // For a class decorator, the `target` is the type of the class (e.g. the - // "static" or "constructor" side of the class) - let classSymbol = getSymbolOfNode(target); - return getTypeOfSymbol(classSymbol); - - case SyntaxKind.Parameter: - // For a parameter decorator, the `target` is the parent type of the - // parameter's containing method. - target = target.parent; - if (target.kind === SyntaxKind.Constructor) { - let classSymbol = getSymbolOfNode(target); - return getTypeOfSymbol(classSymbol); - } - - // fall-through - - case SyntaxKind.PropertyDeclaration: - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - // For a property or method decorator, the `target` is the - // "static"-side type of the parent of the member if the member is - // declared "static"; otherwise, it is the "instance"-side type of the - // parent of the member. - return getTypeOfParentOfClassElement(target); - - default: - return undefined; - } - } - - function getDecoratorPropertyKeyArgumentType(target: Node) { - // The second argument to a decorator is its `propertyKey` - switch (target.kind) { - case SyntaxKind.ClassDeclaration: - Debug.fail("Class decorators should not have a second synthetic argument."); - - case SyntaxKind.Parameter: - target = target.parent; - if (target.kind === SyntaxKind.Constructor) { - // For a constructor parameter decorator, the `propertyKey` will be `undefined`. - return anyType; - } - - // For a non-constructor parameter decorator, the `propertyKey` will be either - // a string or a symbol, based on the name of the parameter's containing method. - - // fall-through - - case SyntaxKind.PropertyDeclaration: - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - // The `propertyKey` for a property or method decorator will be a - // string literal type if the member name is an identifier, number, or string; - // otherwise, if the member name is a computed property name it will - // be either string or symbol. - let element = target; - switch (element.name.kind) { - case SyntaxKind.Identifier: - case SyntaxKind.NumericLiteral: - case SyntaxKind.StringLiteral: - return getStringLiteralType(element.name); - - case SyntaxKind.ComputedPropertyName: - let nameType = checkComputedPropertyName(element.name); - if (allConstituentTypesHaveKind(nameType, TypeFlags.ESSymbol)) { - return nameType; - } - else { - return stringType; - } - } - } - } - - function getDecoratorPropertyIndexOrDescriptorArgumentType(parent: Node) { - // The third argument to a decorator is either its `descriptor` for a method decorator - // or its `parameterIndex` for a paramter decorator - switch (parent.kind) { - case SyntaxKind.ClassDeclaration: - Debug.fail("Class decorators should not have a third synthetic argument."); - break; - case SyntaxKind.Parameter: - // The `parameterIndex` for a parameter decorator is always a number - return numberType; - - case SyntaxKind.PropertyDeclaration: - Debug.fail("Property decorators should not have a third synthetic argument."); - break; - - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor` - // for the type of the member. - let propertyType: Type = getTypeOfNode(parent); - return createTypedPropertyDescriptorType(propertyType); - } - } - - function checkApplicableSignature(node: CallLikeExpression, args: Expression[], signature: Signature, relation: Map, excludeArgument: boolean[], reportErrors: boolean, containingMessageChain?: DiagnosticMessageChain) { - for (let i = 0; i < args.length; i++) { - let arg = args[i]; - if (arg.kind !== SyntaxKind.OmittedExpression) { + function checkApplicableSignature(node: CallLikeExpression, args: Expression[], signature: Signature, relation: Map, excludeArgument: boolean[], reportErrors: boolean) { + let argCount = getEffectiveArgumentCount(node, args, signature); + for (let i = 0; i < argCount; i++) { + let arg = getEffectiveArgument(node, args, i); + if (!arg || arg.kind !== SyntaxKind.OmittedExpression) { // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) let paramType = getTypeAtPosition(signature, i); - - // Decorators provide special arguments, a tagged template expression provides - // a special first argument, and string literals get string literal types - // unless we're reporting errors - let argType: Type; - if (arg.parent.kind === SyntaxKind.Decorator) { - if (i === 0) { - argType = getDecoratorTargetArgumentType(arg.parent.parent); - } - else if (i === 1) { - argType = getDecoratorPropertyKeyArgumentType(arg.parent.parent); - } - else if (i === 2) { - argType = getDecoratorPropertyIndexOrDescriptorArgumentType(arg.parent.parent); - } - } - else if (i === 0 && arg.parent.kind === SyntaxKind.TaggedTemplateExpression) { - argType = globalTemplateStringsArrayType; - } - - if (argType === undefined) { - if (arg.kind === SyntaxKind.StringLiteral && !reportErrors) { - argType = getStringLiteralType(arg); - } - else { - argType = checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); - } - } + let argType = getEffectiveArgumentType(node, i, arg, paramType, excludeArgument, /*inferenceMapper*/ undefined, reportErrors); // Use argument expression as error location when reporting errors - let errorNode = reportErrors ? arg : undefined; + let errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; let headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; - if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage, containingMessageChain)) { + if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) { return false; } } } + return true; } @@ -7011,17 +6838,15 @@ module ts { * * If 'node' is a CallExpression or a NewExpression, then its argument list is returned. * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution - * expressions, where the first element of the list is the template for error reporting purposes. - * If 'node' is a Decorator, a new argument list is constructed with the decorator - * expression as a placeholder to help when choosing an applicable signature and - * for error reporting purposes. + * expressions, where the first element of the list is `undefined`. + * If 'node' is a Decorator, the argument list will be `undefined`, and its arguments and types + * will be supplied from calls to `getEffectiveArgumentCount` and `getEffectiveArgumentType`. */ function getEffectiveCallArguments(node: CallLikeExpression): Expression[] { let args: Expression[]; if (node.kind === SyntaxKind.TaggedTemplateExpression) { let template = (node).template; - args = [template]; - + args = [undefined]; if (template.kind === SyntaxKind.TemplateExpression) { forEach((template).templateSpans, span => { args.push(span.expression); @@ -7029,21 +6854,10 @@ module ts { } } else if (node.kind === SyntaxKind.Decorator) { - let decorator = node; - switch (decorator.parent.kind) { - case SyntaxKind.ClassDeclaration: - args = [decorator.expression]; - break; - case SyntaxKind.PropertyDeclaration: - args = [decorator.expression, decorator.expression]; - break; - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - case SyntaxKind.Parameter: - args = [decorator.expression, decorator.expression, decorator.expression]; - break; - } + // For a decorator, we return undefined as we will determine + // the number and types of arguments for a decorator using + // `getEffectiveArgumentCount` and `getEffectiveArgumentType` below. + return undefined; } else { args = (node).arguments || emptyArray; @@ -7074,7 +6888,287 @@ module ts { } } - function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[], containingMessageChain?: DiagnosticMessageChain): Signature { + /** + * Returns the effective argument count for a node that works like a function invocation. + * If 'node' is a Decorator, the number of arguments is derived from the decoration + * target and the signature: + * If 'node.target' is a class declaration or class expression, the effective argument + * count is 1. + * If 'node.target' is a parameter declaration, the effective argument count is 3. + * If 'node.target' is a property declaration, the effective argument count is 2. + * If 'node.target' is a method or accessor declaration, the effective argument count + * is 3, although it can be 2 if the signature only accepts two arguments, allowing + * us to match a property decorator. + * Otherwise, the argument count is the length of the 'args' array. + */ + function getEffectiveArgumentCount(node: CallLikeExpression, args: Expression[], signature: Signature) { + if (node.kind === SyntaxKind.Decorator) { + switch (node.parent.kind) { + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + // A class decorator will have one argument (see `ClassDecorator` in core.d.ts) + return 1; + + case SyntaxKind.PropertyDeclaration: + // A property declaration decorator will have two arguments (see + // `PropertyDecorator` in core.d.ts) + return 2; + + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // A method or accessor declaration decorator will have two or three arguments (see + // `PropertyDecorator` and `MethodDecorator` in core.d.ts) + // If the method decorator signature only accepts a target and a key, we will only + // type check those arguments. + return signature.parameters.length >= 3 ? 3 : 2; + + case SyntaxKind.Parameter: + // A parameter declaration decorator will have three arguments (see + // `ParameterDecorator` in core.d.ts) + + return 3; + } + } + else { + return args.length; + } + } + + /** + * Returns the effective type of the first argument to a decorator. + * If 'node' is a class declaration or class expression, the effective argument type + * is the type of the static side of the class. + * If 'node' is a parameter declaration, the effective argument type is either the type + * of the static or instance side of the class for the parameter's parent method, + * depending on whether the method is declared static. + * For a constructor, the type is always the type of the static side of the class. + * If 'node' is a property, method, or accessor declaration, the effective argument + * type is the type of the static or instance side of the parent class for class + * element, depending on whether the element is declared static. + */ + function getEffectiveDecoratorFirstArgumentType(node: Node): Type { + // The first argument to a decorator is its `target`. + switch (node.kind) { + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + // For a class decorator, the `target` is the type of the class (e.g. the + // "static" or "constructor" side of the class) + let classSymbol = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol); + + case SyntaxKind.Parameter: + // For a parameter decorator, the `target` is the parent type of the + // parameter's containing method. + node = node.parent; + if (node.kind === SyntaxKind.Constructor) { + let classSymbol = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol); + } + + // fall-through + + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // For a property or method decorator, the `target` is the + // "static"-side type of the parent of the member if the member is + // declared "static"; otherwise, it is the "instance"-side type of the + // parent of the member. + return getParentTypeOfClassElement(node); + + default: + Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + + /** + * Returns the effective type for the second argument to a decorator. + * If 'node' is a parameter, its effective argument type is one of the following: + * If 'node.parent' is a constructor, the effective argument type is 'any', as we + * will emit `undefined`. + * If 'node.parent' is a member with an identifier, numeric, or string literal name, + * the effective argument type will be a string literal type for the member name. + * If 'node.parent' is a computed property name, the effective argument type will + * either be a symbol type or the string type. + * If 'node' is a member with an identifier, numeric, or string literal name, the + * effective argument type will be a string literal type for the member name. + * If 'node' is a computed property name, the effective argument type will either + * be a symbol type or the string type. + * A class decorator does not have a second argument type. + */ + function getEffectiveDecoratorSecondArgumentType(node: Node) { + // The second argument to a decorator is its `propertyKey` + switch (node.kind) { + case SyntaxKind.ClassDeclaration: + Debug.fail("Class decorators should not have a second synthetic argument."); + return unknownType; + + case SyntaxKind.Parameter: + node = node.parent; + if (node.kind === SyntaxKind.Constructor) { + // For a constructor parameter decorator, the `propertyKey` will be `undefined`. + return anyType; + } + + // For a non-constructor parameter decorator, the `propertyKey` will be either + // a string or a symbol, based on the name of the parameter's containing method. + + // fall-through + + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // The `propertyKey` for a property or method decorator will be a + // string literal type if the member name is an identifier, number, or string; + // otherwise, if the member name is a computed property name it will + // be either string or symbol. + let element = node; + switch (element.name.kind) { + case SyntaxKind.Identifier: + case SyntaxKind.NumericLiteral: + case SyntaxKind.StringLiteral: + return getStringLiteralType(element.name); + + case SyntaxKind.ComputedPropertyName: + let nameType = checkComputedPropertyName(element.name); + if (allConstituentTypesHaveKind(nameType, TypeFlags.ESSymbol)) { + return nameType; + } + else { + return stringType; + } + + default: + Debug.fail("Unsupported property name."); + return unknownType; + } + + + default: + Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + + /** + * Returns the effective argument type for the third argument to a decorator. + * If 'node' is a parameter, the effective argument type is the number type. + * If 'node' is a method or accessor, the effective argument type is a + * `TypedPropertyDescriptor` instantiated with the type of the member. + * Class and property decorators do not have a third effective argument. + */ + function getEffectiveDecoratorThirdArgumentType(node: Node) { + // The third argument to a decorator is either its `descriptor` for a method decorator + // or its `parameterIndex` for a paramter decorator + switch (node.kind) { + case SyntaxKind.ClassDeclaration: + Debug.fail("Class decorators should not have a third synthetic argument."); + return unknownType; + + case SyntaxKind.Parameter: + // The `parameterIndex` for a parameter decorator is always a number + return numberType; + + case SyntaxKind.PropertyDeclaration: + Debug.fail("Property decorators should not have a third synthetic argument."); + return unknownType; + + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor` + // for the type of the member. + let propertyType = getTypeOfNode(node); + return createTypedPropertyDescriptorType(propertyType); + + default: + Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + + /** + * Returns the effective argument type for the provided argument to a decorator. + */ + function getEffectiveDecoratorArgumentType(node: Decorator, argIndex: number): Type { + if (argIndex === 0) { + return getEffectiveDecoratorFirstArgumentType(node.parent); + } + else if (argIndex === 1) { + return getEffectiveDecoratorSecondArgumentType(node.parent); + } + else if (argIndex === 2) { + return getEffectiveDecoratorThirdArgumentType(node.parent); + } + + Debug.fail("Decorators should not have a fourth synthetic argument."); + return unknownType; + } + + /** + * Gets the effective argument type for an argument in a call expression. + */ + function getEffectiveArgumentType(node: CallLikeExpression, argIndex: number, arg: Expression, paramType: Type, excludeArgument: boolean[], inferenceMapper: TypeMapper, reportErrors: boolean): Type { + // Decorators provide special arguments, a tagged template expression provides + // a special first argument, and string literals get string literal types + // unless we're reporting errors + if (node.kind === SyntaxKind.Decorator) { + return getEffectiveDecoratorArgumentType(node, argIndex); + } + else if (argIndex === 0 && node.kind === SyntaxKind.TaggedTemplateExpression) { + return globalTemplateStringsArrayType; + } + else if (!inferenceMapper && !reportErrors && arg.kind === SyntaxKind.StringLiteral) { + return getStringLiteralType(arg); + } + else { + let mapper: TypeMapper; + if (inferenceMapper) { + mapper = excludeArgument && excludeArgument[argIndex] !== undefined ? identityMapper : inferenceMapper; + } + else { + mapper = excludeArgument && excludeArgument[argIndex] ? identityMapper : undefined; + } + + return checkExpressionWithContextualType(arg, paramType, mapper); + } + } + + /** + * Gets the effective argument expression for an argument in a call expression. + */ + function getEffectiveArgument(node: CallLikeExpression, args: Expression[], argIndex: number) { + // For a decorator or the first argument of a tagged template expression we return undefined. + if (node.kind === SyntaxKind.Decorator || + (argIndex === 0 && node.kind === SyntaxKind.TaggedTemplateExpression)) { + return undefined; + } + + return args[argIndex]; + } + + /** + * Gets the error node to use when reporting errors for an effective argument. + */ + function getEffectiveArgumentErrorNode(node: CallLikeExpression, argIndex: number, arg: Expression) { + if (node.kind === SyntaxKind.Decorator) { + // For a decorator, we use the expression of the decorator for error reporting. + return (node).expression; + } + else if (argIndex === 0 && node.kind === SyntaxKind.TaggedTemplateExpression) { + // For a the first argument of a tagged template expression, we use the template of the tag for error reporting. + return (node).template; + } + else { + return arg; + } + } + + function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[], headMessage?: DiagnosticMessage): Signature { let isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression; let isDecorator = node.kind === SyntaxKind.Decorator; @@ -7115,6 +7209,8 @@ module ts { // decorators are applied to a declaration by the emitter, and not to an expression. let excludeArgument: boolean[]; if (!isDecorator) { + // We do not need to call `getEffectiveArgumentCount` here as it only + // applies when calculating the number of arguments for a decorator. for (let i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { if (isContextSensitive(args[i])) { if (!excludeArgument) { @@ -7185,11 +7281,11 @@ module ts { // in arguments too early. If possible, we'd like to only type them once we know the correct // overload. However, this matters for the case where the call is correct. When the call is // an error, we don't need to exclude any arguments, although it would cause no harm to do so. - checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true, containingMessageChain); + checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true); } else if (candidateForTypeArgumentError) { if (!isTaggedTemplate && !isDecorator && (node).typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, (node).typeArguments, [], /*reportErrors*/ true, containingMessageChain) + checkTypeArguments(candidateForTypeArgumentError, (node).typeArguments, [], /*reportErrors*/ true, headMessage) } else { Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); @@ -7200,8 +7296,8 @@ module ts { Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, typeToString(failedTypeParameter)); - if (containingMessageChain) { - diagnosticChainHead = concatenateDiagnosticMessageChains(containingMessageChain, diagnosticChainHead); + if (headMessage) { + diagnosticChainHead = chainDiagnosticMessages(diagnosticChainHead, headMessage); } reportNoCommonSupertypeError(inferenceCandidates, (node).expression || (node).tag, diagnosticChainHead); @@ -7227,9 +7323,10 @@ module ts { return resolveErrorCall(node); function reportError(message: DiagnosticMessage, arg0?: string, arg1?: string, arg2?: string): void { - let errorInfo = chainDiagnosticMessages(/*details*/ undefined, message, arg0, arg1, arg2); - if (containingMessageChain) { - errorInfo = concatenateDiagnosticMessageChains(containingMessageChain, errorInfo); + let errorInfo: DiagnosticMessageChain; + errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2); + if (headMessage) { + errorInfo = chainDiagnosticMessages(errorInfo, headMessage); } diagnostics.add(createDiagnosticForNodeFromMessageChain(node, errorInfo)); @@ -7256,7 +7353,7 @@ module ts { typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, /*reportErrors*/ false) } else { - inferTypeArguments(candidate, args, excludeArgument, inferenceContext); + inferTypeArguments(node, candidate, args, excludeArgument, inferenceContext); typeArgumentsAreValid = inferenceContext.failedTypeParameterIndex === undefined; typeArgumentTypes = inferenceContext.inferredTypes; } @@ -7433,7 +7530,32 @@ module ts { return resolveCall(node, callSignatures, candidatesOutArray); } + + /** + * Gets the localized diagnostic head message to use for errors when resolving a decorator as a call expression. + */ + function getDiagnosticHeadMessageForDecoratorResolution(node: Decorator) { + switch (node.parent.kind) { + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + return Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; + + case SyntaxKind.Parameter: + return Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; + + case SyntaxKind.PropertyDeclaration: + return Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; + + case SyntaxKind.MethodDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + return Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression; + } + } + /** + * Resolves a decorator as if it were a call expression. + */ function resolveDecorator(node: Decorator, candidatesOutArray: Signature[]): Signature { let funcType = checkExpression(node.expression); let apparentType = getApparentType(funcType); @@ -7446,43 +7568,16 @@ module ts { return resolveUntypedCall(node); } - let decoratorKind: string; - switch (node.parent.kind) { - case SyntaxKind.ClassDeclaration: - case SyntaxKind.ClassExpression: - decoratorKind = "class"; - break; - - case SyntaxKind.Parameter: - decoratorKind = "parameter"; - break; - - case SyntaxKind.PropertyDeclaration: - decoratorKind = "property"; - break; - - case SyntaxKind.MethodDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - decoratorKind = "method"; - break; - - default: - Debug.fail("Invalid decorator target."); - break; - } - - let diagnosticChainHead = chainDiagnosticMessages( - /*details*/ undefined, - Diagnostics.Unable_to_resolve_signature_of_0_decorator_when_called_as_an_expression, decoratorKind); + let headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); if (!callSignatures.length) { - let errorInfo = chainDiagnosticMessages(/*details*/ undefined, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); - errorInfo = concatenateDiagnosticMessageChains(diagnosticChainHead, errorInfo); + let errorInfo: DiagnosticMessageChain; + errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); + errorInfo = chainDiagnosticMessages(errorInfo, headMessage); diagnostics.add(createDiagnosticForNodeFromMessageChain(node, errorInfo)); return resolveErrorCall(node); } - return resolveCall(node, callSignatures, candidatesOutArray, diagnosticChainHead); + return resolveCall(node, callSignatures, candidatesOutArray, headMessage); } // candidatesOutArray is passed by signature help in the language service, and collectCandidates @@ -9134,24 +9229,28 @@ module ts { } let expectedReturnType: Type; - let diagnosticChainHead: DiagnosticMessageChain; - let decoratorKind: string; + let headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + let errorInfo: DiagnosticMessageChain; switch (node.parent.kind) { case SyntaxKind.ClassDeclaration: let classSymbol = getSymbolOfNode(node.parent); let classConstructorType = getTypeOfSymbol(classSymbol); expectedReturnType = getUnionType([classConstructorType, voidType]); - decoratorKind = "class"; break; case SyntaxKind.Parameter: expectedReturnType = voidType; - decoratorKind = "parameter"; - break; + errorInfo = chainDiagnosticMessages( + errorInfo, + Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any); + break; + case SyntaxKind.PropertyDeclaration: expectedReturnType = voidType; - decoratorKind = "property"; + errorInfo = chainDiagnosticMessages( + errorInfo, + Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any); break; case SyntaxKind.MethodDeclaration: @@ -9160,23 +9259,15 @@ module ts { let methodType = getTypeOfNode(node.parent); let descriptorType = createTypedPropertyDescriptorType(methodType); expectedReturnType = getUnionType([descriptorType, voidType]); - decoratorKind = "method"; break; } - if (expectedReturnType === voidType) { - diagnosticChainHead = chainDiagnosticMessages( - diagnosticChainHead, - Diagnostics.The_return_type_of_a_0_decorator_function_must_be_either_void_or_any, - decoratorKind); - } - - diagnosticChainHead = chainDiagnosticMessages( - diagnosticChainHead, - Diagnostics.Unable_to_resolve_signature_of_0_decorator_when_called_as_an_expression, - decoratorKind); - - checkTypeAssignableTo(returnType, expectedReturnType, node, /*headMessage*/ undefined, diagnosticChainHead); + checkTypeAssignableTo( + returnType, + expectedReturnType, + node, + headMessage, + errorInfo); } /** Checks a type reference node as an expression. */ @@ -11815,6 +11906,17 @@ module ts { return checkExpression(expr); } + /** + * Gets either the static or instance type of a class element, based on + * whether the element is declared as "static". + */ + function getParentTypeOfClassElement(node: ClassElement) { + let classSymbol = getSymbolOfNode(node.parent); + return node.flags & NodeFlags.Static + ? getTypeOfSymbol(classSymbol) + : getDeclaredTypeOfSymbol(classSymbol); + } + // Return the list of properties of the given type, augmented with properties from Function // if the type has call or construct signatures function getAugmentedPropertiesOfType(type: Type): Symbol[] { diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index a1b776611f7..1653b673503 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -174,8 +174,12 @@ module ts { Type_expected_0_is_a_reserved_word_in_strict_mode: { code: 1215, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode" }, Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, - The_return_type_of_a_0_decorator_function_must_be_either_void_or_any: { code: 1219, category: DiagnosticCategory.Error, key: "The return type of a {0} decorator function must be either 'void' or 'any'." }, - Unable_to_resolve_signature_of_0_decorator_when_called_as_an_expression: { code: 1220, category: DiagnosticCategory.Error, key: "Unable to resolve signature of {0} decorator when called as an expression." }, + The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: { code: 1219, category: DiagnosticCategory.Error, key: "The return type of a property decorator function must be either 'void' or 'any'." }, + The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: { code: 1220, category: DiagnosticCategory.Error, key: "The return type of a parameter decorator function must be either 'void' or 'any'." }, + Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: { code: 1221, category: DiagnosticCategory.Error, key: "Unable to resolve signature of class decorator when called as an expression." }, + Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: { code: 1222, category: DiagnosticCategory.Error, key: "Unable to resolve signature of parameter decorator when called as an expression." }, + Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: { code: 1223, category: DiagnosticCategory.Error, key: "Unable to resolve signature of property decorator when called as an expression." }, + Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: { code: 1224, category: DiagnosticCategory.Error, key: "Unable to resolve signature of method decorator when called as an expression." }, 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." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 27238db5d95..006e1d6f1a9 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -683,14 +683,31 @@ "category": "Error", "code": 1218 }, - "The return type of a {0} decorator function must be either 'void' or 'any'.": { + "The return type of a property decorator function must be either 'void' or 'any'.": { "category": "Error", "code": 1219 }, - "Unable to resolve signature of {0} decorator when called as an expression.": { + "The return type of a parameter decorator function must be either 'void' or 'any'.": { "category": "Error", "code": 1220 }, + + "Unable to resolve signature of class decorator when called as an expression.": { + "category": "Error", + "code": 1221 + }, + "Unable to resolve signature of parameter decorator when called as an expression.": { + "category": "Error", + "code": 1222 + }, + "Unable to resolve signature of property decorator when called as an expression.": { + "category": "Error", + "code": 1223 + }, + "Unable to resolve signature of method decorator when called as an expression.": { + "category": "Error", + "code": 1224 + }, "Duplicate identifier '{0}'.": { "category": "Error", diff --git a/tests/baselines/reference/decoratorOnClass8.errors.txt b/tests/baselines/reference/decoratorOnClass8.errors.txt index b5e27b4b3cb..adda3c19095 100644 --- a/tests/baselines/reference/decoratorOnClass8.errors.txt +++ b/tests/baselines/reference/decoratorOnClass8.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS1220: Unable to resolve signature of class decorator when called as an expression. +tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS1221: Unable to resolve signature of class decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -7,7 +7,7 @@ tests/cases/conformance/decorators/class/decoratorOnClass8.ts(3,1): error TS1220 @dec() ~~~~~~ -!!! error TS1220: Unable to resolve signature of class decorator when called as an expression. -!!! error TS1220: Supplied parameters do not match any signature of call target. +!!! error TS1221: Unable to resolve signature of class decorator when called as an expression. +!!! error TS1221: Supplied parameters do not match any signature of call target. class C { } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod10.errors.txt b/tests/baselines/reference/decoratorOnClassMethod10.errors.txt index 1d94f08f2a2..6499aa44e53 100644 --- a/tests/baselines/reference/decoratorOnClassMethod10.errors.txt +++ b/tests/baselines/reference/decoratorOnClassMethod10.errors.txt @@ -1,6 +1,5 @@ -tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,6): error TS1220: Unable to resolve signature of method decorator when called as an expression. - Argument of type 'C' is not assignable to parameter of type 'Function'. - Property 'apply' is missing in type 'C'. +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,6): error TS2345: Argument of type 'C' is not assignable to parameter of type 'Function'. + Property 'apply' is missing in type 'C'. ==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts (1 errors) ==== @@ -9,7 +8,6 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod10.ts(4,6) class C { @dec method() {} ~~~ -!!! error TS1220: Unable to resolve signature of method decorator when called as an expression. -!!! error TS1220: Argument of type 'C' is not assignable to parameter of type 'Function'. -!!! error TS1220: Property 'apply' is missing in type 'C'. +!!! error TS2345: Argument of type 'C' is not assignable to parameter of type 'Function'. +!!! error TS2345: Property 'apply' is missing in type 'C'. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod6.errors.txt b/tests/baselines/reference/decoratorOnClassMethod6.errors.txt index 2231d0da56d..206480dd135 100644 --- a/tests/baselines/reference/decoratorOnClassMethod6.errors.txt +++ b/tests/baselines/reference/decoratorOnClassMethod6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): error TS1220: Unable to resolve signature of method decorator when called as an expression. +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): error TS1224: Unable to resolve signature of method decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): class C { @dec ["method"]() {} ~~~~ -!!! error TS1220: Unable to resolve signature of method decorator when called as an expression. -!!! error TS1220: Supplied parameters do not match any signature of call target. +!!! error TS1224: Unable to resolve signature of method decorator when called as an expression. +!!! error TS1224: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassMethod8.errors.txt b/tests/baselines/reference/decoratorOnClassMethod8.errors.txt index d80fe7e05f7..832b8efbb34 100644 --- a/tests/baselines/reference/decoratorOnClassMethod8.errors.txt +++ b/tests/baselines/reference/decoratorOnClassMethod8.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts(4,5): error TS1220: Unable to resolve signature of method decorator when called as an expression. +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts(4,5): error TS1224: Unable to resolve signature of method decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod8.ts(4,5): class C { @dec method() {} ~~~~ -!!! error TS1220: Unable to resolve signature of method decorator when called as an expression. -!!! error TS1220: Supplied parameters do not match any signature of call target. +!!! error TS1224: Unable to resolve signature of method decorator when called as an expression. +!!! error TS1224: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassProperty11.errors.txt b/tests/baselines/reference/decoratorOnClassProperty11.errors.txt index 8dad5dc955f..9b153135639 100644 --- a/tests/baselines/reference/decoratorOnClassProperty11.errors.txt +++ b/tests/baselines/reference/decoratorOnClassProperty11.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts(4,5): error TS1220: Unable to resolve signature of property decorator when called as an expression. +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts(4,5): error TS1223: Unable to resolve signature of property decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts( class C { @dec prop; ~~~~ -!!! error TS1220: Unable to resolve signature of property decorator when called as an expression. -!!! error TS1220: Supplied parameters do not match any signature of call target. +!!! error TS1223: Unable to resolve signature of property decorator when called as an expression. +!!! error TS1223: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassProperty6.errors.txt b/tests/baselines/reference/decoratorOnClassProperty6.errors.txt index eca97e803e0..8fa543a2734 100644 --- a/tests/baselines/reference/decoratorOnClassProperty6.errors.txt +++ b/tests/baselines/reference/decoratorOnClassProperty6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts(4,5): error TS1220: Unable to resolve signature of property decorator when called as an expression. +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts(4,5): error TS1223: Unable to resolve signature of property decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/property/decoratorOnClassProperty6.ts(4 class C { @dec prop; ~~~~ -!!! error TS1220: Unable to resolve signature of property decorator when called as an expression. -!!! error TS1220: Supplied parameters do not match any signature of call target. +!!! error TS1223: Unable to resolve signature of property decorator when called as an expression. +!!! error TS1223: Supplied parameters do not match any signature of call target. } \ No newline at end of file diff --git a/tests/baselines/reference/decoratorOnClassProperty7.errors.txt b/tests/baselines/reference/decoratorOnClassProperty7.errors.txt index 7f2249e5934..a467cfe5a27 100644 --- a/tests/baselines/reference/decoratorOnClassProperty7.errors.txt +++ b/tests/baselines/reference/decoratorOnClassProperty7.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4,5): error TS1220: Unable to resolve signature of property decorator when called as an expression. +tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4,5): error TS1223: Unable to resolve signature of property decorator when called as an expression. Supplied parameters do not match any signature of call target. @@ -8,6 +8,6 @@ tests/cases/conformance/decorators/class/property/decoratorOnClassProperty7.ts(4 class C { @dec prop; ~~~~ -!!! error TS1220: Unable to resolve signature of property decorator when called as an expression. -!!! error TS1220: Supplied parameters do not match any signature of call target. +!!! error TS1223: Unable to resolve signature of property decorator when called as an expression. +!!! error TS1223: Supplied parameters do not match any signature of call target. } \ No newline at end of file From 813d227e370c280f276a3e218402c2f760f896e1 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 27 May 2015 16:31:29 -0700 Subject: [PATCH 032/309] classInterface: changed excludes flags --- src/compiler/types.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index c8d22b26728..87a887da5da 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1339,8 +1339,8 @@ module ts { PropertyExcludes = Value, EnumMemberExcludes = Value, FunctionExcludes = Value & ~(Function | ValueModule), - ClassExcludes = (Value | Type) & ~ValueModule, - InterfaceExcludes = Type & ~Interface, + ClassExcludes = (Value | Type) & ~(ValueModule | Interface), + InterfaceExcludes = Type & ~(Class | Interface), RegularEnumExcludes = (Value | Type) & ~(RegularEnum | ValueModule), // regular enums merge only with regular enums and modules ConstEnumExcludes = (Value | Type) & ~ConstEnum, // const enums merge only with const enums ValueModuleExcludes = Value & ~(Function | Class | RegularEnum | ValueModule), From 87d0af10d00d49d8722e8264dbc0536a7812fb92 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 29 May 2015 11:00:19 -0700 Subject: [PATCH 033/309] Moved call for getSpreadArgumentIndex in hasCorrectArity --- src/compiler/checker.ts | 3 ++- src/compiler/diagnosticMessages.json | 1 - 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 57e1f8190f0..04ff7a1eaa5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6628,6 +6628,7 @@ module ts { let typeArguments: NodeArray; // Type arguments (undefined if none) let callIsIncomplete: boolean; // In incomplete call we want to be lenient when we have too few arguments let isDecorator: boolean; + let spreadArgIndex = -1; if (node.kind === SyntaxKind.TaggedTemplateExpression) { let tagExpression = node; @@ -6675,6 +6676,7 @@ module ts { callIsIncomplete = (callExpression).arguments.end === callExpression.end; typeArguments = callExpression.typeArguments; + spreadArgIndex = getSpreadArgumentIndex(args); } // If the user supplied type arguments, but the number of type arguments does not match @@ -6687,7 +6689,6 @@ module ts { // If spread arguments are present, check that they correspond to a rest parameter. If so, no // further checking is necessary. - let spreadArgIndex = !isDecorator ? getSpreadArgumentIndex(args) : -1; if (spreadArgIndex >= 0) { return signature.hasRestParameter && spreadArgIndex >= signature.parameters.length - 1; } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 006e1d6f1a9..264f2fdb55b 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -691,7 +691,6 @@ "category": "Error", "code": 1220 }, - "Unable to resolve signature of class decorator when called as an expression.": { "category": "Error", "code": 1221 From 18abf470c25cb839829c97fc2c3e5e98ef4a2b18 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 1 Jun 2015 09:17:09 -0700 Subject: [PATCH 034/309] Revert "classInterface: changed excludes flags" This reverts commit 813d227e370c280f276a3e218402c2f760f896e1. --- src/compiler/types.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 87a887da5da..c8d22b26728 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1339,8 +1339,8 @@ module ts { PropertyExcludes = Value, EnumMemberExcludes = Value, FunctionExcludes = Value & ~(Function | ValueModule), - ClassExcludes = (Value | Type) & ~(ValueModule | Interface), - InterfaceExcludes = Type & ~(Class | Interface), + ClassExcludes = (Value | Type) & ~ValueModule, + InterfaceExcludes = Type & ~Interface, RegularEnumExcludes = (Value | Type) & ~(RegularEnum | ValueModule), // regular enums merge only with regular enums and modules ConstEnumExcludes = (Value | Type) & ~ConstEnum, // const enums merge only with const enums ValueModuleExcludes = Value & ~(Function | Class | RegularEnum | ValueModule), From 05500f4577aa7761e46dc5ddcbd3a2e644c4c079 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 1 Jun 2015 14:49:11 -0700 Subject: [PATCH 035/309] Added merged declarations for ambient class/interfaces --- src/compiler/binder.ts | 42 +++++++++++++++++++++++++++++++----------- src/compiler/types.ts | 3 ++- 2 files changed, 33 insertions(+), 12 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index b66497fc40d..15370d5e9db 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -6,8 +6,8 @@ module ts { export const enum ModuleInstanceState { NonInstantiated = 0, - Instantiated = 1, - ConstEnumOnly = 2 + Instantiated = 1, + ConstEnumOnly = 2 } export function getModuleInstanceState(node: Node): ModuleInstanceState { @@ -135,6 +135,26 @@ module ts { return node.name ? declarationNameToString(node.name) : getDeclarationName(node); } + /* internal */ + /** + * Checks if the symbol contains a class declaration declaration that is non-ambient. + */ + function hasNonAmbientClass(symbol: Symbol): boolean { + if (symbol) { + return !! forEach(symbol.declarations, (element: Declaration, index: number) => { + return (element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient)) + }); + } + } + + /** + * Declares a Symbol for the Node and add it to symbols. Reports errors for conflicting identifier names, + * @param symbols - The symbolTable which node will be added to. + * @param parent - If node is in a class, parent denotes the parent declaration. + * @param node - The declaration to be added to the symbol table + * @param includes - The SymbolFlags that node has in addition to its declaration type (eg: export, ambient, etc.) + * @param excludes - The flags which node cannot be declared alongside in a symbol table. Used to report forbidden declarations. + */ function declareSymbol(symbols: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol { Debug.assert(!hasDynamicName(node)); @@ -144,15 +164,15 @@ module ts { let symbol: Symbol; if (name !== undefined) { symbol = hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name)); - if (symbol.flags & excludes) { - if (node.name) { - node.name.parent = node; - } + if (symbol.flags & excludes || (node.kind === SyntaxKind.InterfaceDeclaration && hasNonAmbientClass(symbol)) ) { + if (node.name) { + node.name.parent = node; + } // Report errors every position with duplicate declaration // Report errors on previous encountered declarations let message = symbol.flags & SymbolFlags.BlockScopedVariable - ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 + ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0; forEach(symbol.declarations, declaration => { @@ -249,7 +269,7 @@ module ts { // these cases are: // - node has locals (symbolKind & HasLocals) !== 0 // - node is a source file - setBlockScopeContainer(node, /*cleanLocals*/ (symbolKind & SymbolFlags.HasLocals) === 0 && node.kind !== SyntaxKind.SourceFile); + setBlockScopeContainer(node, /*cleanLocals*/(symbolKind & SymbolFlags.HasLocals) === 0 && node.kind !== SyntaxKind.SourceFile); } forEachChild(node, bind); @@ -403,7 +423,7 @@ module ts { declareModuleMember(node, symbolKind, symbolExcludes); break; } - // fall through. + // fall through. default: if (!blockScopeContainer.locals) { blockScopeContainer.locals = {}; @@ -424,7 +444,7 @@ module ts { function bind(node: Node) { node.parent = parent; - + switch (node.kind) { case SyntaxKind.TypeParameter: bindDeclaration(node, SymbolFlags.TypeParameter, SymbolFlags.TypeParameterExcludes, /*isBlockScopeContainer*/ false); @@ -516,7 +536,7 @@ module ts { bindCatchVariableDeclaration(node); break; case SyntaxKind.ClassDeclaration: - bindBlockScopedDeclaration(node, SymbolFlags.Class, SymbolFlags.ClassExcludes); + bindBlockScopedDeclaration(node, SymbolFlags.Class, isAmbientContext(node) ? SymbolFlags.AmbientClassExcludes : SymbolFlags.ClassExcludes); break; case SyntaxKind.InterfaceDeclaration: bindDeclaration(node, SymbolFlags.Interface, SymbolFlags.InterfaceExcludes, /*isBlockScopeContainer*/ false); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index c8d22b26728..807d8ce7564 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1340,7 +1340,8 @@ module ts { EnumMemberExcludes = Value, FunctionExcludes = Value & ~(Function | ValueModule), ClassExcludes = (Value | Type) & ~ValueModule, - InterfaceExcludes = Type & ~Interface, + AmbientClassExcludes = (Value | Type) & ~(ValueModule | Interface), + InterfaceExcludes = Type & ~(Interface | Class), RegularEnumExcludes = (Value | Type) & ~(RegularEnum | ValueModule), // regular enums merge only with regular enums and modules ConstEnumExcludes = (Value | Type) & ~ConstEnum, // const enums merge only with const enums ValueModuleExcludes = Value & ~(Function | Class | RegularEnum | ValueModule), From 6c98c677146ec32b9c41122daffc6946ef1c599c Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 1 Jun 2015 16:26:41 -0700 Subject: [PATCH 036/309] added conformance tests --- ...lassAndInterfaceMergeConflictingMembers.ts | 23 +++++++++++++++++++ .../declaredClassMergedwithSelf.ts | 9 ++++++++ .../classDeclarations/mergedClassInterface.ts | 11 +++++++++ 3 files changed, 43 insertions(+) create mode 100644 tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts b/tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts new file mode 100644 index 00000000000..d11d67c3fea --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts @@ -0,0 +1,23 @@ +declare class C1 { + public x : number; +} + +interface C1 { + x : number; +} + +declare class C2 { + protected x : number; +} + +interface C2 { + x : number; +} + +declare class C3 { + private x : number; +} + +interface C3 { + x : number; +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts b/tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts new file mode 100644 index 00000000000..4688fec9e26 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts @@ -0,0 +1,9 @@ +declare class C1 {} + +declare class C1 {} + +declare class C2 {} + +interface C2 {} + +declare class C2 {} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts b/tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts new file mode 100644 index 00000000000..4fac95b516a --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts @@ -0,0 +1,11 @@ +declare class C1 {} + +interface C1 {} + +interface C2 {} + +declare class C2 {} + +interface C2 {} + +interface C2 {} \ No newline at end of file From b864df2fd4715ad291ca834583f43bcca385d927 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 1 Jun 2015 16:39:41 -0700 Subject: [PATCH 037/309] New Baselines for class-interface merging --- ...nterfaceMergeConflictingMembers.errors.txt | 44 +++++++++++++++++++ ...lassAndInterfaceMergeConflictingMembers.js | 26 +++++++++++ .../declaredClassMergedwithSelf.errors.txt | 27 ++++++++++++ .../reference/declaredClassMergedwithSelf.js | 12 +++++ .../reference/mergedClassInterface.js | 14 ++++++ .../reference/mergedClassInterface.symbols | 19 ++++++++ .../reference/mergedClassInterface.types | 19 ++++++++ 7 files changed, 161 insertions(+) create mode 100644 tests/baselines/reference/classAndInterfaceMergeConflictingMembers.errors.txt create mode 100644 tests/baselines/reference/classAndInterfaceMergeConflictingMembers.js create mode 100644 tests/baselines/reference/declaredClassMergedwithSelf.errors.txt create mode 100644 tests/baselines/reference/declaredClassMergedwithSelf.js create mode 100644 tests/baselines/reference/mergedClassInterface.js create mode 100644 tests/baselines/reference/mergedClassInterface.symbols create mode 100644 tests/baselines/reference/mergedClassInterface.types diff --git a/tests/baselines/reference/classAndInterfaceMergeConflictingMembers.errors.txt b/tests/baselines/reference/classAndInterfaceMergeConflictingMembers.errors.txt new file mode 100644 index 00000000000..48e52faae1e --- /dev/null +++ b/tests/baselines/reference/classAndInterfaceMergeConflictingMembers.errors.txt @@ -0,0 +1,44 @@ +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(2,12): error TS2300: Duplicate identifier 'x'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(6,5): error TS2300: Duplicate identifier 'x'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(10,15): error TS2300: Duplicate identifier 'x'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(14,5): error TS2300: Duplicate identifier 'x'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(18,13): error TS2300: Duplicate identifier 'x'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(22,5): error TS2300: Duplicate identifier 'x'. + + +==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts (6 errors) ==== + declare class C1 { + public x : number; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + interface C1 { + x : number; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + declare class C2 { + protected x : number; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + interface C2 { + x : number; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + declare class C3 { + private x : number; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + interface C3 { + x : number; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } \ No newline at end of file diff --git a/tests/baselines/reference/classAndInterfaceMergeConflictingMembers.js b/tests/baselines/reference/classAndInterfaceMergeConflictingMembers.js new file mode 100644 index 00000000000..07b425383f4 --- /dev/null +++ b/tests/baselines/reference/classAndInterfaceMergeConflictingMembers.js @@ -0,0 +1,26 @@ +//// [classAndInterfaceMergeConflictingMembers.ts] +declare class C1 { + public x : number; +} + +interface C1 { + x : number; +} + +declare class C2 { + protected x : number; +} + +interface C2 { + x : number; +} + +declare class C3 { + private x : number; +} + +interface C3 { + x : number; +} + +//// [classAndInterfaceMergeConflictingMembers.js] diff --git a/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt b/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt new file mode 100644 index 00000000000..8a783639c1c --- /dev/null +++ b/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt @@ -0,0 +1,27 @@ +tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(1,15): error TS2300: Duplicate identifier 'C1'. +tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(3,15): error TS2300: Duplicate identifier 'C1'. +tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(5,15): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(7,11): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(9,15): error TS2300: Duplicate identifier 'C2'. + + +==== tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts (5 errors) ==== + declare class C1 {} + ~~ +!!! error TS2300: Duplicate identifier 'C1'. + + declare class C1 {} + ~~ +!!! error TS2300: Duplicate identifier 'C1'. + + declare class C2 {} + ~~ +!!! error TS2300: Duplicate identifier 'C2'. + + interface C2 {} + ~~ +!!! error TS2300: Duplicate identifier 'C2'. + + declare class C2 {} + ~~ +!!! error TS2300: Duplicate identifier 'C2'. \ No newline at end of file diff --git a/tests/baselines/reference/declaredClassMergedwithSelf.js b/tests/baselines/reference/declaredClassMergedwithSelf.js new file mode 100644 index 00000000000..85213668adc --- /dev/null +++ b/tests/baselines/reference/declaredClassMergedwithSelf.js @@ -0,0 +1,12 @@ +//// [declaredClassMergedwithSelf.ts] +declare class C1 {} + +declare class C1 {} + +declare class C2 {} + +interface C2 {} + +declare class C2 {} + +//// [declaredClassMergedwithSelf.js] diff --git a/tests/baselines/reference/mergedClassInterface.js b/tests/baselines/reference/mergedClassInterface.js new file mode 100644 index 00000000000..70c8b7d2b2f --- /dev/null +++ b/tests/baselines/reference/mergedClassInterface.js @@ -0,0 +1,14 @@ +//// [mergedClassInterface.ts] +declare class C1 {} + +interface C1 {} + +interface C2 {} + +declare class C2 {} + +interface C2 {} + +interface C2 {} + +//// [mergedClassInterface.js] diff --git a/tests/baselines/reference/mergedClassInterface.symbols b/tests/baselines/reference/mergedClassInterface.symbols new file mode 100644 index 00000000000..dc7ba891551 --- /dev/null +++ b/tests/baselines/reference/mergedClassInterface.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts === +declare class C1 {} +>C1 : Symbol(C1, Decl(mergedClassInterface.ts, 0, 0), Decl(mergedClassInterface.ts, 0, 19)) + +interface C1 {} +>C1 : Symbol(C1, Decl(mergedClassInterface.ts, 0, 0), Decl(mergedClassInterface.ts, 0, 19)) + +interface C2 {} +>C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15)) + +declare class C2 {} +>C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15)) + +interface C2 {} +>C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15)) + +interface C2 {} +>C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15)) + diff --git a/tests/baselines/reference/mergedClassInterface.types b/tests/baselines/reference/mergedClassInterface.types new file mode 100644 index 00000000000..a31f147b734 --- /dev/null +++ b/tests/baselines/reference/mergedClassInterface.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts === +declare class C1 {} +>C1 : C1 + +interface C1 {} +>C1 : C1 + +interface C2 {} +>C2 : C2 + +declare class C2 {} +>C2 : C2 + +interface C2 {} +>C2 : C2 + +interface C2 {} +>C2 : C2 + From ed46bc3b588de7bb53209a9678d60ba64c076c30 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 1 Jun 2015 16:43:43 -0700 Subject: [PATCH 038/309] Fixed intendation typo --- src/compiler/binder.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 32fc5872ef6..6d91d11990c 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -164,10 +164,10 @@ module ts { let symbol: Symbol; if (name !== undefined) { symbol = hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name)); - if (symbol.flags & excludes || (node.kind === SyntaxKind.InterfaceDeclaration && hasNonAmbientClass(symbol)) ) { - if (node.name) { - node.name.parent = node; - } + if (symbol.flags & excludes || (node.kind === SyntaxKind.InterfaceDeclaration && hasNonAmbientClass(symbol))) { + if (node.name) { + node.name.parent = node; + } // Report errors every position with duplicate declaration // Report errors on previous encountered declarations @@ -269,7 +269,7 @@ module ts { // these cases are: // - node has locals (symbolKind & HasLocals) !== 0 // - node is a source file - setBlockScopeContainer(node, /*cleanLocals*/(symbolKind & SymbolFlags.HasLocals) === 0 && node.kind !== SyntaxKind.SourceFile); + setBlockScopeContainer(node, /*cleanLocals*/ (symbolKind & SymbolFlags.HasLocals) === 0 && node.kind !== SyntaxKind.SourceFile); } forEachChild(node, bind); From d25b91032f96ba5a0a4d92f6a7bcca84b2c598b7 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 1 Jun 2015 16:45:11 -0700 Subject: [PATCH 039/309] fixed indentation --- src/compiler/binder.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 6d91d11990c..7c38b2ecb90 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -6,8 +6,8 @@ module ts { export const enum ModuleInstanceState { NonInstantiated = 0, - Instantiated = 1, - ConstEnumOnly = 2 + Instantiated = 1, + ConstEnumOnly = 2 } export function getModuleInstanceState(node: Node): ModuleInstanceState { From 910079a60e88686b34acc4df0f2db4c79af9ac2e Mon Sep 17 00:00:00 2001 From: SaschaNaz Date: Tue, 2 Jun 2015 15:28:29 +0900 Subject: [PATCH 040/309] exclude closeparen/propertyaccess tokens --- src/services/formatting/smartIndenter.ts | 7 ++++++- ...nsistenceOnIndentionsOfChainedFunctionCalls.ts | 2 +- .../fourslash/formattingOnChainedCallbacks.ts | 15 ++++++++++++++- 3 files changed, 21 insertions(+), 3 deletions(-) diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 4bd7fd66411..f904cfe744d 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -296,7 +296,12 @@ module ts.formatting { } function getLineIndentationWhenExpressionIsInMultiLine(node: Node, sourceFile: SourceFile, options: EditorOptions): number { - if (node.parent && ( + // actual indentation should not be used when: + // - node is close parenthesis - this is the end of the expression + // - node is property access expression + if (node.kind !== SyntaxKind.CloseParenToken && + node.kind !== SyntaxKind.PropertyAccessExpression && + node.parent && ( node.parent.kind === SyntaxKind.CallExpression || node.parent.kind === SyntaxKind.NewExpression)) { diff --git a/tests/cases/fourslash/consistenceOnIndentionsOfChainedFunctionCalls.ts b/tests/cases/fourslash/consistenceOnIndentionsOfChainedFunctionCalls.ts index ec2ae9b3c22..3692974f5fb 100644 --- a/tests/cases/fourslash/consistenceOnIndentionsOfChainedFunctionCalls.ts +++ b/tests/cases/fourslash/consistenceOnIndentionsOfChainedFunctionCalls.ts @@ -18,4 +18,4 @@ goTo.marker("1"); edit.insert("\r\n"); goTo.marker("0"); // Won't-fixed: Smart indent during chained function calls -verify.indentationIs(4); \ No newline at end of file +verify.indentationIs(8); \ No newline at end of file diff --git a/tests/cases/fourslash/formattingOnChainedCallbacks.ts b/tests/cases/fourslash/formattingOnChainedCallbacks.ts index 98f91de56fb..b8dbc55d8b6 100644 --- a/tests/cases/fourslash/formattingOnChainedCallbacks.ts +++ b/tests/cases/fourslash/formattingOnChainedCallbacks.ts @@ -13,6 +13,14 @@ //// })/*b*/ ////} +////Promise +//// .then( +//// /*n1*/ +//// ) +//// /*n2*/ +//// .then(); + + goTo.marker('1'); edit.insertLine(''); goTo.marker('2'); @@ -36,4 +44,9 @@ edit.insert(';'); verify.currentLineContentIs(' "";'); goTo.marker('b'); edit.insert(';'); -verify.currentLineContentIs(' });'); \ No newline at end of file +verify.currentLineContentIs(' });'); + +goTo.marker('n1'); +verify.indentationIs(8); +goTo.marker('n2'); +verify.indentationIs(4); \ No newline at end of file From 1f74b134f1ece1276a00f03836853ac3e3fe67c4 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 09:30:28 -0700 Subject: [PATCH 041/309] fixed style, added comment --- src/compiler/binder.ts | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 7c38b2ecb90..975f890927e 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -135,14 +135,13 @@ module ts { return node.name ? declarationNameToString(node.name) : getDeclarationName(node); } - /* internal */ /** - * Checks if the symbol contains a class declaration declaration that is non-ambient. + * Checks if the symbol contains a class declaration that is non-ambient. */ function hasNonAmbientClass(symbol: Symbol): boolean { if (symbol) { - return !! forEach(symbol.declarations, (element: Declaration, index: number) => { - return (element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient)) + return forEach(symbol.declarations, (element: Declaration) => { + return element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient); }); } } @@ -164,6 +163,9 @@ module ts { let symbol: Symbol; if (name !== undefined) { symbol = hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name)); + + // Check for declarations node cannot be merged with. + // Interfaces declarations cannot be merged with non-ambient class declarations, which isn't encoded in SymbolFlags. if (symbol.flags & excludes || (node.kind === SyntaxKind.InterfaceDeclaration && hasNonAmbientClass(symbol))) { if (node.name) { node.name.parent = node; @@ -423,7 +425,7 @@ module ts { declareModuleMember(node, symbolKind, symbolExcludes); break; } - // fall through. + // fall through. default: if (!blockScopeContainer.locals) { blockScopeContainer.locals = {}; From 2d77cbdc06d7b0ef9a3e653ce0bae86a6b38a79e Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 10:49:22 -0700 Subject: [PATCH 042/309] cleaner hasNonAmbientClass --- src/compiler/binder.ts | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 975f890927e..30514c84e40 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -139,11 +139,9 @@ module ts { * Checks if the symbol contains a class declaration that is non-ambient. */ function hasNonAmbientClass(symbol: Symbol): boolean { - if (symbol) { - return forEach(symbol.declarations, (element: Declaration) => { - return element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient); - }); - } + return symbol && forEach(symbol.declarations, (element: Declaration) => { + return element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient); + }); } /** From edc4611341680ea6cb7a446c73defccc83e87132 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 11:27:40 -0700 Subject: [PATCH 043/309] removed comma --- src/compiler/binder.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 30514c84e40..b417892d354 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -145,7 +145,7 @@ module ts { } /** - * Declares a Symbol for the Node and add it to symbols. Reports errors for conflicting identifier names, + * Declares a Symbol for the Node and add it to symbols. Reports errors for conflicting identifier names. * @param symbols - The symbolTable which node will be added to. * @param parent - If node is in a class, parent denotes the parent declaration. * @param node - The declaration to be added to the symbol table @@ -162,7 +162,7 @@ module ts { if (name !== undefined) { symbol = hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name)); - // Check for declarations node cannot be merged with. + // Check for declarations 'node' cannot be merged with. // Interfaces declarations cannot be merged with non-ambient class declarations, which isn't encoded in SymbolFlags. if (symbol.flags & excludes || (node.kind === SyntaxKind.InterfaceDeclaration && hasNonAmbientClass(symbol))) { if (node.name) { From a50ab3ebb00d381974ad0308aaff2c4c9091be4c Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 12:20:36 -0700 Subject: [PATCH 044/309] Remove checking in declareSymbol --- src/compiler/binder.ts | 20 ++++++++++---------- src/compiler/types.ts | 3 +-- 2 files changed, 11 insertions(+), 12 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index b417892d354..60b5a622ac6 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -135,14 +135,14 @@ module ts { return node.name ? declarationNameToString(node.name) : getDeclarationName(node); } - /** - * Checks if the symbol contains a class declaration that is non-ambient. - */ - function hasNonAmbientClass(symbol: Symbol): boolean { - return symbol && forEach(symbol.declarations, (element: Declaration) => { - return element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient); - }); - } + // /** + // * Checks if the symbol contains a class declaration that is non-ambient. + // */ + // function hasNonAmbientClass(symbol: Symbol): boolean { + // return symbol && forEach(symbol.declarations, (element: Declaration) => { + // return element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient); + // }); + // } /** * Declares a Symbol for the Node and add it to symbols. Reports errors for conflicting identifier names. @@ -164,7 +164,7 @@ module ts { // Check for declarations 'node' cannot be merged with. // Interfaces declarations cannot be merged with non-ambient class declarations, which isn't encoded in SymbolFlags. - if (symbol.flags & excludes || (node.kind === SyntaxKind.InterfaceDeclaration && hasNonAmbientClass(symbol))) { + if (symbol.flags & excludes) { if (node.name) { node.name.parent = node; } @@ -536,7 +536,7 @@ module ts { bindCatchVariableDeclaration(node); break; case SyntaxKind.ClassDeclaration: - bindBlockScopedDeclaration(node, SymbolFlags.Class, isAmbientContext(node) ? SymbolFlags.AmbientClassExcludes : SymbolFlags.ClassExcludes); + bindBlockScopedDeclaration(node, SymbolFlags.Class, SymbolFlags.ClassExcludes); break; case SyntaxKind.InterfaceDeclaration: bindBlockScopedDeclaration(node, SymbolFlags.Interface, SymbolFlags.InterfaceExcludes); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 890c6968de9..ec5a8de0051 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1472,8 +1472,7 @@ module ts { PropertyExcludes = Value, EnumMemberExcludes = Value, FunctionExcludes = Value & ~(Function | ValueModule), - ClassExcludes = (Value | Type) & ~ValueModule, - AmbientClassExcludes = (Value | Type) & ~(ValueModule | Interface), + ClassExcludes = (Value | Type) & ~(ValueModule | Interface), // class-interface mergability done in checker.ts InterfaceExcludes = Type & ~(Interface | Class), RegularEnumExcludes = (Value | Type) & ~(RegularEnum | ValueModule), // regular enums merge only with regular enums and modules ConstEnumExcludes = (Value | Type) & ~ConstEnum, // const enums merge only with const enums From 90e19551bc71f25473eaf559f27611ccb89b8474 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 15:03:01 -0700 Subject: [PATCH 045/309] merge compatiblity now performed in checker.ts --- src/compiler/binder.ts | 12 +------- src/compiler/checker.ts | 28 +++++++++++++++++++ .../diagnosticInformationMap.generated.ts | 2 ++ src/compiler/diagnosticMessages.json | 17 +++++++---- 4 files changed, 43 insertions(+), 16 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 60b5a622ac6..42c22eda571 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -135,15 +135,6 @@ module ts { return node.name ? declarationNameToString(node.name) : getDeclarationName(node); } - // /** - // * Checks if the symbol contains a class declaration that is non-ambient. - // */ - // function hasNonAmbientClass(symbol: Symbol): boolean { - // return symbol && forEach(symbol.declarations, (element: Declaration) => { - // return element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient); - // }); - // } - /** * Declares a Symbol for the Node and add it to symbols. Reports errors for conflicting identifier names. * @param symbols - The symbolTable which node will be added to. @@ -162,8 +153,7 @@ module ts { if (name !== undefined) { symbol = hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name)); - // Check for declarations 'node' cannot be merged with. - // Interfaces declarations cannot be merged with non-ambient class declarations, which isn't encoded in SymbolFlags. + // Check for declarations 'node' cannot be merged with. if (symbol.flags & excludes) { if (node.name) { node.name.parent = node; diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 759b235ad0a..20b0fc6d68e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10393,6 +10393,15 @@ module ts { }); } + // Non-ambient classes cannot merge with interfaces. + if (!(node.flags & NodeFlags.Ambient)) { + if (forEach(symbol.declarations, (element: Declaration) => { + return element.kind === SyntaxKind.InterfaceDeclaration; + })) { + error(node, Diagnostics.A_non_ambient_class_cannot_be_merged_with_an_interface) + } + } + forEach(node.members, checkSourceElement); if (produceDiagnostics) { checkIndexConstraints(type); @@ -10544,6 +10553,15 @@ module ts { return ok; } + /** + * Checks if the symbol contains a class declaration that is non-ambient. + */ + function hasNonAmbientClass(symbol: Symbol): boolean { + return symbol && forEach(symbol.declarations, (element: Declaration) => { + return element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient); + }); + } + function checkInterfaceDeclaration(node: InterfaceDeclaration) { // Grammar checking checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); @@ -10572,6 +10590,13 @@ module ts { checkIndexConstraints(type); } } + + // Interfaces cannot merge with non-ambient classes. + if (!(node.flags & NodeFlags.Ambient)) { + if (hasNonAmbientClass(symbol)) { + error(node, Diagnostics.An_interface_cannot_merge_with_a_non_ambient_class); + } + } } forEach(getInterfaceBaseTypeNodes(node), heritageElement => { if (!isSupportedExpressionWithTypeArguments(heritageElement)) { @@ -10580,6 +10605,9 @@ module ts { checkExpressionWithTypeArguments(heritageElement); }); + + + forEach(node.members, checkSourceElement); if (produceDiagnostics) { diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 6e73d28bddd..2d7fd358f70 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -371,6 +371,8 @@ module ts { Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, No_best_common_type_exists_among_yield_expressions: { code: 2504, category: DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, + A_non_ambient_class_cannot_be_merged_with_an_interface: { code: 2506, category: DiagnosticCategory.Error, key: "A non-ambient class cannot be merged with an interface." }, + An_interface_cannot_merge_with_a_non_ambient_class: { code: 2507, category: DiagnosticCategory.Error, key: "An interface cannot merge with a non-ambient class." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index d5764605d51..fdf35985189 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1456,15 +1456,15 @@ "A rest element cannot contain a binding pattern.": { "category": "Error", "code": 2501 - }, + }, "'{0}' is referenced directly or indirectly in its own type annotation.": { "category": "Error", "code": 2502 - }, + }, "Cannot find namespace '{0}'.": { "category": "Error", "code": 2503 - }, + }, "No best common type exists among yield expressions.": { "category": "Error", "code": 2504 @@ -1472,8 +1472,15 @@ "A generator cannot have a 'void' type annotation.": { "category": "Error", "code": 2505 - }, - + }, + "A non-ambient class cannot be merged with an interface.": { + "category": "Error", + "code": 2506 + }, + "An interface cannot merge with a non-ambient class.": { + "category": "Error", + "code": 2507 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 From c629c3fbee82ab3057b43076134574a94f30edaf Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 15:15:23 -0700 Subject: [PATCH 046/309] deleted redundant tests --- tests/cases/compiler/class1.ts | 2 -- tests/cases/compiler/classAndInterface1.ts | 2 -- 2 files changed, 4 deletions(-) delete mode 100644 tests/cases/compiler/class1.ts delete mode 100644 tests/cases/compiler/classAndInterface1.ts diff --git a/tests/cases/compiler/class1.ts b/tests/cases/compiler/class1.ts deleted file mode 100644 index c7b2115b88b..00000000000 --- a/tests/cases/compiler/class1.ts +++ /dev/null @@ -1,2 +0,0 @@ -interface foo{ } // error -class foo{ } // error \ No newline at end of file diff --git a/tests/cases/compiler/classAndInterface1.ts b/tests/cases/compiler/classAndInterface1.ts deleted file mode 100644 index 79b02915857..00000000000 --- a/tests/cases/compiler/classAndInterface1.ts +++ /dev/null @@ -1,2 +0,0 @@ - class cli { } // error -interface cli { } // error \ No newline at end of file From e4bc29e9a036f7b82a30cfb5dd06b72510571f0e Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 15:22:52 -0700 Subject: [PATCH 047/309] Updated tests --- ...uplicateIdentifiersAcrossFileBoundaries.ts | 33 +++++++++++ .../classAndInterfaceMerge.d.ts | 25 +++++++++ .../declaredClassMergedwithSelf.ts | 13 ++++- .../classDeclarations/mergedClassInterface.ts | 55 +++++++++++++++++-- 4 files changed, 119 insertions(+), 7 deletions(-) create mode 100644 tests/cases/compiler/duplicateIdentifiersAcrossFileBoundaries.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts diff --git a/tests/cases/compiler/duplicateIdentifiersAcrossFileBoundaries.ts b/tests/cases/compiler/duplicateIdentifiersAcrossFileBoundaries.ts new file mode 100644 index 00000000000..94e5cd94ab1 --- /dev/null +++ b/tests/cases/compiler/duplicateIdentifiersAcrossFileBoundaries.ts @@ -0,0 +1,33 @@ +// @declaration: true + +// @Filename: file1.ts +interface I { } +class C1 { } +class C2 { } +function f() { } +var v = 3; + +class Foo { + static x: number; +} + +module N { + export module F { + var t; + } +} + +// @Filename: file2.ts +class I { } // error -- cannot merge interface with non-ambient class +interface C1 { } // error -- cannot merge interface with non-ambient class +function C2() { } // error -- cannot merge function with non-ambient class +class f { } // error -- cannot merge function with non-ambient class +var v = 3; + +module Foo { + export var x: number; // error for redeclaring var in a different parent +} + +declare module N { + export function F(); // no error because function is ambient +} diff --git a/tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts b/tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts new file mode 100644 index 00000000000..1ef7724f81d --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts @@ -0,0 +1,25 @@ + +interface C { } + +declare class C { } + +interface C { } + +interface C { } + +declare module M { + + interface C1 { } + + class C1 { } + + interface C1 { } + + interface C1 { } + + export class C2 { } +} + +declare module M { + export interface C2 { } +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts b/tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts index 4688fec9e26..7445104e228 100644 --- a/tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts +++ b/tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts @@ -1,3 +1,6 @@ + +// @Filename: file1.ts + declare class C1 {} declare class C1 {} @@ -6,4 +9,12 @@ declare class C2 {} interface C2 {} -declare class C2 {} \ No newline at end of file +declare class C2 {} + +// @Filename: file2.ts + +declare class C3 { } + +// @Filename: file3.ts + +declare class C3 { } \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts b/tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts index 4fac95b516a..29400c63808 100644 --- a/tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts +++ b/tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts @@ -1,11 +1,54 @@ -declare class C1 {} +// @declaration: true -interface C1 {} +// @Filename: file1.ts -interface C2 {} +declare class C1 { } -declare class C2 {} +interface C1 { } -interface C2 {} +interface C2 { } -interface C2 {} \ No newline at end of file +declare class C2 { } + +class C3 { } // error -- cannot merge non-ambient class and interface + +interface C3 { } // error -- cannot merge non-ambient class and interface + +interface C4 { } // error -- cannot merge non-ambient class and interface + +class C4 { } // error -- cannot merge non-ambient class and interface + +interface C5 { + x1: number; +} + +declare class C5 { + x2: number; +} + +interface C5 { + x3: number; +} + +interface C5 { + x4: number; +} + +// checks if properties actually were merged +var c5 : C5; +c5.x1; +c5.x2; +c5.x3; +c5.x4; + +// @Filename: file2.ts + +declare class C6 { } + +interface C7 { } + +// @Filename: file3.ts + +interface C6 { } + +declare class C7 { } \ No newline at end of file From b293da4f9bec122ef3b7761b4d3606661f2f0e03 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 15:26:43 -0700 Subject: [PATCH 048/309] updated baselines --- .../reference/augmentedTypesClass2.errors.txt | 8 +- .../augmentedTypesInterface.errors.txt | 8 +- tests/baselines/reference/class1.errors.txt | 11 -- tests/baselines/reference/class1.js | 10 -- .../reference/classAndInterface1.errors.txt | 11 -- .../baselines/reference/classAndInterface1.js | 10 -- .../classAndInterfaceMerge.d.errors.txt | 46 +++++++ .../classAndInterfaceWithSameName.errors.txt | 30 ++-- .../reference/clinterfaces.errors.txt | 32 ++--- tests/baselines/reference/clinterfaces.js | 1 + .../baselines/reference/declInput.errors.txt | 8 +- .../declaredClassMergedwithSelf.errors.txt | 30 +++- .../reference/declaredClassMergedwithSelf.js | 20 ++- ...ifiersAcrossContainerBoundaries.errors.txt | 8 +- ...IdentifiersAcrossFileBoundaries.errors.txt | 67 +++++++++ ...uplicateIdentifiersAcrossFileBoundaries.js | 76 +++++++++++ .../interfaceDeclaration2.errors.txt | 8 +- .../reference/mergedClassInterface.errors.txt | 67 +++++++++ .../reference/mergedClassInterface.js | 129 ++++++++++++++++-- .../reference/mergedClassInterface.symbols | 19 --- .../reference/mergedClassInterface.types | 19 --- .../reference/nameCollisions.errors.txt | 16 +-- ...tringsArrayTypeDefinedInES5Mode.errors.txt | 14 +- ...ingsArrayTypeRedefinedInES6Mode.errors.txt | 14 +- 24 files changed, 492 insertions(+), 170 deletions(-) delete mode 100644 tests/baselines/reference/class1.errors.txt delete mode 100644 tests/baselines/reference/class1.js delete mode 100644 tests/baselines/reference/classAndInterface1.errors.txt delete mode 100644 tests/baselines/reference/classAndInterface1.js create mode 100644 tests/baselines/reference/classAndInterfaceMerge.d.errors.txt create mode 100644 tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt create mode 100644 tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js create mode 100644 tests/baselines/reference/mergedClassInterface.errors.txt delete mode 100644 tests/baselines/reference/mergedClassInterface.symbols delete mode 100644 tests/baselines/reference/mergedClassInterface.types diff --git a/tests/baselines/reference/augmentedTypesClass2.errors.txt b/tests/baselines/reference/augmentedTypesClass2.errors.txt index 5881e49dae9..2622429d743 100644 --- a/tests/baselines/reference/augmentedTypesClass2.errors.txt +++ b/tests/baselines/reference/augmentedTypesClass2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/augmentedTypesClass2.ts(4,7): error TS2300: Duplicate identifier 'c11'. -tests/cases/compiler/augmentedTypesClass2.ts(10,11): error TS2300: Duplicate identifier 'c11'. +tests/cases/compiler/augmentedTypesClass2.ts(4,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/augmentedTypesClass2.ts(10,11): error TS2507: An interface cannot merge with a non-ambient class. tests/cases/compiler/augmentedTypesClass2.ts(16,7): error TS2300: Duplicate identifier 'c33'. tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate identifier 'c33'. @@ -10,7 +10,7 @@ tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate iden // class then interface class c11 { // error ~~~ -!!! error TS2300: Duplicate identifier 'c11'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. foo() { return 1; } @@ -18,7 +18,7 @@ tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate iden interface c11 { // error ~~~ -!!! error TS2300: Duplicate identifier 'c11'. +!!! error TS2507: An interface cannot merge with a non-ambient class. bar(): void; } diff --git a/tests/baselines/reference/augmentedTypesInterface.errors.txt b/tests/baselines/reference/augmentedTypesInterface.errors.txt index a9fc28dd5ae..9719539b344 100644 --- a/tests/baselines/reference/augmentedTypesInterface.errors.txt +++ b/tests/baselines/reference/augmentedTypesInterface.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/augmentedTypesInterface.ts(12,11): error TS2300: Duplicate identifier 'i2'. -tests/cases/compiler/augmentedTypesInterface.ts(16,7): error TS2300: Duplicate identifier 'i2'. +tests/cases/compiler/augmentedTypesInterface.ts(12,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/augmentedTypesInterface.ts(16,7): error TS2506: A non-ambient class cannot be merged with an interface. tests/cases/compiler/augmentedTypesInterface.ts(23,11): error TS2300: Duplicate identifier 'i3'. tests/cases/compiler/augmentedTypesInterface.ts(26,6): error TS2300: Duplicate identifier 'i3'. @@ -18,13 +18,13 @@ tests/cases/compiler/augmentedTypesInterface.ts(26,6): error TS2300: Duplicate i // interface then class interface i2 { // error ~~ -!!! error TS2300: Duplicate identifier 'i2'. +!!! error TS2507: An interface cannot merge with a non-ambient class. foo(): void; } class i2 { // error ~~ -!!! error TS2300: Duplicate identifier 'i2'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. bar() { return 1; } diff --git a/tests/baselines/reference/class1.errors.txt b/tests/baselines/reference/class1.errors.txt deleted file mode 100644 index b90fae9cb40..00000000000 --- a/tests/baselines/reference/class1.errors.txt +++ /dev/null @@ -1,11 +0,0 @@ -tests/cases/compiler/class1.ts(1,11): error TS2300: Duplicate identifier 'foo'. -tests/cases/compiler/class1.ts(2,7): error TS2300: Duplicate identifier 'foo'. - - -==== tests/cases/compiler/class1.ts (2 errors) ==== - interface foo{ } // error - ~~~ -!!! error TS2300: Duplicate identifier 'foo'. - class foo{ } // error - ~~~ -!!! error TS2300: Duplicate identifier 'foo'. \ No newline at end of file diff --git a/tests/baselines/reference/class1.js b/tests/baselines/reference/class1.js deleted file mode 100644 index 7a104e237b6..00000000000 --- a/tests/baselines/reference/class1.js +++ /dev/null @@ -1,10 +0,0 @@ -//// [class1.ts] -interface foo{ } // error -class foo{ } // error - -//// [class1.js] -var foo = (function () { - function foo() { - } - return foo; -})(); // error diff --git a/tests/baselines/reference/classAndInterface1.errors.txt b/tests/baselines/reference/classAndInterface1.errors.txt deleted file mode 100644 index 8d31e847d71..00000000000 --- a/tests/baselines/reference/classAndInterface1.errors.txt +++ /dev/null @@ -1,11 +0,0 @@ -tests/cases/compiler/classAndInterface1.ts(1,8): error TS2300: Duplicate identifier 'cli'. -tests/cases/compiler/classAndInterface1.ts(2,11): error TS2300: Duplicate identifier 'cli'. - - -==== tests/cases/compiler/classAndInterface1.ts (2 errors) ==== - class cli { } // error - ~~~ -!!! error TS2300: Duplicate identifier 'cli'. - interface cli { } // error - ~~~ -!!! error TS2300: Duplicate identifier 'cli'. \ No newline at end of file diff --git a/tests/baselines/reference/classAndInterface1.js b/tests/baselines/reference/classAndInterface1.js deleted file mode 100644 index 5efabded838..00000000000 --- a/tests/baselines/reference/classAndInterface1.js +++ /dev/null @@ -1,10 +0,0 @@ -//// [classAndInterface1.ts] - class cli { } // error -interface cli { } // error - -//// [classAndInterface1.js] -var cli = (function () { - function cli() { - } - return cli; -})(); // error diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt b/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt new file mode 100644 index 00000000000..d4afe3bc7c9 --- /dev/null +++ b/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt @@ -0,0 +1,46 @@ +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(12,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(14,11): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(16,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(18,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(20,18): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(24,22): error TS2507: An interface cannot merge with a non-ambient class. + + +==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts (6 errors) ==== + + interface C { } + + declare class C { } + + interface C { } + + interface C { } + + declare module M { + + interface C1 { } + ~~ +!!! error TS2507: An interface cannot merge with a non-ambient class. + + class C1 { } + ~~ +!!! error TS2506: A non-ambient class cannot be merged with an interface. + + interface C1 { } + ~~ +!!! error TS2507: An interface cannot merge with a non-ambient class. + + interface C1 { } + ~~ +!!! error TS2507: An interface cannot merge with a non-ambient class. + + export class C2 { } + ~~ +!!! error TS2506: A non-ambient class cannot be merged with an interface. + } + + declare module M { + export interface C2 { } + ~~ +!!! error TS2507: An interface cannot merge with a non-ambient class. + } \ No newline at end of file diff --git a/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt b/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt index aa3e687cf4d..6bf95880ceb 100644 --- a/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt +++ b/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt @@ -1,27 +1,39 @@ -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,7): error TS2300: Duplicate identifier 'C'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,11): error TS2300: Duplicate identifier 'C'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(5,11): error TS2300: Duplicate identifier 'D'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(9,15): error TS2300: Duplicate identifier 'D'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,11): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,15): error TS2300: Duplicate identifier 'foo'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(5,11): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(6,9): error TS2300: Duplicate identifier 'bar'. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(9,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(10,9): error TS2300: Duplicate identifier 'bar'. -==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts (4 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts (8 errors) ==== class C { foo: string; } ~ -!!! error TS2300: Duplicate identifier 'C'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. interface C { foo: string; } // error ~ -!!! error TS2300: Duplicate identifier 'C'. +!!! error TS2507: An interface cannot merge with a non-ambient class. + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. module M { class D { ~ -!!! error TS2300: Duplicate identifier 'D'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. bar: string; + ~~~ +!!! error TS2300: Duplicate identifier 'bar'. } interface D { // error ~ -!!! error TS2300: Duplicate identifier 'D'. +!!! error TS2507: An interface cannot merge with a non-ambient class. bar: string; + ~~~ +!!! error TS2300: Duplicate identifier 'bar'. } } \ No newline at end of file diff --git a/tests/baselines/reference/clinterfaces.errors.txt b/tests/baselines/reference/clinterfaces.errors.txt index d5eab2c7994..6e172fa0d96 100644 --- a/tests/baselines/reference/clinterfaces.errors.txt +++ b/tests/baselines/reference/clinterfaces.errors.txt @@ -1,50 +1,50 @@ -tests/cases/compiler/clinterfaces.ts(2,11): error TS2300: Duplicate identifier 'C'. -tests/cases/compiler/clinterfaces.ts(3,15): error TS2300: Duplicate identifier 'C'. -tests/cases/compiler/clinterfaces.ts(4,15): error TS2300: Duplicate identifier 'D'. -tests/cases/compiler/clinterfaces.ts(5,11): error TS2300: Duplicate identifier 'D'. -tests/cases/compiler/clinterfaces.ts(8,11): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/clinterfaces.ts(12,7): error TS2300: Duplicate identifier 'Foo'. -tests/cases/compiler/clinterfaces.ts(16,7): error TS2300: Duplicate identifier 'Bar'. -tests/cases/compiler/clinterfaces.ts(20,11): error TS2300: Duplicate identifier 'Bar'. +tests/cases/compiler/clinterfaces.ts(2,11): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/clinterfaces.ts(3,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/clinterfaces.ts(4,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/clinterfaces.ts(5,11): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/clinterfaces.ts(8,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/clinterfaces.ts(12,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/clinterfaces.ts(16,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/clinterfaces.ts(20,11): error TS2507: An interface cannot merge with a non-ambient class. ==== tests/cases/compiler/clinterfaces.ts (8 errors) ==== module M { class C { } ~ -!!! error TS2300: Duplicate identifier 'C'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. interface C { } ~ -!!! error TS2300: Duplicate identifier 'C'. +!!! error TS2507: An interface cannot merge with a non-ambient class. interface D { } ~ -!!! error TS2300: Duplicate identifier 'D'. +!!! error TS2507: An interface cannot merge with a non-ambient class. class D { } ~ -!!! error TS2300: Duplicate identifier 'D'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. } interface Foo { ~~~ -!!! error TS2300: Duplicate identifier 'Foo'. +!!! error TS2507: An interface cannot merge with a non-ambient class. a: string; } class Foo{ ~~~ -!!! error TS2300: Duplicate identifier 'Foo'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. b: number; } class Bar{ ~~~ -!!! error TS2300: Duplicate identifier 'Bar'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. b: number; } interface Bar { ~~~ -!!! error TS2300: Duplicate identifier 'Bar'. +!!! error TS2507: An interface cannot merge with a non-ambient class. a: string; } diff --git a/tests/baselines/reference/clinterfaces.js b/tests/baselines/reference/clinterfaces.js index 02ae7349869..a55924227c9 100644 --- a/tests/baselines/reference/clinterfaces.js +++ b/tests/baselines/reference/clinterfaces.js @@ -49,3 +49,4 @@ var Bar = (function () { } return Bar; })(); +module.exports = Foo; diff --git a/tests/baselines/reference/declInput.errors.txt b/tests/baselines/reference/declInput.errors.txt index 8ec341ce15b..313866cf93d 100644 --- a/tests/baselines/reference/declInput.errors.txt +++ b/tests/baselines/reference/declInput.errors.txt @@ -1,17 +1,17 @@ -tests/cases/compiler/declInput.ts(1,11): error TS2300: Duplicate identifier 'bar'. -tests/cases/compiler/declInput.ts(5,7): error TS2300: Duplicate identifier 'bar'. +tests/cases/compiler/declInput.ts(1,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/declInput.ts(5,7): error TS2506: A non-ambient class cannot be merged with an interface. ==== tests/cases/compiler/declInput.ts (2 errors) ==== interface bar { ~~~ -!!! error TS2300: Duplicate identifier 'bar'. +!!! error TS2507: An interface cannot merge with a non-ambient class. } class bar { ~~~ -!!! error TS2300: Duplicate identifier 'bar'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. public f() { return ''; } public g() { return {a: null, b: undefined, c: void 4 }; } public h(x = 4, y = null, z = '') { x++; } diff --git a/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt b/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt index 8a783639c1c..a46dfb0d339 100644 --- a/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt +++ b/tests/baselines/reference/declaredClassMergedwithSelf.errors.txt @@ -1,11 +1,15 @@ -tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(1,15): error TS2300: Duplicate identifier 'C1'. -tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(3,15): error TS2300: Duplicate identifier 'C1'. -tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(5,15): error TS2300: Duplicate identifier 'C2'. -tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(7,11): error TS2300: Duplicate identifier 'C2'. -tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(9,15): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file1.ts(3,15): error TS2300: Duplicate identifier 'C1'. +tests/cases/conformance/classes/classDeclarations/file1.ts(5,15): error TS2300: Duplicate identifier 'C1'. +tests/cases/conformance/classes/classDeclarations/file1.ts(7,15): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file1.ts(9,11): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file1.ts(11,15): error TS2300: Duplicate identifier 'C2'. +tests/cases/conformance/classes/classDeclarations/file2.ts(2,15): error TS2300: Duplicate identifier 'C3'. +tests/cases/conformance/classes/classDeclarations/file3.ts(2,15): error TS2300: Duplicate identifier 'C3'. -==== tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts (5 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/file1.ts (5 errors) ==== + + declare class C1 {} ~~ !!! error TS2300: Duplicate identifier 'C1'. @@ -24,4 +28,16 @@ tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts declare class C2 {} ~~ -!!! error TS2300: Duplicate identifier 'C2'. \ No newline at end of file +!!! error TS2300: Duplicate identifier 'C2'. + +==== tests/cases/conformance/classes/classDeclarations/file2.ts (1 errors) ==== + + declare class C3 { } + ~~ +!!! error TS2300: Duplicate identifier 'C3'. + +==== tests/cases/conformance/classes/classDeclarations/file3.ts (1 errors) ==== + + declare class C3 { } + ~~ +!!! error TS2300: Duplicate identifier 'C3'. \ No newline at end of file diff --git a/tests/baselines/reference/declaredClassMergedwithSelf.js b/tests/baselines/reference/declaredClassMergedwithSelf.js index 85213668adc..a38391d90db 100644 --- a/tests/baselines/reference/declaredClassMergedwithSelf.js +++ b/tests/baselines/reference/declaredClassMergedwithSelf.js @@ -1,4 +1,8 @@ -//// [declaredClassMergedwithSelf.ts] +//// [tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts] //// + +//// [file1.ts] + + declare class C1 {} declare class C1 {} @@ -7,6 +11,16 @@ declare class C2 {} interface C2 {} -declare class C2 {} +declare class C2 {} -//// [declaredClassMergedwithSelf.js] +//// [file2.ts] + +declare class C3 { } + +//// [file3.ts] + +declare class C3 { } + +//// [file1.js] +//// [file2.js] +//// [file3.js] diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt index 6c80d13b2f4..77a7f4ffb35 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(2,22): error TS2300: Duplicate identifier 'I'. -tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(5,18): error TS2300: Duplicate identifier 'I'. +tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(2,22): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(5,18): error TS2506: A non-ambient class cannot be merged with an interface. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(9,21): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(12,18): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(37,12): error TS2300: Duplicate identifier 'x'. @@ -10,12 +10,12 @@ tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(41,16): er module M { export interface I { } ~ -!!! error TS2300: Duplicate identifier 'I'. +!!! error TS2507: An interface cannot merge with a non-ambient class. } module M { export class I { } // error ~ -!!! error TS2300: Duplicate identifier 'I'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. } module M { diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt new file mode 100644 index 00000000000..0febfd77ec5 --- /dev/null +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt @@ -0,0 +1,67 @@ +tests/cases/compiler/file1.ts(1,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/file1.ts(2,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/file1.ts(3,7): error TS2300: Duplicate identifier 'C2'. +tests/cases/compiler/file1.ts(4,10): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/file1.ts(8,12): error TS2300: Duplicate identifier 'x'. +tests/cases/compiler/file2.ts(1,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/file2.ts(2,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/file2.ts(3,10): error TS2300: Duplicate identifier 'C2'. +tests/cases/compiler/file2.ts(4,7): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/file2.ts(7,8): error TS2433: A namespace declaration cannot be in a different file from a class or function with which it is merged +tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. + + +==== tests/cases/compiler/file1.ts (5 errors) ==== + interface I { } + ~ +!!! error TS2507: An interface cannot merge with a non-ambient class. + class C1 { } + ~~ +!!! error TS2506: A non-ambient class cannot be merged with an interface. + class C2 { } + ~~ +!!! error TS2300: Duplicate identifier 'C2'. + function f() { } + ~ +!!! error TS2300: Duplicate identifier 'f'. + var v = 3; + + class Foo { + static x: number; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + module N { + export module F { + var t; + } + } + +==== tests/cases/compiler/file2.ts (6 errors) ==== + class I { } // error -- cannot merge interface with non-ambient class + ~ +!!! error TS2506: A non-ambient class cannot be merged with an interface. + interface C1 { } // error -- cannot merge interface with non-ambient class + ~~ +!!! error TS2507: An interface cannot merge with a non-ambient class. + function C2() { } // error -- cannot merge function with non-ambient class + ~~ +!!! error TS2300: Duplicate identifier 'C2'. + class f { } // error -- cannot merge function with non-ambient class + ~ +!!! error TS2300: Duplicate identifier 'f'. + var v = 3; + + module Foo { + ~~~ +!!! error TS2433: A namespace declaration cannot be in a different file from a class or function with which it is merged + export var x: number; // error for redeclaring var in a different parent + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + declare module N { + export function F(); // no error because function is ambient + } + \ No newline at end of file diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js new file mode 100644 index 00000000000..f6e3a5652e5 --- /dev/null +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js @@ -0,0 +1,76 @@ +//// [tests/cases/compiler/duplicateIdentifiersAcrossFileBoundaries.ts] //// + +//// [file1.ts] +interface I { } +class C1 { } +class C2 { } +function f() { } +var v = 3; + +class Foo { + static x: number; +} + +module N { + export module F { + var t; + } +} + +//// [file2.ts] +class I { } // error -- cannot merge interface with non-ambient class +interface C1 { } // error -- cannot merge interface with non-ambient class +function C2() { } // error -- cannot merge function with non-ambient class +class f { } // error -- cannot merge function with non-ambient class +var v = 3; + +module Foo { + export var x: number; // error for redeclaring var in a different parent +} + +declare module N { + export function F(); // no error because function is ambient +} + + +//// [file1.js] +var C1 = (function () { + function C1() { + } + return C1; +})(); +var C2 = (function () { + function C2() { + } + return C2; +})(); +function f() { } +var v = 3; +var Foo = (function () { + function Foo() { + } + return Foo; +})(); +var N; +(function (N) { + var F; + (function (F) { + var t; + })(F = N.F || (N.F = {})); +})(N || (N = {})); +//// [file2.js] +var I = (function () { + function I() { + } + return I; +})(); // error -- cannot merge interface with non-ambient class +function C2() { } // error -- cannot merge function with non-ambient class +var f = (function () { + function f() { + } + return f; +})(); // error -- cannot merge function with non-ambient class +var v = 3; +var Foo; +(function (Foo) { +})(Foo || (Foo = {})); diff --git a/tests/baselines/reference/interfaceDeclaration2.errors.txt b/tests/baselines/reference/interfaceDeclaration2.errors.txt index 9739d946bc5..06a0e247301 100644 --- a/tests/baselines/reference/interfaceDeclaration2.errors.txt +++ b/tests/baselines/reference/interfaceDeclaration2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/interfaceDeclaration2.ts(4,11): error TS2300: Duplicate identifier 'I2'. -tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2300: Duplicate identifier 'I2'. +tests/cases/compiler/interfaceDeclaration2.ts(4,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2506: A non-ambient class cannot be merged with an interface. ==== tests/cases/compiler/interfaceDeclaration2.ts (2 errors) ==== @@ -8,10 +8,10 @@ tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2300: Duplicate iden interface I2 { } ~~ -!!! error TS2300: Duplicate identifier 'I2'. +!!! error TS2507: An interface cannot merge with a non-ambient class. class I2 { } ~~ -!!! error TS2300: Duplicate identifier 'I2'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. interface I3 { } function I3() { } diff --git a/tests/baselines/reference/mergedClassInterface.errors.txt b/tests/baselines/reference/mergedClassInterface.errors.txt new file mode 100644 index 00000000000..42f0a14b8ef --- /dev/null +++ b/tests/baselines/reference/mergedClassInterface.errors.txt @@ -0,0 +1,67 @@ +tests/cases/conformance/classes/classDeclarations/file1.ts(11,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(13,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/file1.ts(15,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2506: A non-ambient class cannot be merged with an interface. + + +==== tests/cases/conformance/classes/classDeclarations/file1.ts (4 errors) ==== + + + declare class C1 { } + + interface C1 { } + + interface C2 { } + + declare class C2 { } + + class C3 { } // error -- cannot merge non-ambient class and interface + ~~ +!!! error TS2506: A non-ambient class cannot be merged with an interface. + + interface C3 { } // error -- cannot merge non-ambient class and interface + ~~ +!!! error TS2507: An interface cannot merge with a non-ambient class. + + interface C4 { } // error -- cannot merge non-ambient class and interface + ~~ +!!! error TS2507: An interface cannot merge with a non-ambient class. + + class C4 { } // error -- cannot merge non-ambient class and interface + ~~ +!!! error TS2506: A non-ambient class cannot be merged with an interface. + + interface C5 { + x1: number; + } + + declare class C5 { + x2: number; + } + + interface C5 { + x3: number; + } + + interface C5 { + x4: number; + } + + // checks if properties actually were merged + var c5 : C5; + c5.x1; + c5.x2; + c5.x3; + c5.x4; + +==== tests/cases/conformance/classes/classDeclarations/file2.ts (0 errors) ==== + + declare class C6 { } + + interface C7 { } + +==== tests/cases/conformance/classes/classDeclarations/file3.ts (0 errors) ==== + + interface C6 { } + + declare class C7 { } \ No newline at end of file diff --git a/tests/baselines/reference/mergedClassInterface.js b/tests/baselines/reference/mergedClassInterface.js index 70c8b7d2b2f..7176255655d 100644 --- a/tests/baselines/reference/mergedClassInterface.js +++ b/tests/baselines/reference/mergedClassInterface.js @@ -1,14 +1,117 @@ -//// [mergedClassInterface.ts] -declare class C1 {} - -interface C1 {} - -interface C2 {} - -declare class C2 {} - -interface C2 {} - -interface C2 {} +//// [tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts] //// -//// [mergedClassInterface.js] +//// [file1.ts] + + +declare class C1 { } + +interface C1 { } + +interface C2 { } + +declare class C2 { } + +class C3 { } // error -- cannot merge non-ambient class and interface + +interface C3 { } // error -- cannot merge non-ambient class and interface + +interface C4 { } // error -- cannot merge non-ambient class and interface + +class C4 { } // error -- cannot merge non-ambient class and interface + +interface C5 { + x1: number; +} + +declare class C5 { + x2: number; +} + +interface C5 { + x3: number; +} + +interface C5 { + x4: number; +} + +// checks if properties actually were merged +var c5 : C5; +c5.x1; +c5.x2; +c5.x3; +c5.x4; + +//// [file2.ts] + +declare class C6 { } + +interface C7 { } + +//// [file3.ts] + +interface C6 { } + +declare class C7 { } + +//// [file1.js] +var C3 = (function () { + function C3() { + } + return C3; +})(); // error -- cannot merge non-ambient class and interface +var C4 = (function () { + function C4() { + } + return C4; +})(); // error -- cannot merge non-ambient class and interface +// checks if properties actually were merged +var c5; +c5.x1; +c5.x2; +c5.x3; +c5.x4; +//// [file2.js] +//// [file3.js] + + +//// [file1.d.ts] +declare class C1 { +} +interface C1 { +} +interface C2 { +} +declare class C2 { +} +declare class C3 { +} +interface C3 { +} +interface C4 { +} +declare class C4 { +} +interface C5 { + x1: number; +} +declare class C5 { + x2: number; +} +interface C5 { + x3: number; +} +interface C5 { + x4: number; +} +declare var c5: C5; +//// [file2.d.ts] +declare class C6 { +} +interface C7 { +} +//// [file3.d.ts] +interface C6 { +} +declare class C7 { +} diff --git a/tests/baselines/reference/mergedClassInterface.symbols b/tests/baselines/reference/mergedClassInterface.symbols deleted file mode 100644 index dc7ba891551..00000000000 --- a/tests/baselines/reference/mergedClassInterface.symbols +++ /dev/null @@ -1,19 +0,0 @@ -=== tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts === -declare class C1 {} ->C1 : Symbol(C1, Decl(mergedClassInterface.ts, 0, 0), Decl(mergedClassInterface.ts, 0, 19)) - -interface C1 {} ->C1 : Symbol(C1, Decl(mergedClassInterface.ts, 0, 0), Decl(mergedClassInterface.ts, 0, 19)) - -interface C2 {} ->C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15)) - -declare class C2 {} ->C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15)) - -interface C2 {} ->C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15)) - -interface C2 {} ->C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15)) - diff --git a/tests/baselines/reference/mergedClassInterface.types b/tests/baselines/reference/mergedClassInterface.types deleted file mode 100644 index a31f147b734..00000000000 --- a/tests/baselines/reference/mergedClassInterface.types +++ /dev/null @@ -1,19 +0,0 @@ -=== tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts === -declare class C1 {} ->C1 : C1 - -interface C1 {} ->C1 : C1 - -interface C2 {} ->C2 : C2 - -declare class C2 {} ->C2 : C2 - -interface C2 {} ->C2 : C2 - -interface C2 {} ->C2 : C2 - diff --git a/tests/baselines/reference/nameCollisions.errors.txt b/tests/baselines/reference/nameCollisions.errors.txt index 5eb7ea2cf80..d570d9e1278 100644 --- a/tests/baselines/reference/nameCollisions.errors.txt +++ b/tests/baselines/reference/nameCollisions.errors.txt @@ -11,10 +11,10 @@ tests/cases/compiler/nameCollisions.ts(33,11): error TS2300: Duplicate identifie tests/cases/compiler/nameCollisions.ts(34,14): error TS2300: Duplicate identifier 'C'. tests/cases/compiler/nameCollisions.ts(36,14): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/nameCollisions.ts(37,11): error TS2300: Duplicate identifier 'C2'. -tests/cases/compiler/nameCollisions.ts(42,11): error TS2300: Duplicate identifier 'cli'. -tests/cases/compiler/nameCollisions.ts(43,15): error TS2300: Duplicate identifier 'cli'. -tests/cases/compiler/nameCollisions.ts(45,15): error TS2300: Duplicate identifier 'cli2'. -tests/cases/compiler/nameCollisions.ts(46,11): error TS2300: Duplicate identifier 'cli2'. +tests/cases/compiler/nameCollisions.ts(42,11): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/nameCollisions.ts(43,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/nameCollisions.ts(45,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/nameCollisions.ts(46,11): error TS2506: A non-ambient class cannot be merged with an interface. ==== tests/cases/compiler/nameCollisions.ts (17 errors) ==== @@ -87,15 +87,15 @@ tests/cases/compiler/nameCollisions.ts(46,11): error TS2300: Duplicate identifie class cli { } ~~~ -!!! error TS2300: Duplicate identifier 'cli'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. interface cli { } // error ~~~ -!!! error TS2300: Duplicate identifier 'cli'. +!!! error TS2507: An interface cannot merge with a non-ambient class. interface cli2 { } ~~~~ -!!! error TS2300: Duplicate identifier 'cli2'. +!!! error TS2507: An interface cannot merge with a non-ambient class. class cli2 { } // error ~~~~ -!!! error TS2300: Duplicate identifier 'cli2'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. } \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt index 7c796d47398..9d6da3ec4b4 100644 --- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt @@ -1,14 +1,14 @@ -lib.d.ts(521,11): error TS2300: Duplicate identifier 'TemplateStringsArray'. -tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(2,7): error TS2300: Duplicate identifier 'TemplateStringsArray'. -tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'TemplateStringsArray'. - Property 'raw' is missing in type '{ [x: number]: undefined; }'. +lib.d.ts(521,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(2,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. + Property 'raw' is missing in type '{}'. ==== tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts (2 errors) ==== class TemplateStringsArray { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2300: Duplicate identifier 'TemplateStringsArray'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. } function f(x: TemplateStringsArray, y: number, z: number) { @@ -16,7 +16,7 @@ tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2 f({}, 10, 10); ~~ -!!! error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'TemplateStringsArray'. -!!! error TS2345: Property 'raw' is missing in type '{ [x: number]: undefined; }'. +!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. +!!! error TS2345: Property 'raw' is missing in type '{}'. f `abcdef${ 1234 }${ 5678 }ghijkl`; \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt index 4b9cb63d9aa..ffb619cedc7 100644 --- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt @@ -1,14 +1,14 @@ -lib.d.ts(521,11): error TS2300: Duplicate identifier 'TemplateStringsArray'. -tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(2,7): error TS2300: Duplicate identifier 'TemplateStringsArray'. -tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'TemplateStringsArray'. - Property 'raw' is missing in type '{ [x: number]: undefined; }'. +lib.d.ts(521,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(2,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. + Property 'raw' is missing in type '{}'. ==== tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts (2 errors) ==== class TemplateStringsArray { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2300: Duplicate identifier 'TemplateStringsArray'. +!!! error TS2506: A non-ambient class cannot be merged with an interface. } function f(x: TemplateStringsArray, y: number, z: number) { @@ -16,7 +16,7 @@ tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error T f({}, 10, 10); ~~ -!!! error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'TemplateStringsArray'. -!!! error TS2345: Property 'raw' is missing in type '{ [x: number]: undefined; }'. +!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. +!!! error TS2345: Property 'raw' is missing in type '{}'. f `abcdef${ 1234 }${ 5678 }ghijkl`; \ No newline at end of file From 0917582a014cf3973d9d7f5f2d21d0ecb094b5e7 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 15:39:48 -0700 Subject: [PATCH 049/309] removed extra newlines --- src/compiler/checker.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index cce77cdd7de..4a65b3503d9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10614,9 +10614,7 @@ module ts { checkExpressionWithTypeArguments(heritageElement); }); - - forEach(node.members, checkSourceElement); if (produceDiagnostics) { From fa06f3e4e658bda108b6fbd4c8e0c8ab39284ba4 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 15:58:15 -0700 Subject: [PATCH 050/309] fixed merge conflict. --- src/compiler/diagnosticMessages.json | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index d4595d4cd28..8f3973fbdb8 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1476,7 +1476,6 @@ "category": "Error", "code": 2505 }, -<<<<<<< HEAD "A non-ambient class cannot be merged with an interface.": { "category": "Error", "code": 2506 @@ -1485,9 +1484,6 @@ "category": "Error", "code": 2507 }, -======= - ->>>>>>> master "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 From fa9b6fcb0708d9a90f3d537198107abbe235627b Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 2 Jun 2015 17:34:34 -0700 Subject: [PATCH 051/309] fixed loops, merged baseline --- src/compiler/checker.ts | 27 +++++---------- .../classAndInterfaceMerge.d.errors.txt | 4 +-- ...IdentifiersAcrossFileBoundaries.errors.txt | 11 +++--- ...uplicateIdentifiersAcrossFileBoundaries.js | 34 +++++++++++++++++++ 4 files changed, 50 insertions(+), 26 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 4a65b3503d9..36012af42a5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10403,12 +10403,8 @@ module ts { } // Non-ambient classes cannot merge with interfaces. - if (!(node.flags & NodeFlags.Ambient)) { - if (forEach(symbol.declarations, (element: Declaration) => { - return element.kind === SyntaxKind.InterfaceDeclaration; - })) { - error(node, Diagnostics.A_non_ambient_class_cannot_be_merged_with_an_interface) - } + if (!(node.flags & NodeFlags.Ambient) && getDeclarationOfKind(symbol, SyntaxKind.InterfaceDeclaration)) { + error(node, Diagnostics.A_non_ambient_class_cannot_be_merged_with_an_interface) } forEach(node.members, checkSourceElement); @@ -10562,15 +10558,6 @@ module ts { return ok; } - /** - * Checks if the symbol contains a class declaration that is non-ambient. - */ - function hasNonAmbientClass(symbol: Symbol): boolean { - return symbol && forEach(symbol.declarations, (element: Declaration) => { - return element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient); - }); - } - function checkInterfaceDeclaration(node: InterfaceDeclaration) { // Grammar checking checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); @@ -10600,10 +10587,12 @@ module ts { } } - // Interfaces cannot merge with non-ambient classes. - if (!(node.flags & NodeFlags.Ambient)) { - if (hasNonAmbientClass(symbol)) { - error(node, Diagnostics.An_interface_cannot_merge_with_a_non_ambient_class); + if (symbol && symbol.declarations) { + for (let declaration of symbol.declarations) { + if (declaration.kind === SyntaxKind.ClassDeclaration && !(declaration.flags & NodeFlags.Ambient)) { + error(node, Diagnostics.An_interface_cannot_merge_with_a_non_ambient_class); + break; + } } } } diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt b/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt index d4afe3bc7c9..d73e5fcb2f0 100644 --- a/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt +++ b/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt @@ -17,7 +17,7 @@ tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(24 interface C { } declare module M { - + interface C1 { } ~~ !!! error TS2507: An interface cannot merge with a non-ambient class. @@ -33,7 +33,7 @@ tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(24 interface C1 { } ~~ !!! error TS2507: An interface cannot merge with a non-ambient class. - + export class C2 { } ~~ !!! error TS2506: A non-ambient class cannot be merged with an interface. diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt index 0febfd77ec5..bd223330669 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt @@ -1,8 +1,8 @@ -tests/cases/compiler/file1.ts(1,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/file1.ts(2,7): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/compiler/file1.ts(3,7): error TS2300: Duplicate identifier 'C2'. -tests/cases/compiler/file1.ts(4,10): error TS2300: Duplicate identifier 'f'. -tests/cases/compiler/file1.ts(8,12): error TS2300: Duplicate identifier 'x'. +tests/cases/compiler/file1.ts(2,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/file1.ts(3,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/file1.ts(4,7): error TS2300: Duplicate identifier 'C2'. +tests/cases/compiler/file1.ts(5,10): error TS2300: Duplicate identifier 'f'. +tests/cases/compiler/file1.ts(9,12): error TS2300: Duplicate identifier 'x'. tests/cases/compiler/file2.ts(1,7): error TS2506: A non-ambient class cannot be merged with an interface. tests/cases/compiler/file2.ts(2,11): error TS2507: An interface cannot merge with a non-ambient class. tests/cases/compiler/file2.ts(3,10): error TS2300: Duplicate identifier 'C2'. @@ -12,6 +12,7 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. ==== tests/cases/compiler/file1.ts (5 errors) ==== + interface I { } ~ !!! error TS2507: An interface cannot merge with a non-ambient class. diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js index f6e3a5652e5..a2509ea97f4 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.js @@ -1,6 +1,7 @@ //// [tests/cases/compiler/duplicateIdentifiersAcrossFileBoundaries.ts] //// //// [file1.ts] + interface I { } class C1 { } class C2 { } @@ -74,3 +75,36 @@ var v = 3; var Foo; (function (Foo) { })(Foo || (Foo = {})); + + +//// [file1.d.ts] +interface I { +} +declare class C1 { +} +declare class C2 { +} +declare function f(): void; +declare var v: number; +declare class Foo { + static x: number; +} +declare module N { + module F { + } +} +//// [file2.d.ts] +declare class I { +} +interface C1 { +} +declare function C2(): void; +declare class f { +} +declare var v: number; +declare module Foo { + var x: number; +} +declare module N { + function F(): any; +} From f3278e2f0f034c592a0bb2ab931811955a1590c4 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 3 Jun 2015 10:32:59 -0700 Subject: [PATCH 052/309] fixed a grammatical issue --- src/compiler/binder.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 96950ce7b42..b8b63c3aa45 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -166,7 +166,7 @@ module ts { } /** - * Declares a Symbol for the Node and add it to symbols. Reports errors for conflicting identifier names. + * Declares a Symbol for the node and adds it to symbols. Reports errors for conflicting identifier names. * @param symbolTable - The symbol table which node will be added to. * @param parent - If node is in a class, parent denotes the parent declaration. * @param node - The declaration to be added to the symbol table @@ -185,7 +185,7 @@ module ts { // Check and see if the symbol table already has a symbol with this name. If not, // create a new symbol with this name and add it to the table. Note that we don't // give the new symbol any flags *yet*. This ensures that it will not conflict - // witht he 'excludes' flags we pass in. + // with the 'excludes' flags we pass in. // // If we do get an existing symbol, see if it conflicts with the new symbol we're // creating. For example, a 'var' symbol and a 'class' symbol will conflict within From 531f3aa0ac222d9ce50dfba8b6b8db5da205dbaa Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 7 May 2015 15:11:46 -0700 Subject: [PATCH 053/309] Nodes -> Node --- src/services/services.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 400bf754a00..52ffc75efe4 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4227,7 +4227,7 @@ module ts { isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) { - let referencedSymbols = getReferencedSymbolsForNodes(node, sourceFilesToSearch, /*findInStrings:*/ false, /*findInComments:*/ false); + let referencedSymbols = getReferencedSymbolsForNode(node, sourceFilesToSearch, /*findInStrings:*/ false, /*findInComments:*/ false); return convertReferencedSymbols(referencedSymbols); } @@ -4879,10 +4879,10 @@ module ts { } Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.NumericLiteral || node.kind === SyntaxKind.StringLiteral); - return getReferencedSymbolsForNodes(node, program.getSourceFiles(), findInStrings, findInComments); + return getReferencedSymbolsForNode(node, program.getSourceFiles(), findInStrings, findInComments); } - function getReferencedSymbolsForNodes(node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean): ReferencedSymbol[] { + function getReferencedSymbolsForNode(node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean): ReferencedSymbol[] { let typeChecker = program.getTypeChecker(); // Labels From 1a17aba26ae0baf681327415d1be2cc55948f7d2 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 15 May 2015 17:00:13 -0700 Subject: [PATCH 054/309] Added tests. --- .../findAllRefsForDefaultExport01.ts | 21 ++++++++++++++++ .../findAllRefsForDefaultExport02.ts | 22 +++++++++++++++++ .../findAllRefsForDefaultExport03.ts | 24 +++++++++++++++++++ .../findAllRefsForDefaultExportNegative01.ts | 14 +++++++++++ .../findAllRefsForDefaultExportNegative02.ts | 15 ++++++++++++ .../findAllRefsForDefaultExportNegative03.ts | 17 +++++++++++++ 6 files changed, 113 insertions(+) create mode 100644 tests/cases/fourslash/findAllRefsForDefaultExport01.ts create mode 100644 tests/cases/fourslash/findAllRefsForDefaultExport02.ts create mode 100644 tests/cases/fourslash/findAllRefsForDefaultExport03.ts create mode 100644 tests/cases/fourslash/findAllRefsForDefaultExportNegative01.ts create mode 100644 tests/cases/fourslash/findAllRefsForDefaultExportNegative02.ts create mode 100644 tests/cases/fourslash/findAllRefsForDefaultExportNegative03.ts diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport01.ts b/tests/cases/fourslash/findAllRefsForDefaultExport01.ts new file mode 100644 index 00000000000..87c439bd9ef --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefaultExport01.ts @@ -0,0 +1,21 @@ +/// + +////export default class [|DefaultExportedClass|] { +////} +//// +////var x: [|DefaultExportedClass|]; +//// +////var y = new [|DefaultExportedClass|]; +//// +////namespace [|DefaultExportedClass|] { +//// var local = 100; +////} + +let ranges = test.ranges() +for (let range of ranges) { + goTo.position(range.start); + + for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); + } +} \ No newline at end of file diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport02.ts b/tests/cases/fourslash/findAllRefsForDefaultExport02.ts new file mode 100644 index 00000000000..3000b7de92d --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefaultExport02.ts @@ -0,0 +1,22 @@ +/// + +////export default function [|DefaultExportedFunction|]() { +//// return [|DefaultExportedFunction|] +////} +//// +////var x: typeof [|DefaultExportedFunction|]; +//// +////var y = [|DefaultExportedFunction|](); +//// +////namespace [|DefaultExportedFunction|] { +//// var local = 100; +////} + +let ranges = test.ranges() +for (let range of ranges) { + goTo.position(range.start); + + for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); + } +} \ No newline at end of file diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport03.ts b/tests/cases/fourslash/findAllRefsForDefaultExport03.ts new file mode 100644 index 00000000000..89027879ff1 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefaultExport03.ts @@ -0,0 +1,24 @@ +/// + +////function [|f|]() { +//// return 100; +////} +//// +////export default [|f|]; +//// +////var x: typeof [|f|]; +//// +////var y = [|f|](); +//// +////namespace [|f|] { +//// var local = 100; +////} + +let ranges = test.ranges() +for (let range of ranges) { + goTo.position(range.start); + + for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); + } +} \ No newline at end of file diff --git a/tests/cases/fourslash/findAllRefsForDefaultExportNegative01.ts b/tests/cases/fourslash/findAllRefsForDefaultExportNegative01.ts new file mode 100644 index 00000000000..b44ab76b292 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefaultExportNegative01.ts @@ -0,0 +1,14 @@ +/// + +////export default class DefaultExportedClass { +////} +//// +////var x: DefaultExportedClass; +//// +////var y = new DefaultExportedClass; +//// +////namespace /**/DefaultExportedClass { +////} + +goTo.marker(); +verify.referencesCountIs(1); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExportNegative02.ts b/tests/cases/fourslash/findAllRefsForDefaultExportNegative02.ts new file mode 100644 index 00000000000..901cc3ffe0f --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefaultExportNegative02.ts @@ -0,0 +1,15 @@ +/// + +////export default function DefaultExportedFunction() { +//// return DefaultExportedFunction +////} +//// +////var x: typeof DefaultExportedFunction; +//// +////var y = DefaultExportedFunction(); +//// +////namespace /**/DefaultExportedFunction { +////} + +goTo.marker(); +verify.referencesCountIs(1); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExportNegative03.ts b/tests/cases/fourslash/findAllRefsForDefaultExportNegative03.ts new file mode 100644 index 00000000000..d9364b2193e --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefaultExportNegative03.ts @@ -0,0 +1,17 @@ +/// + +////function f() { +//// return 100; +////} +//// +////export default f; +//// +////var x: typeof f; +//// +////var y = f(); +//// +////namespace /**/f { +////} + +goTo.marker(); +verify.referencesCountIs(1); From 9907d62f3b4f4995b9d3831b52248039357ae533 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 19 May 2015 12:43:58 -0700 Subject: [PATCH 055/309] Added rename tests. --- .../fourslash/renameForDefaultExport01.ts | 23 ++++++++++++++++ .../fourslash/renameForDefaultExport02.ts | 24 +++++++++++++++++ .../fourslash/renameForDefaultExport03.ts | 26 +++++++++++++++++++ 3 files changed, 73 insertions(+) create mode 100644 tests/cases/fourslash/renameForDefaultExport01.ts create mode 100644 tests/cases/fourslash/renameForDefaultExport02.ts create mode 100644 tests/cases/fourslash/renameForDefaultExport03.ts diff --git a/tests/cases/fourslash/renameForDefaultExport01.ts b/tests/cases/fourslash/renameForDefaultExport01.ts new file mode 100644 index 00000000000..ec9c3900a5e --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport01.ts @@ -0,0 +1,23 @@ +/// + +/////** +//// * Commenting [|DefaultExportedClass|] +//// */ +////export default class /*1*/[|DefaultExportedClass|] { +////} +//// +////var x: /*2*/[|DefaultExportedClass|]; +//// +////var y = new /*3*/[|DefaultExportedClass|]; +//// +////namespace /*4*/[|DefaultExportedClass|] { +//// var local = 100; +////} + +let markers = test.markers() +for (let marker of markers) { + goTo.position(marker.position); + + verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); + verify.renameInfoSucceeded("DefaultExportedClass"); +} \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport02.ts b/tests/cases/fourslash/renameForDefaultExport02.ts new file mode 100644 index 00000000000..eea63282f5f --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport02.ts @@ -0,0 +1,24 @@ +/// + +/////** +//// * Commenting [|DefaultExportedFunction|] +//// */ +////export default function /*1*/[|DefaultExportedFunction|]() { +//// return /*2*/[|DefaultExportedFunction|] +////} +//// +////var x: typeof /*3*/[|DefaultExportedFunction|]; +//// +////var y = /*4*/[|DefaultExportedFunction|](); +//// +////namespace /*5*/[|DefaultExportedFunction|] { +//// var local = 100; +////} + +let markers = test.markers() +for (let marker of markers) { + goTo.position(marker.position); + + verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); + verify.renameInfoSucceeded("DefaultExportedFunction"); +} \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport03.ts b/tests/cases/fourslash/renameForDefaultExport03.ts new file mode 100644 index 00000000000..b36b04768ab --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport03.ts @@ -0,0 +1,26 @@ +/// + +/////** +//// * Commenting [|f|] +//// */ +////function /*1*/[|f|]() { +//// return 100; +////} +//// +////export default /*2*/[|f|]; +//// +////var x: typeof /*3*/[|f|]; +//// +////var y = /*4*/[|f|](); +//// +////namespace /*5*/[|f|] { +//// var local = 100; +////} + +let markers = test.markers() +for (let marker of markers) { + goTo.position(marker.position); + + verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); + verify.renameInfoSucceeded("f"); +} \ No newline at end of file From 693c587b86fdcaac2e6e82955adc21a4e3974d66 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 19 May 2015 15:53:16 -0700 Subject: [PATCH 056/309] Removed unused code, use valueDeclaration for symbol. --- src/compiler/checker.ts | 3 ++- src/services/services.ts | 22 +++++++--------------- 2 files changed, 9 insertions(+), 16 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index aa2207d5431..a6d95fd3d42 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11833,7 +11833,8 @@ module ts { if (languageVersion === ScriptTarget.ES3) { defaultKeyword = "[\"default\"]"; - } else { + } + else { defaultKeyword = ".default"; } return getGeneratedNameForNode(node.parent) + defaultKeyword; diff --git a/src/services/services.ts b/src/services/services.ts index 52ffc75efe4..1b5ba6752de 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4988,19 +4988,6 @@ module ts { } function getDeclaredName(symbol: Symbol, location: Node) { - // Special case for function expressions, whose names are solely local to their bodies. - let functionExpression = forEach(symbol.declarations, d => d.kind === SyntaxKind.FunctionExpression ? d : undefined); - - // When a name gets interned into a SourceFile's 'identifiers' Map, - // its name is escaped and stored in the same way its symbol name/identifier - // name should be stored. Function expressions, however, are a special case, - // because despite sometimes having a name, the binder unconditionally binds them - // to a symbol with the name "__function". - let name: string; - if (functionExpression && functionExpression.name) { - name = functionExpression.name.text; - } - // If this is an export or import specifier it could have been renamed using the as syntax. // if so we want to search for whatever under the cursor, the symbol is pointing to the alias (name) // so check for the propertyName. @@ -5008,7 +4995,7 @@ module ts { return location.getText(); } - name = typeChecker.symbolToString(symbol); + let name = typeChecker.symbolToString(symbol); return stripQuotes(name); } @@ -5022,7 +5009,12 @@ module ts { } // Special case for function expressions, whose names are solely local to their bodies. - let functionExpression = forEach(declarations, d => d.kind === SyntaxKind.FunctionExpression ? d : undefined); + // TODO (drosen): Why would we have to lookup the interned name for a function expression? + // Shouldn't we have found a scope? Consider a 'Debug.fail()'. + let functionExpression: FunctionExpression; + if (symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.FunctionExpression) { + functionExpression = symbol.valueDeclaration; + } // When a name gets interned into a SourceFile's 'identifiers' Map, // its name is escaped and stored in the same way its symbol name/identifier From 24c504415e0e8896980f4a9cad8cc031f86af064 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 19 May 2015 16:15:51 -0700 Subject: [PATCH 057/309] Error smarter. --- src/harness/fourslash.ts | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 8d313c9a1a6..6867863a941 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -882,6 +882,14 @@ module FourSlash { this.activeFile.fileName, this.currentCaretPosition, findInStrings, findInComments); var ranges = this.getRanges(); + + if (!references) { + if (ranges.length !== 0) { + this.raiseError(`Expected ${ranges.length} rename locations; got none.`); + } + return; + } + if (ranges.length !== references.length) { this.raiseError(this.assertionMessage("Rename locations", references.length, ranges.length)); } From 70911a31b656c020558702c8618f7623c5a04c45 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 20 May 2015 14:58:55 -0700 Subject: [PATCH 058/309] Adjust tests. --- .../fourslash/findAllRefsForDefault04.ts | 28 +++++++++++++++++++ .../fourslash/findAllRefsForDefault05.ts | 28 +++++++++++++++++++ .../fourslash/findAllRefsForDefault06.ts | 28 +++++++++++++++++++ ...gative02.ts => findAllRefsForDefault07.ts} | 3 ++ ...gative01.ts => findAllRefsForDefault08.ts} | 3 ++ .../findAllRefsForDefaultExportNegative03.ts | 17 ----------- 6 files changed, 90 insertions(+), 17 deletions(-) create mode 100644 tests/cases/fourslash/findAllRefsForDefault04.ts create mode 100644 tests/cases/fourslash/findAllRefsForDefault05.ts create mode 100644 tests/cases/fourslash/findAllRefsForDefault06.ts rename tests/cases/fourslash/{findAllRefsForDefaultExportNegative02.ts => findAllRefsForDefault07.ts} (76%) rename tests/cases/fourslash/{findAllRefsForDefaultExportNegative01.ts => findAllRefsForDefault08.ts} (72%) delete mode 100644 tests/cases/fourslash/findAllRefsForDefaultExportNegative03.ts diff --git a/tests/cases/fourslash/findAllRefsForDefault04.ts b/tests/cases/fourslash/findAllRefsForDefault04.ts new file mode 100644 index 00000000000..45b008b55fe --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefault04.ts @@ -0,0 +1,28 @@ +/// + +////function f() { +//// return 100; +////} +//// +////export default [|f|]; +//// +////var x: typeof f; +//// +////var y = f(); +//// +////namespace /**/[|f|] { +////} + +// The function 'f' and the namespace 'f' don't get merged, +// but the 'export default' site, includes both meanings. + +// Here we are testing whether the 'export default' +// site is included in the references to the namespace. + +goTo.marker(); +let ranges = test.ranges(); +verify.referencesCountIs(ranges.length); + +for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); +} diff --git a/tests/cases/fourslash/findAllRefsForDefault05.ts b/tests/cases/fourslash/findAllRefsForDefault05.ts new file mode 100644 index 00000000000..6655138da3b --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefault05.ts @@ -0,0 +1,28 @@ +/// + +////function /**/[|f|]() { +//// return 100; +////} +//// +////export default [|f|]; +//// +////var x: typeof [|f|]; +//// +////var y = [|f|](); +//// +////namespace f { +////} + +// The function 'f' and the namespace 'f' don't get merged, +// but the 'export default' site, includes both meanings. + +// Here we are testing whether the 'export default' site +// and all value-uses of 'f' are included in the references to the function. + +goTo.marker(); +let ranges = test.ranges(); +verify.referencesCountIs(ranges.length); + +for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); +} diff --git a/tests/cases/fourslash/findAllRefsForDefault06.ts b/tests/cases/fourslash/findAllRefsForDefault06.ts new file mode 100644 index 00000000000..12c187b4b0c --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForDefault06.ts @@ -0,0 +1,28 @@ +/// + +////function [|f|]() { +//// return 100; +////} +//// +////export default /**/[|f|]; +//// +////var x: typeof [|f|]; +//// +////var y = [|f|](); +//// +////namespace [|f|] { +////} + +// The function 'f' and the namespace 'f' don't get merged, +// but the 'export default' site, includes both meanings. + +// Here we are testing whether the 'export default' site +// and all value-uses of 'f' are included in the references to the function. + +goTo.marker(); +let ranges = test.ranges(); +verify.referencesCountIs(ranges.length); + +for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); +} diff --git a/tests/cases/fourslash/findAllRefsForDefaultExportNegative02.ts b/tests/cases/fourslash/findAllRefsForDefault07.ts similarity index 76% rename from tests/cases/fourslash/findAllRefsForDefaultExportNegative02.ts rename to tests/cases/fourslash/findAllRefsForDefault07.ts index 901cc3ffe0f..9534a671316 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExportNegative02.ts +++ b/tests/cases/fourslash/findAllRefsForDefault07.ts @@ -11,5 +11,8 @@ ////namespace /**/DefaultExportedFunction { ////} +// The namespace and function do not merge, +// so the namespace should be all alone. + goTo.marker(); verify.referencesCountIs(1); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExportNegative01.ts b/tests/cases/fourslash/findAllRefsForDefault08.ts similarity index 72% rename from tests/cases/fourslash/findAllRefsForDefaultExportNegative01.ts rename to tests/cases/fourslash/findAllRefsForDefault08.ts index b44ab76b292..80eabbe53f4 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExportNegative01.ts +++ b/tests/cases/fourslash/findAllRefsForDefault08.ts @@ -10,5 +10,8 @@ ////namespace /**/DefaultExportedClass { ////} +// The namespace and class do not merge, +// so the namespace should be all alone. + goTo.marker(); verify.referencesCountIs(1); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExportNegative03.ts b/tests/cases/fourslash/findAllRefsForDefaultExportNegative03.ts deleted file mode 100644 index d9364b2193e..00000000000 --- a/tests/cases/fourslash/findAllRefsForDefaultExportNegative03.ts +++ /dev/null @@ -1,17 +0,0 @@ -/// - -////function f() { -//// return 100; -////} -//// -////export default f; -//// -////var x: typeof f; -//// -////var y = f(); -//// -////namespace /**/f { -////} - -goTo.marker(); -verify.referencesCountIs(1); From cf193a4dc4f203c7ff5fa64e69a1f890a37b2e1b Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 20 May 2015 15:34:31 -0700 Subject: [PATCH 059/309] Renamed tests. --- ...indAllRefsForDefault04.ts => findAllRefsForDefaultExport04.ts} | 0 ...indAllRefsForDefault05.ts => findAllRefsForDefaultExport05.ts} | 0 ...indAllRefsForDefault06.ts => findAllRefsForDefaultExport06.ts} | 0 ...indAllRefsForDefault07.ts => findAllRefsForDefaultExport07.ts} | 0 ...indAllRefsForDefault08.ts => findAllRefsForDefaultExport08.ts} | 0 5 files changed, 0 insertions(+), 0 deletions(-) rename tests/cases/fourslash/{findAllRefsForDefault04.ts => findAllRefsForDefaultExport04.ts} (100%) rename tests/cases/fourslash/{findAllRefsForDefault05.ts => findAllRefsForDefaultExport05.ts} (100%) rename tests/cases/fourslash/{findAllRefsForDefault06.ts => findAllRefsForDefaultExport06.ts} (100%) rename tests/cases/fourslash/{findAllRefsForDefault07.ts => findAllRefsForDefaultExport07.ts} (100%) rename tests/cases/fourslash/{findAllRefsForDefault08.ts => findAllRefsForDefaultExport08.ts} (100%) diff --git a/tests/cases/fourslash/findAllRefsForDefault04.ts b/tests/cases/fourslash/findAllRefsForDefaultExport04.ts similarity index 100% rename from tests/cases/fourslash/findAllRefsForDefault04.ts rename to tests/cases/fourslash/findAllRefsForDefaultExport04.ts diff --git a/tests/cases/fourslash/findAllRefsForDefault05.ts b/tests/cases/fourslash/findAllRefsForDefaultExport05.ts similarity index 100% rename from tests/cases/fourslash/findAllRefsForDefault05.ts rename to tests/cases/fourslash/findAllRefsForDefaultExport05.ts diff --git a/tests/cases/fourslash/findAllRefsForDefault06.ts b/tests/cases/fourslash/findAllRefsForDefaultExport06.ts similarity index 100% rename from tests/cases/fourslash/findAllRefsForDefault06.ts rename to tests/cases/fourslash/findAllRefsForDefaultExport06.ts diff --git a/tests/cases/fourslash/findAllRefsForDefault07.ts b/tests/cases/fourslash/findAllRefsForDefaultExport07.ts similarity index 100% rename from tests/cases/fourslash/findAllRefsForDefault07.ts rename to tests/cases/fourslash/findAllRefsForDefaultExport07.ts diff --git a/tests/cases/fourslash/findAllRefsForDefault08.ts b/tests/cases/fourslash/findAllRefsForDefaultExport08.ts similarity index 100% rename from tests/cases/fourslash/findAllRefsForDefault08.ts rename to tests/cases/fourslash/findAllRefsForDefaultExport08.ts From 2539ebe29faba45accc9ca023231108e2d5dcd39 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 20 May 2015 15:39:35 -0700 Subject: [PATCH 060/309] Verify references count. --- tests/cases/fourslash/findAllRefsForDefaultExport01.ts | 1 + tests/cases/fourslash/findAllRefsForDefaultExport02.ts | 1 + tests/cases/fourslash/findAllRefsForDefaultExport03.ts | 1 + 3 files changed, 3 insertions(+) diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport01.ts b/tests/cases/fourslash/findAllRefsForDefaultExport01.ts index 87c439bd9ef..ca2f982302c 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport01.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport01.ts @@ -15,6 +15,7 @@ let ranges = test.ranges() for (let range of ranges) { goTo.position(range.start); + verify.referencesCountIs(ranges.length); for (let expectedReference of ranges) { verify.referencesAtPositionContains(expectedReference); } diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport02.ts b/tests/cases/fourslash/findAllRefsForDefaultExport02.ts index 3000b7de92d..1a0a92241f4 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport02.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport02.ts @@ -16,6 +16,7 @@ let ranges = test.ranges() for (let range of ranges) { goTo.position(range.start); + verify.referencesCountIs(ranges.length); for (let expectedReference of ranges) { verify.referencesAtPositionContains(expectedReference); } diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport03.ts b/tests/cases/fourslash/findAllRefsForDefaultExport03.ts index 89027879ff1..f753d17de49 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport03.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport03.ts @@ -18,6 +18,7 @@ let ranges = test.ranges() for (let range of ranges) { goTo.position(range.start); + verify.referencesCountIs(ranges.length); for (let expectedReference of ranges) { verify.referencesAtPositionContains(expectedReference); } From b9ddfcc0824c0fc6498f1245c092bc634be9c47a Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 May 2015 12:26:41 -0700 Subject: [PATCH 061/309] Spit out JSON when expected =/= actual. --- src/harness/fourslash.ts | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 6867863a941..938e486fee1 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -891,7 +891,7 @@ module FourSlash { } if (ranges.length !== references.length) { - this.raiseError(this.assertionMessage("Rename locations", references.length, ranges.length)); + this.raiseError("Rename location count does not match result.\n\nExpected: " + JSON.stringify(ranges) + "\n\nActual:" + JSON.stringify(references)); } ranges = ranges.sort((r1, r2) => r1.start - r2.start); @@ -904,9 +904,7 @@ module FourSlash { if (reference.textSpan.start !== range.start || ts.textSpanEnd(reference.textSpan) !== range.end) { - this.raiseError(this.assertionMessage("Rename location", - "[" + reference.textSpan.start + "," + ts.textSpanEnd(reference.textSpan) + ")", - "[" + range.start + "," + range.end + ")")); + this.raiseError("Rename location results do not match.\n\nExpected: " + JSON.stringify(ranges) + "\n\nActual:" + JSON.stringify(references)); } } } From ddb67e461a6a19f0bcbf03d2dc89091775488b5b Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 May 2015 12:28:02 -0700 Subject: [PATCH 062/309] Fixed tests. --- .../findAllRefsForDefaultExport01.ts | 4 ---- .../findAllRefsForDefaultExport02.ts | 4 ---- .../fourslash/renameForDefaultExport01.ts | 11 +++------- .../fourslash/renameForDefaultExport02.ts | 11 +++------- .../fourslash/renameForDefaultExport03.ts | 7 +++---- .../fourslash/renameForDefaultExport04.ts | 14 +++++++++++++ .../fourslash/renameForDefaultExport05.ts | 14 +++++++++++++ .../fourslash/renameForDefaultExport06.ts | 14 +++++++++++++ .../fourslash/renameForDefaultExport07.ts | 15 +++++++++++++ .../fourslash/renameForDefaultExport08.ts | 15 +++++++++++++ .../fourslash/renameForDefaultExport09.ts | 21 +++++++++++++++++++ 11 files changed, 102 insertions(+), 28 deletions(-) create mode 100644 tests/cases/fourslash/renameForDefaultExport04.ts create mode 100644 tests/cases/fourslash/renameForDefaultExport05.ts create mode 100644 tests/cases/fourslash/renameForDefaultExport06.ts create mode 100644 tests/cases/fourslash/renameForDefaultExport07.ts create mode 100644 tests/cases/fourslash/renameForDefaultExport08.ts create mode 100644 tests/cases/fourslash/renameForDefaultExport09.ts diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport01.ts b/tests/cases/fourslash/findAllRefsForDefaultExport01.ts index ca2f982302c..2f40af93c02 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport01.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport01.ts @@ -6,10 +6,6 @@ ////var x: [|DefaultExportedClass|]; //// ////var y = new [|DefaultExportedClass|]; -//// -////namespace [|DefaultExportedClass|] { -//// var local = 100; -////} let ranges = test.ranges() for (let range of ranges) { diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport02.ts b/tests/cases/fourslash/findAllRefsForDefaultExport02.ts index 1a0a92241f4..db773c74e3c 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport02.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport02.ts @@ -7,10 +7,6 @@ ////var x: typeof [|DefaultExportedFunction|]; //// ////var y = [|DefaultExportedFunction|](); -//// -////namespace [|DefaultExportedFunction|] { -//// var local = 100; -////} let ranges = test.ranges() for (let range of ranges) { diff --git a/tests/cases/fourslash/renameForDefaultExport01.ts b/tests/cases/fourslash/renameForDefaultExport01.ts index ec9c3900a5e..809c127a727 100644 --- a/tests/cases/fourslash/renameForDefaultExport01.ts +++ b/tests/cases/fourslash/renameForDefaultExport01.ts @@ -1,23 +1,18 @@ /// -/////** -//// * Commenting [|DefaultExportedClass|] -//// */ ////export default class /*1*/[|DefaultExportedClass|] { ////} +/////* +//// * Commenting [|DefaultExportedClass|] +//// */ //// ////var x: /*2*/[|DefaultExportedClass|]; //// ////var y = new /*3*/[|DefaultExportedClass|]; -//// -////namespace /*4*/[|DefaultExportedClass|] { -//// var local = 100; -////} let markers = test.markers() for (let marker of markers) { goTo.position(marker.position); verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); - verify.renameInfoSucceeded("DefaultExportedClass"); } \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport02.ts b/tests/cases/fourslash/renameForDefaultExport02.ts index eea63282f5f..ddf4b224023 100644 --- a/tests/cases/fourslash/renameForDefaultExport02.ts +++ b/tests/cases/fourslash/renameForDefaultExport02.ts @@ -1,24 +1,19 @@ /// -/////** -//// * Commenting [|DefaultExportedFunction|] -//// */ ////export default function /*1*/[|DefaultExportedFunction|]() { //// return /*2*/[|DefaultExportedFunction|] ////} +/////** +//// * Commenting [|DefaultExportedFunction|] +//// */ //// ////var x: typeof /*3*/[|DefaultExportedFunction|]; //// ////var y = /*4*/[|DefaultExportedFunction|](); -//// -////namespace /*5*/[|DefaultExportedFunction|] { -//// var local = 100; -////} let markers = test.markers() for (let marker of markers) { goTo.position(marker.position); verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); - verify.renameInfoSucceeded("DefaultExportedFunction"); } \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport03.ts b/tests/cases/fourslash/renameForDefaultExport03.ts index b36b04768ab..6f82d96fe5e 100644 --- a/tests/cases/fourslash/renameForDefaultExport03.ts +++ b/tests/cases/fourslash/renameForDefaultExport03.ts @@ -1,8 +1,5 @@ /// -/////** -//// * Commenting [|f|] -//// */ ////function /*1*/[|f|]() { //// return 100; ////} @@ -13,6 +10,9 @@ //// ////var y = /*4*/[|f|](); //// +/////** +//// * Commenting [|f|] +//// */ ////namespace /*5*/[|f|] { //// var local = 100; ////} @@ -22,5 +22,4 @@ for (let marker of markers) { goTo.position(marker.position); verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); - verify.renameInfoSucceeded("f"); } \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport04.ts b/tests/cases/fourslash/renameForDefaultExport04.ts new file mode 100644 index 00000000000..44dd764682f --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport04.ts @@ -0,0 +1,14 @@ +/// + +////export default class /**/[|DefaultExportedClass|] { +////} +/////* +//// * Commenting DefaultExportedClass +//// */ +//// +////var x: DefaultExportedClass; +//// +////var y = new DefaultExportedClass; + +goTo.marker(); +verify.renameInfoSucceeded("DefaultExportedClass", "DefaultExportedClass"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport05.ts b/tests/cases/fourslash/renameForDefaultExport05.ts new file mode 100644 index 00000000000..926fa5dd6fd --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport05.ts @@ -0,0 +1,14 @@ +/// + +////export default class DefaultExportedClass { +////} +/////* +//// * Commenting DefaultExportedClass +//// */ +//// +////var x: /**/[|DefaultExportedClass|]; +//// +////var y = new DefaultExportedClass; + +goTo.marker(); +verify.renameInfoSucceeded("DefaultExportedClass", "DefaultExportedClass"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport06.ts b/tests/cases/fourslash/renameForDefaultExport06.ts new file mode 100644 index 00000000000..da3ca8d92a4 --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport06.ts @@ -0,0 +1,14 @@ +/// + +////export default class DefaultExportedClass { +////} +/////* +//// * Commenting DefaultExportedClass +//// */ +//// +////var x: DefaultExportedClass; +//// +////var y = new /**/[|DefaultExportedClass|]; + +goTo.marker(); +verify.renameInfoSucceeded("DefaultExportedClass", "DefaultExportedClass"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport07.ts b/tests/cases/fourslash/renameForDefaultExport07.ts new file mode 100644 index 00000000000..9b1010580bf --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport07.ts @@ -0,0 +1,15 @@ +/// + +////export default function /**/[|DefaultExportedFunction|]() { +//// return DefaultExportedFunction +////} +/////** +//// * Commenting DefaultExportedFunction +//// */ +//// +////var x: typeof DefaultExportedFunction; +//// +////var y = DefaultExportedFunction(); + +goTo.marker(); +verify.renameInfoSucceeded("DefaultExportedFunction", "DefaultExportedFunction"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport08.ts b/tests/cases/fourslash/renameForDefaultExport08.ts new file mode 100644 index 00000000000..033b20516be --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport08.ts @@ -0,0 +1,15 @@ +/// + +////export default function DefaultExportedFunction() { +//// return /**/[|DefaultExportedFunction|] +////} +/////** +//// * Commenting DefaultExportedFunction +//// */ +//// +////var x: typeof DefaultExportedFunction; +//// +////var y = DefaultExportedFunction(); + +goTo.marker(); +verify.renameInfoSucceeded("DefaultExportedFunction", "DefaultExportedFunction"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport09.ts b/tests/cases/fourslash/renameForDefaultExport09.ts new file mode 100644 index 00000000000..568eb18a84e --- /dev/null +++ b/tests/cases/fourslash/renameForDefaultExport09.ts @@ -0,0 +1,21 @@ +/// + +////function /**/[|f|]() { +//// return 100; +////} +//// +////export default f; +//// +////var x: typeof f; +//// +////var y = f(); +//// +/////** +//// * Commenting f +//// */ +////namespace f { +//// var local = 100; +////} + +goTo.marker(); +verify.renameInfoSucceeded("f", "f"); \ No newline at end of file From 2c4bb5717c8e4a8a0868281465b9cff62c6966ef Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 May 2015 12:29:09 -0700 Subject: [PATCH 063/309] Find the references themselves. --- src/services/services.ts | 40 +++++++++++++++++++--------------------- 1 file changed, 19 insertions(+), 21 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 1b5ba6752de..d99f3bacfc8 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4915,20 +4915,25 @@ module ts { return undefined; } + let declarations = symbol.declarations; - // The symbol was an internal symbol and does not have a declaration e.g.undefined symbol + // The symbol was an internal symbol and does not have a declaration e.g. undefined symbol if (!declarations || !declarations.length) { return undefined; } + // Try to get the local symbol if we're dealing with an 'export default' + // since that symbol has the "true" name and we need to account for other declarations. + let localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol); + let result: ReferencedSymbol[]; // Compute the meaning from the location and the symbol it references let searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations); - // Get the text to search for, we need to normalize it as external module names will have quote - let declaredName = getDeclaredName(symbol, node); + // Get the text to search for, we need to normalize it as external module names will have quotes + let declaredName = getDeclaredName(localExportDefaultSymbol || symbol, node); // Try to get the smallest valid scope that we can limit our search to; // otherwise we'll need to search globally (i.e. include each file). @@ -4942,7 +4947,7 @@ module ts { getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex); } else { - let internedName = getInternedName(symbol, node, declarations) + let internedName = getInternedName(localExportDefaultSymbol || symbol, node, declarations) for (let sourceFile of sourceFiles) { cancellationToken.throwIfCancellationRequested(); @@ -4988,9 +4993,8 @@ module ts { } function getDeclaredName(symbol: Symbol, location: Node) { - // If this is an export or import specifier it could have been renamed using the as syntax. - // if so we want to search for whatever under the cursor, the symbol is pointing to the alias (name) - // so check for the propertyName. + // If this is an export or import specifier it could have been renamed using the 'as' syntax. + // If so we want to search for whatever is under the cursor. if (isImportOrExportSpecifierName(location)) { return location.getText(); } @@ -5000,10 +5004,9 @@ module ts { return stripQuotes(name); } - function getInternedName(symbol: Symbol, location: Node, declarations: Declaration[]): string { - // If this is an export or import specifier it could have been renamed using the as syntax. - // if so we want to search for whatever under the cursor, the symbol is pointing to the alias (name) - // so check for the propertyName. + function getInternedName(symbol: Symbol, location: Node, declarations: Declaration[]) { + // If this is an export or import specifier it could have been renamed using the 'as' syntax. + // If so we want to search for whatever under the cursor. if (isImportOrExportSpecifierName(location)) { return location.getText(); } @@ -5014,18 +5017,13 @@ module ts { let functionExpression: FunctionExpression; if (symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.FunctionExpression) { functionExpression = symbol.valueDeclaration; + + if (functionExpression.name) { + return functionExpression.name.text; + } } - // When a name gets interned into a SourceFile's 'identifiers' Map, - // its name is escaped and stored in the same way its symbol name/identifier - // name should be stored. Function expressions, however, are a special case, - // because despite sometimes having a name, the binder unconditionally binds them - // to a symbol with the name "__function". - let name = functionExpression && functionExpression.name - ? functionExpression.name.text - : symbol.name; - - return stripQuotes(name); + return stripQuotes(symbol.name); } function stripQuotes(name: string) { From 33693e87ddf037fbbdfcfb56bb204d1c0a5ae895 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 May 2015 12:43:58 -0700 Subject: [PATCH 064/309] Adjust expectations. --- tests/cases/fourslash/renameForDefaultExport04.ts | 2 +- tests/cases/fourslash/renameForDefaultExport05.ts | 2 +- tests/cases/fourslash/renameForDefaultExport06.ts | 2 +- tests/cases/fourslash/renameForDefaultExport07.ts | 2 +- tests/cases/fourslash/renameForDefaultExport08.ts | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/cases/fourslash/renameForDefaultExport04.ts b/tests/cases/fourslash/renameForDefaultExport04.ts index 44dd764682f..8c4e2733e33 100644 --- a/tests/cases/fourslash/renameForDefaultExport04.ts +++ b/tests/cases/fourslash/renameForDefaultExport04.ts @@ -11,4 +11,4 @@ ////var y = new DefaultExportedClass; goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedClass", "DefaultExportedClass"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedClass"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport05.ts b/tests/cases/fourslash/renameForDefaultExport05.ts index 926fa5dd6fd..f6c87d936da 100644 --- a/tests/cases/fourslash/renameForDefaultExport05.ts +++ b/tests/cases/fourslash/renameForDefaultExport05.ts @@ -11,4 +11,4 @@ ////var y = new DefaultExportedClass; goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedClass", "DefaultExportedClass"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedClass"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport06.ts b/tests/cases/fourslash/renameForDefaultExport06.ts index da3ca8d92a4..083fd29054a 100644 --- a/tests/cases/fourslash/renameForDefaultExport06.ts +++ b/tests/cases/fourslash/renameForDefaultExport06.ts @@ -11,4 +11,4 @@ ////var y = new /**/[|DefaultExportedClass|]; goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedClass", "DefaultExportedClass"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedClass"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport07.ts b/tests/cases/fourslash/renameForDefaultExport07.ts index 9b1010580bf..2c718a1202b 100644 --- a/tests/cases/fourslash/renameForDefaultExport07.ts +++ b/tests/cases/fourslash/renameForDefaultExport07.ts @@ -12,4 +12,4 @@ ////var y = DefaultExportedFunction(); goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedFunction", "DefaultExportedFunction"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedFunction"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport08.ts b/tests/cases/fourslash/renameForDefaultExport08.ts index 033b20516be..29064180d58 100644 --- a/tests/cases/fourslash/renameForDefaultExport08.ts +++ b/tests/cases/fourslash/renameForDefaultExport08.ts @@ -12,4 +12,4 @@ ////var y = DefaultExportedFunction(); goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedFunction", "DefaultExportedFunction"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedFunction"); \ No newline at end of file From 6f925acacbf50c491fc55b81dff7aa177852a2f2 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 May 2015 12:50:22 -0700 Subject: [PATCH 065/309] Add rename tests for function expressions. --- .../fourslash/renameInfoForFunctionExpression01.ts | 8 ++++++++ .../renameLocationsForFunctionExpression01.ts | 12 ++++++++++++ 2 files changed, 20 insertions(+) create mode 100644 tests/cases/fourslash/renameInfoForFunctionExpression01.ts create mode 100644 tests/cases/fourslash/renameLocationsForFunctionExpression01.ts diff --git a/tests/cases/fourslash/renameInfoForFunctionExpression01.ts b/tests/cases/fourslash/renameInfoForFunctionExpression01.ts new file mode 100644 index 00000000000..807c4541f3f --- /dev/null +++ b/tests/cases/fourslash/renameInfoForFunctionExpression01.ts @@ -0,0 +1,8 @@ +/// + +////var x = function /**/[|f|](g: any, h: any) { +//// f(f, g); +////} + +goTo.marker(); +verify.renameInfoSucceeded("f"); \ No newline at end of file diff --git a/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts b/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts new file mode 100644 index 00000000000..b2f54853c7b --- /dev/null +++ b/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts @@ -0,0 +1,12 @@ +/// + +////var x = function /*1*/[|f|](g: any, h: any) { +//// /*2*/[|f|](/*3*/[|f|], g); +////} + +let markers = test.markers() +for (let marker of markers) { + goTo.position(marker.position); + + verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); +} \ No newline at end of file From 934a3bfc6d53b986ca8434fbb2001a3bfc4fffaf Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 May 2015 12:52:00 -0700 Subject: [PATCH 066/309] Fixed 'displayName'. --- src/services/services.ts | 43 ++++++++------------------------------- src/services/utilities.ts | 30 +++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 34 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index d99f3bacfc8..0865c68db64 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4915,7 +4915,6 @@ module ts { return undefined; } - let declarations = symbol.declarations; // The symbol was an internal symbol and does not have a declaration e.g. undefined symbol @@ -4923,17 +4922,13 @@ module ts { return undefined; } - // Try to get the local symbol if we're dealing with an 'export default' - // since that symbol has the "true" name and we need to account for other declarations. - let localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol); - let result: ReferencedSymbol[]; // Compute the meaning from the location and the symbol it references let searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations); // Get the text to search for, we need to normalize it as external module names will have quotes - let declaredName = getDeclaredName(localExportDefaultSymbol || symbol, node); + let declaredName = getDeclaredName(typeChecker, symbol, node); // Try to get the smallest valid scope that we can limit our search to; // otherwise we'll need to search globally (i.e. include each file). @@ -4947,7 +4942,7 @@ module ts { getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex); } else { - let internedName = getInternedName(localExportDefaultSymbol || symbol, node, declarations) + let internedName = getInternedName(symbol, node, declarations) for (let sourceFile of sourceFiles) { cancellationToken.throwIfCancellationRequested(); @@ -4980,30 +4975,12 @@ module ts { }; } - function isImportOrExportSpecifierName(location: Node): boolean { - return location.parent && - (location.parent.kind === SyntaxKind.ImportSpecifier || location.parent.kind === SyntaxKind.ExportSpecifier) && - (location.parent).propertyName === location; - } - function isImportOrExportSpecifierImportSymbol(symbol: Symbol) { return (symbol.flags & SymbolFlags.Alias) && forEach(symbol.declarations, declaration => { return declaration.kind === SyntaxKind.ImportSpecifier || declaration.kind === SyntaxKind.ExportSpecifier; }); } - function getDeclaredName(symbol: Symbol, location: Node) { - // If this is an export or import specifier it could have been renamed using the 'as' syntax. - // If so we want to search for whatever is under the cursor. - if (isImportOrExportSpecifierName(location)) { - return location.getText(); - } - - let name = typeChecker.symbolToString(symbol); - - return stripQuotes(name); - } - function getInternedName(symbol: Symbol, location: Node, declarations: Declaration[]) { // If this is an export or import specifier it could have been renamed using the 'as' syntax. // If so we want to search for whatever under the cursor. @@ -5023,15 +5000,12 @@ module ts { } } - return stripQuotes(symbol.name); - } + // Try to get the local symbol if we're dealing with an 'export default' + // since that symbol has the "true" name. + let localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol); + symbol = localExportDefaultSymbol || symbol; - function stripQuotes(name: string) { - let length = name.length; - if (length >= 2 && name.charCodeAt(0) === CharacterCodes.doubleQuote && name.charCodeAt(length - 1) === CharacterCodes.doubleQuote) { - return name.substring(1, length - 1); - }; - return name; + return stripQuotes(symbol.name); } function getSymbolScope(symbol: Symbol): Node { @@ -6647,12 +6621,13 @@ module ts { } } + let displayName = getDeclaredName(typeChecker, symbol, node); let kind = getSymbolKind(symbol, node); if (kind) { return { canRename: true, localizedErrorMessage: undefined, - displayName: symbol.name, + displayName, fullDisplayName: typeChecker.getFullyQualifiedName(symbol), kind: kind, kindModifiers: getSymbolModifiers(symbol), diff --git a/src/services/utilities.ts b/src/services/utilities.ts index da0a0aa96c1..e1cbf609c86 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -652,4 +652,34 @@ module ts { typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); }); } + + export function getDeclaredName(typeChecker: TypeChecker, symbol: Symbol, location: Node) { + // If this is an export or import specifier it could have been renamed using the 'as' syntax. + // If so we want to search for whatever is under the cursor. + if (isImportOrExportSpecifierName(location)) { + return location.getText(); + } + + // Try to get the local symbol if we're dealing with an 'export default' + // since that symbol has the "true" name. + let localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol); + + let name = typeChecker.symbolToString(localExportDefaultSymbol || symbol); + + return stripQuotes(name); + } + + export function isImportOrExportSpecifierName(location: Node): boolean { + return location.parent && + (location.parent.kind === SyntaxKind.ImportSpecifier || location.parent.kind === SyntaxKind.ExportSpecifier) && + (location.parent).propertyName === location; + } + + export function stripQuotes(name: string) { + let length = name.length; + if (length >= 2 && name.charCodeAt(0) === CharacterCodes.doubleQuote && name.charCodeAt(length - 1) === CharacterCodes.doubleQuote) { + return name.substring(1, length - 1); + }; + return name; + } } \ No newline at end of file From 035962bee16a68876acb5ba0e9df65dc6d428ffc Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 28 May 2015 11:47:12 -0700 Subject: [PATCH 067/309] Added test for find all refs of function expressions. --- .../findAllRefsForFunctionExpression01.ts | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 tests/cases/fourslash/findAllRefsForFunctionExpression01.ts diff --git a/tests/cases/fourslash/findAllRefsForFunctionExpression01.ts b/tests/cases/fourslash/findAllRefsForFunctionExpression01.ts new file mode 100644 index 00000000000..a312a277ebb --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForFunctionExpression01.ts @@ -0,0 +1,21 @@ +/// + +// @Filename: file1.ts +////var foo = function [|foo|](a = [|foo|](), b = () => [|foo|]) { +//// [|foo|]([|foo|], [|foo|]); +////} + +// @Filename: file2.ts +/////// +////foo(); + + +let ranges = test.ranges() +for (let range of ranges) { + goTo.position(range.start); + + verify.referencesCountIs(ranges.length); + for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); + } +} \ No newline at end of file From bca3d014fd65703db6d2ec094d9a81a45534c979 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 28 May 2015 12:10:18 -0700 Subject: [PATCH 068/309] Limit scope of function expressions to themselves. --- src/compiler/types.ts | 4 ++-- src/services/services.ts | 25 +++++++++++++------------ 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 296e75c4b76..0fda2989e1a 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1582,10 +1582,10 @@ module ts { Tuple = 0x00002000, // Tuple Union = 0x00004000, // Union Anonymous = 0x00008000, // Anonymous - /* @internal */ + /* @internal */ FromSignature = 0x00010000, // Created for signature assignment check ObjectLiteral = 0x00020000, // Originates in an object literal - /* @internal */ + /* @internal */ ContainsUndefinedOrNull = 0x00040000, // Type is or contains Undefined or Null type /* @internal */ ContainsObjectLiteral = 0x00080000, // Type is or contains object literal type diff --git a/src/services/services.ts b/src/services/services.ts index 0865c68db64..691aebf6cc3 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4988,18 +4988,6 @@ module ts { return location.getText(); } - // Special case for function expressions, whose names are solely local to their bodies. - // TODO (drosen): Why would we have to lookup the interned name for a function expression? - // Shouldn't we have found a scope? Consider a 'Debug.fail()'. - let functionExpression: FunctionExpression; - if (symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.FunctionExpression) { - functionExpression = symbol.valueDeclaration; - - if (functionExpression.name) { - return functionExpression.name.text; - } - } - // Try to get the local symbol if we're dealing with an 'export default' // since that symbol has the "true" name. let localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol); @@ -5008,7 +4996,20 @@ module ts { return stripQuotes(symbol.name); } + /** + * Determines the smallest scope in which a symbol may have named references. + * + * Returns undefined if the scope cannot be determined, often implying that + * a reference to a symbol can occur anywhere. + */ function getSymbolScope(symbol: Symbol): Node { + // If this is the symbol of a function expression, then named references + // are limited to its own scope. + let valueDeclaration = symbol.valueDeclaration; + if (valueDeclaration && valueDeclaration.kind === SyntaxKind.FunctionExpression) { + return valueDeclaration; + } + // If this is private property or method, the scope is the containing class if (symbol.flags & (SymbolFlags.Property | SymbolFlags.Method)) { let privateDeclaration = forEach(symbol.getDeclarations(), d => (d.flags & NodeFlags.Private) ? d : undefined); From 6a7ce44aadff783151d3e8a12b1cf95a1a61077f Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 29 May 2015 14:37:51 -0700 Subject: [PATCH 069/309] a deer, a female deer -> does --- src/harness/fourslash.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 938e486fee1..cbbd1d37e63 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -743,7 +743,7 @@ module FourSlash { var reference = references[i]; if (reference && reference.fileName === fileName && reference.textSpan.start === start && ts.textSpanEnd(reference.textSpan) === end) { if (typeof isWriteAccess !== "undefined" && reference.isWriteAccess !== isWriteAccess) { - this.raiseError('verifyReferencesAtPositionListContains failed - item isWriteAccess value doe not match, actual: ' + reference.isWriteAccess + ', expected: ' + isWriteAccess + '.'); + this.raiseError('verifyReferencesAtPositionListContains failed - item isWriteAccess value does not match, actual: ' + reference.isWriteAccess + ', expected: ' + isWriteAccess + '.'); } return; } From 2b899f129a27e9bbd97de703f09315463f5cadbb Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 3 Jun 2015 14:05:18 -0700 Subject: [PATCH 070/309] simplified check --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index ecf22938201..6a45dacb32a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10416,7 +10416,7 @@ module ts { } // Non-ambient classes cannot merge with interfaces. - if (!(node.flags & NodeFlags.Ambient) && getDeclarationOfKind(symbol, SyntaxKind.InterfaceDeclaration)) { + if (!(node.flags & NodeFlags.Ambient) && symbol.flags & SymbolFlags.Interface) { error(node, Diagnostics.A_non_ambient_class_cannot_be_merged_with_an_interface) } From 29c9286cbc35d0a0a46e8cb149e8a141032d0b96 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 3 Jun 2015 14:11:13 -0700 Subject: [PATCH 071/309] Updated error message --- src/compiler/checker.ts | 5 +++-- src/compiler/diagnosticInformationMap.generated.ts | 3 +-- src/compiler/diagnosticMessages.json | 6 +----- 3 files changed, 5 insertions(+), 9 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6a45dacb32a..b0b6521e230 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10417,7 +10417,7 @@ module ts { // Non-ambient classes cannot merge with interfaces. if (!(node.flags & NodeFlags.Ambient) && symbol.flags & SymbolFlags.Interface) { - error(node, Diagnostics.A_non_ambient_class_cannot_be_merged_with_an_interface) + error(node, Diagnostics.Only_an_ambient_class_can_be_merged_with_an_interface) } forEach(node.members, checkSourceElement); @@ -10600,10 +10600,11 @@ module ts { } } + // Interfaces cannot merge with non-ambient classes. if (symbol && symbol.declarations) { for (let declaration of symbol.declarations) { if (declaration.kind === SyntaxKind.ClassDeclaration && !(declaration.flags & NodeFlags.Ambient)) { - error(node, Diagnostics.An_interface_cannot_merge_with_a_non_ambient_class); + error(node, Diagnostics.Only_an_ambient_class_can_be_merged_with_an_interface); break; } } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 358dea6e988..e327a516311 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -372,8 +372,7 @@ module ts { Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, No_best_common_type_exists_among_yield_expressions: { code: 2504, category: DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, - A_non_ambient_class_cannot_be_merged_with_an_interface: { code: 2506, category: DiagnosticCategory.Error, key: "A non-ambient class cannot be merged with an interface." }, - An_interface_cannot_merge_with_a_non_ambient_class: { code: 2507, category: DiagnosticCategory.Error, key: "An interface cannot merge with a non-ambient class." }, + Only_an_ambient_class_can_be_merged_with_an_interface: { code: 2506, category: DiagnosticCategory.Error, key: "Only an ambient class can be merged with an interface." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 8f3973fbdb8..871fb2d9ea8 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1476,14 +1476,10 @@ "category": "Error", "code": 2505 }, - "A non-ambient class cannot be merged with an interface.": { + "Only an ambient class can be merged with an interface.": { "category": "Error", "code": 2506 }, - "An interface cannot merge with a non-ambient class.": { - "category": "Error", - "code": 2507 - }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 From d000e0164b8b3bb548d1a1451057c0e83d6a1622 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 3 Jun 2015 14:17:29 -0700 Subject: [PATCH 072/309] updated baselines to reflect new error message --- .../reference/augmentedTypesClass2.errors.txt | 8 ++--- .../augmentedTypesInterface.errors.txt | 8 ++--- .../classAndInterfaceMerge.d.errors.txt | 24 +++++++------- .../classAndInterfaceWithSameName.errors.txt | 16 +++++----- .../reference/clinterfaces.errors.txt | 32 +++++++++---------- .../baselines/reference/declInput.errors.txt | 8 ++--- ...ifiersAcrossContainerBoundaries.errors.txt | 8 ++--- ...IdentifiersAcrossFileBoundaries.errors.txt | 16 +++++----- .../interfaceDeclaration2.errors.txt | 8 ++--- .../reference/mergedClassInterface.errors.txt | 16 +++++----- .../reference/nameCollisions.errors.txt | 16 +++++----- ...tringsArrayTypeDefinedInES5Mode.errors.txt | 6 ++-- ...ingsArrayTypeRedefinedInES6Mode.errors.txt | 6 ++-- 13 files changed, 86 insertions(+), 86 deletions(-) diff --git a/tests/baselines/reference/augmentedTypesClass2.errors.txt b/tests/baselines/reference/augmentedTypesClass2.errors.txt index 2622429d743..9d0b7b25c34 100644 --- a/tests/baselines/reference/augmentedTypesClass2.errors.txt +++ b/tests/baselines/reference/augmentedTypesClass2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/augmentedTypesClass2.ts(4,7): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/compiler/augmentedTypesClass2.ts(10,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/augmentedTypesClass2.ts(4,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesClass2.ts(10,11): error TS2506: Only an ambient class can be merged with an interface. tests/cases/compiler/augmentedTypesClass2.ts(16,7): error TS2300: Duplicate identifier 'c33'. tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate identifier 'c33'. @@ -10,7 +10,7 @@ tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate iden // class then interface class c11 { // error ~~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. foo() { return 1; } @@ -18,7 +18,7 @@ tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate iden interface c11 { // error ~~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. bar(): void; } diff --git a/tests/baselines/reference/augmentedTypesInterface.errors.txt b/tests/baselines/reference/augmentedTypesInterface.errors.txt index 9719539b344..8ee7dc4e1e8 100644 --- a/tests/baselines/reference/augmentedTypesInterface.errors.txt +++ b/tests/baselines/reference/augmentedTypesInterface.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/augmentedTypesInterface.ts(12,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/augmentedTypesInterface.ts(16,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/augmentedTypesInterface.ts(12,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesInterface.ts(16,7): error TS2506: Only an ambient class can be merged with an interface. tests/cases/compiler/augmentedTypesInterface.ts(23,11): error TS2300: Duplicate identifier 'i3'. tests/cases/compiler/augmentedTypesInterface.ts(26,6): error TS2300: Duplicate identifier 'i3'. @@ -18,13 +18,13 @@ tests/cases/compiler/augmentedTypesInterface.ts(26,6): error TS2300: Duplicate i // interface then class interface i2 { // error ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. foo(): void; } class i2 { // error ~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. bar() { return 1; } diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt b/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt index d73e5fcb2f0..fa0d239cdc7 100644 --- a/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt +++ b/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(12,15): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(14,11): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(16,15): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(18,15): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(20,18): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(24,22): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(12,15): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(14,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(16,15): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(18,15): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(20,18): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(24,22): error TS2506: Only an ambient class can be merged with an interface. ==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts (6 errors) ==== @@ -20,27 +20,27 @@ tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(24 interface C1 { } ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. class C1 { } ~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. interface C1 { } ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. interface C1 { } ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. export class C2 { } ~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. } declare module M { export interface C2 { } ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. } \ No newline at end of file diff --git a/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt b/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt index 6bf95880ceb..170ff29226b 100644 --- a/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt +++ b/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt @@ -1,29 +1,29 @@ -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,7): error TS2506: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,11): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,11): error TS2506: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,15): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(5,11): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(5,11): error TS2506: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(6,9): error TS2300: Duplicate identifier 'bar'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(9,15): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(9,15): error TS2506: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(10,9): error TS2300: Duplicate identifier 'bar'. ==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts (8 errors) ==== class C { foo: string; } ~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. ~~~ !!! error TS2300: Duplicate identifier 'foo'. interface C { foo: string; } // error ~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. ~~~ !!! error TS2300: Duplicate identifier 'foo'. module M { class D { ~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. bar: string; ~~~ !!! error TS2300: Duplicate identifier 'bar'. @@ -31,7 +31,7 @@ tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName. interface D { // error ~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. bar: string; ~~~ !!! error TS2300: Duplicate identifier 'bar'. diff --git a/tests/baselines/reference/clinterfaces.errors.txt b/tests/baselines/reference/clinterfaces.errors.txt index 6e172fa0d96..1d5ecd136f0 100644 --- a/tests/baselines/reference/clinterfaces.errors.txt +++ b/tests/baselines/reference/clinterfaces.errors.txt @@ -1,50 +1,50 @@ -tests/cases/compiler/clinterfaces.ts(2,11): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/compiler/clinterfaces.ts(3,15): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/clinterfaces.ts(4,15): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/clinterfaces.ts(5,11): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/compiler/clinterfaces.ts(8,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/clinterfaces.ts(12,7): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/compiler/clinterfaces.ts(16,7): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/compiler/clinterfaces.ts(20,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/clinterfaces.ts(2,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(3,15): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(4,15): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(5,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(8,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(12,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(16,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(20,11): error TS2506: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/clinterfaces.ts (8 errors) ==== module M { class C { } ~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. interface C { } ~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. interface D { } ~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. class D { } ~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. } interface Foo { ~~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. a: string; } class Foo{ ~~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. b: number; } class Bar{ ~~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. b: number; } interface Bar { ~~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. a: string; } diff --git a/tests/baselines/reference/declInput.errors.txt b/tests/baselines/reference/declInput.errors.txt index 313866cf93d..4e12c802bee 100644 --- a/tests/baselines/reference/declInput.errors.txt +++ b/tests/baselines/reference/declInput.errors.txt @@ -1,17 +1,17 @@ -tests/cases/compiler/declInput.ts(1,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/declInput.ts(5,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/declInput.ts(1,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/declInput.ts(5,7): error TS2506: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/declInput.ts (2 errors) ==== interface bar { ~~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. } class bar { ~~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. public f() { return ''; } public g() { return {a: null, b: undefined, c: void 4 }; } public h(x = 4, y = null, z = '') { x++; } diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt index 77a7f4ffb35..f8b5c559515 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(2,22): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(5,18): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(2,22): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(5,18): error TS2506: Only an ambient class can be merged with an interface. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(9,21): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(12,18): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(37,12): error TS2300: Duplicate identifier 'x'. @@ -10,12 +10,12 @@ tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(41,16): er module M { export interface I { } ~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. } module M { export class I { } // error ~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. } module M { diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt index bd223330669..dcb2440aa26 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt @@ -1,10 +1,10 @@ -tests/cases/compiler/file1.ts(2,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/file1.ts(3,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/file1.ts(2,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/file1.ts(3,7): error TS2506: Only an ambient class can be merged with an interface. tests/cases/compiler/file1.ts(4,7): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/file1.ts(5,10): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/file1.ts(9,12): error TS2300: Duplicate identifier 'x'. -tests/cases/compiler/file2.ts(1,7): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/compiler/file2.ts(2,11): error TS2507: An interface cannot merge with a non-ambient class. +tests/cases/compiler/file2.ts(1,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/file2.ts(2,11): error TS2506: Only an ambient class can be merged with an interface. tests/cases/compiler/file2.ts(3,10): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/file2.ts(4,7): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/file2.ts(7,8): error TS2433: A namespace declaration cannot be in a different file from a class or function with which it is merged @@ -15,10 +15,10 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. interface I { } ~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. class C1 { } ~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. class C2 { } ~~ !!! error TS2300: Duplicate identifier 'C2'. @@ -42,10 +42,10 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. ==== tests/cases/compiler/file2.ts (6 errors) ==== class I { } // error -- cannot merge interface with non-ambient class ~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. interface C1 { } // error -- cannot merge interface with non-ambient class ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. function C2() { } // error -- cannot merge function with non-ambient class ~~ !!! error TS2300: Duplicate identifier 'C2'. diff --git a/tests/baselines/reference/interfaceDeclaration2.errors.txt b/tests/baselines/reference/interfaceDeclaration2.errors.txt index 06a0e247301..2789657a202 100644 --- a/tests/baselines/reference/interfaceDeclaration2.errors.txt +++ b/tests/baselines/reference/interfaceDeclaration2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/interfaceDeclaration2.ts(4,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/interfaceDeclaration2.ts(4,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2506: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/interfaceDeclaration2.ts (2 errors) ==== @@ -8,10 +8,10 @@ tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2506: A non-ambient interface I2 { } ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. class I2 { } ~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. interface I3 { } function I3() { } diff --git a/tests/baselines/reference/mergedClassInterface.errors.txt b/tests/baselines/reference/mergedClassInterface.errors.txt index 42f0a14b8ef..6177b5fa871 100644 --- a/tests/baselines/reference/mergedClassInterface.errors.txt +++ b/tests/baselines/reference/mergedClassInterface.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/classes/classDeclarations/file1.ts(11,7): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/conformance/classes/classDeclarations/file1.ts(13,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/conformance/classes/classDeclarations/file1.ts(15,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(11,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(13,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(15,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2506: Only an ambient class can be merged with an interface. ==== tests/cases/conformance/classes/classDeclarations/file1.ts (4 errors) ==== @@ -17,19 +17,19 @@ tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2506: class C3 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. interface C3 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. interface C4 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. class C4 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. interface C5 { x1: number; diff --git a/tests/baselines/reference/nameCollisions.errors.txt b/tests/baselines/reference/nameCollisions.errors.txt index d570d9e1278..bc7ec752573 100644 --- a/tests/baselines/reference/nameCollisions.errors.txt +++ b/tests/baselines/reference/nameCollisions.errors.txt @@ -11,10 +11,10 @@ tests/cases/compiler/nameCollisions.ts(33,11): error TS2300: Duplicate identifie tests/cases/compiler/nameCollisions.ts(34,14): error TS2300: Duplicate identifier 'C'. tests/cases/compiler/nameCollisions.ts(36,14): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/nameCollisions.ts(37,11): error TS2300: Duplicate identifier 'C2'. -tests/cases/compiler/nameCollisions.ts(42,11): error TS2506: A non-ambient class cannot be merged with an interface. -tests/cases/compiler/nameCollisions.ts(43,15): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/nameCollisions.ts(45,15): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/nameCollisions.ts(46,11): error TS2506: A non-ambient class cannot be merged with an interface. +tests/cases/compiler/nameCollisions.ts(42,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(43,15): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(45,15): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(46,11): error TS2506: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/nameCollisions.ts (17 errors) ==== @@ -87,15 +87,15 @@ tests/cases/compiler/nameCollisions.ts(46,11): error TS2506: A non-ambient class class cli { } ~~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. interface cli { } // error ~~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. interface cli2 { } ~~~~ -!!! error TS2507: An interface cannot merge with a non-ambient class. +!!! error TS2506: Only an ambient class can be merged with an interface. class cli2 { } // error ~~~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. } \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt index 9d6da3ec4b4..aabebad0552 100644 --- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt @@ -1,5 +1,5 @@ -lib.d.ts(521,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(2,7): error TS2506: A non-ambient class cannot be merged with an interface. +lib.d.ts(521,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(2,7): error TS2506: Only an ambient class can be merged with an interface. tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. @@ -8,7 +8,7 @@ tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2 class TemplateStringsArray { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. } function f(x: TemplateStringsArray, y: number, z: number) { diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt index ffb619cedc7..8b1c5fbe0e2 100644 --- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt @@ -1,5 +1,5 @@ -lib.d.ts(521,11): error TS2507: An interface cannot merge with a non-ambient class. -tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(2,7): error TS2506: A non-ambient class cannot be merged with an interface. +lib.d.ts(521,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(2,7): error TS2506: Only an ambient class can be merged with an interface. tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. @@ -8,7 +8,7 @@ tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error T class TemplateStringsArray { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2506: A non-ambient class cannot be merged with an interface. +!!! error TS2506: Only an ambient class can be merged with an interface. } function f(x: TemplateStringsArray, y: number, z: number) { From 143890b1174058bee05f54e22303ef8b19da77d8 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 3 Jun 2015 14:22:39 -0700 Subject: [PATCH 073/309] New test --- .../mergeClassInterfaceAndModule.ts | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts diff --git a/tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts b/tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts new file mode 100644 index 00000000000..4dc733d28c0 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts @@ -0,0 +1,16 @@ + +interface C1 {} +declare class C1 {} +module C1 {} + +declare class C2 {} +interface C2 {} +module C2 {} + +declare class C3 {} +module C3 {} +interface C3 {} + +module C4 {} +declare class C4 {} // error -- class declaration must preceed module declaration +interface C4 {} \ No newline at end of file From 323ce242877219127a6b388d18dcc9b003791cbb Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 3 Jun 2015 14:28:18 -0700 Subject: [PATCH 074/309] new baselines got mergeClassInterfaceAndModule --- .../reference/mergeClassInterfaceAndModule.js | 19 ++++++++++ .../mergeClassInterfaceAndModule.symbols | 38 +++++++++++++++++++ .../mergeClassInterfaceAndModule.types | 38 +++++++++++++++++++ 3 files changed, 95 insertions(+) create mode 100644 tests/baselines/reference/mergeClassInterfaceAndModule.js create mode 100644 tests/baselines/reference/mergeClassInterfaceAndModule.symbols create mode 100644 tests/baselines/reference/mergeClassInterfaceAndModule.types diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.js b/tests/baselines/reference/mergeClassInterfaceAndModule.js new file mode 100644 index 00000000000..5b7315031cd --- /dev/null +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.js @@ -0,0 +1,19 @@ +//// [mergeClassInterfaceAndModule.ts] + +interface C1 {} +declare class C1 {} +module C1 {} + +declare class C2 {} +interface C2 {} +module C2 {} + +declare class C3 {} +module C3 {} +interface C3 {} + +module C4 {} +declare class C4 {} // error -- class declaration must preceed module declaration +interface C4 {} + +//// [mergeClassInterfaceAndModule.js] diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.symbols b/tests/baselines/reference/mergeClassInterfaceAndModule.symbols new file mode 100644 index 00000000000..a10227ed461 --- /dev/null +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.symbols @@ -0,0 +1,38 @@ +=== tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts === + +interface C1 {} +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) + +declare class C1 {} +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) + +module C1 {} +>C1 : Symbol(C1, Decl(mergeClassInterfaceAndModule.ts, 0, 0), Decl(mergeClassInterfaceAndModule.ts, 1, 15), Decl(mergeClassInterfaceAndModule.ts, 2, 19)) + +declare class C2 {} +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) + +interface C2 {} +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) + +module C2 {} +>C2 : Symbol(C2, Decl(mergeClassInterfaceAndModule.ts, 3, 12), Decl(mergeClassInterfaceAndModule.ts, 5, 19), Decl(mergeClassInterfaceAndModule.ts, 6, 15)) + +declare class C3 {} +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) + +module C3 {} +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) + +interface C3 {} +>C3 : Symbol(C3, Decl(mergeClassInterfaceAndModule.ts, 7, 12), Decl(mergeClassInterfaceAndModule.ts, 9, 19), Decl(mergeClassInterfaceAndModule.ts, 10, 12)) + +module C4 {} +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) + +declare class C4 {} // error -- class declaration must preceed module declaration +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) + +interface C4 {} +>C4 : Symbol(C4, Decl(mergeClassInterfaceAndModule.ts, 11, 15), Decl(mergeClassInterfaceAndModule.ts, 13, 12), Decl(mergeClassInterfaceAndModule.ts, 14, 19)) + diff --git a/tests/baselines/reference/mergeClassInterfaceAndModule.types b/tests/baselines/reference/mergeClassInterfaceAndModule.types new file mode 100644 index 00000000000..a91691e5bac --- /dev/null +++ b/tests/baselines/reference/mergeClassInterfaceAndModule.types @@ -0,0 +1,38 @@ +=== tests/cases/conformance/classes/classDeclarations/mergeClassInterfaceAndModule.ts === + +interface C1 {} +>C1 : C1 + +declare class C1 {} +>C1 : C1 + +module C1 {} +>C1 : typeof C1 + +declare class C2 {} +>C2 : C2 + +interface C2 {} +>C2 : C2 + +module C2 {} +>C2 : typeof C2 + +declare class C3 {} +>C3 : C3 + +module C3 {} +>C3 : typeof C3 + +interface C3 {} +>C3 : C3 + +module C4 {} +>C4 : typeof C4 + +declare class C4 {} // error -- class declaration must preceed module declaration +>C4 : C4 + +interface C4 {} +>C4 : C4 + From 365ea3d9099cdfe953d95b8ee75e68cdf3e53e1b Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 3 Jun 2015 15:51:59 -0700 Subject: [PATCH 075/309] Check for ambient context instead of ambient flag --- src/compiler/checker.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b0b6521e230..d904c670195 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10415,8 +10415,8 @@ module ts { }); } - // Non-ambient classes cannot merge with interfaces. - if (!(node.flags & NodeFlags.Ambient) && symbol.flags & SymbolFlags.Interface) { + // Interfaces cannot be merged with non-ambient classes. + if (symbol.flags & SymbolFlags.Interface && !isInAmbientContext(node)) { error(node, Diagnostics.Only_an_ambient_class_can_be_merged_with_an_interface) } @@ -10603,7 +10603,7 @@ module ts { // Interfaces cannot merge with non-ambient classes. if (symbol && symbol.declarations) { for (let declaration of symbol.declarations) { - if (declaration.kind === SyntaxKind.ClassDeclaration && !(declaration.flags & NodeFlags.Ambient)) { + if (declaration.kind === SyntaxKind.ClassDeclaration && !isInAmbientContext(declaration)) { error(node, Diagnostics.Only_an_ambient_class_can_be_merged_with_an_interface); break; } From 5ef426ca02eb15605caa1aff6c4eccf70ffe06ad Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 3 Jun 2015 16:11:19 -0700 Subject: [PATCH 076/309] new baselines --- .../classAndInterfaceMerge.d.errors.txt | 46 ------------------- .../classAndInterfaceMerge.d.symbols | 39 ++++++++++++++++ .../reference/classAndInterfaceMerge.d.types | 39 ++++++++++++++++ 3 files changed, 78 insertions(+), 46 deletions(-) delete mode 100644 tests/baselines/reference/classAndInterfaceMerge.d.errors.txt create mode 100644 tests/baselines/reference/classAndInterfaceMerge.d.symbols create mode 100644 tests/baselines/reference/classAndInterfaceMerge.d.types diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt b/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt deleted file mode 100644 index fa0d239cdc7..00000000000 --- a/tests/baselines/reference/classAndInterfaceMerge.d.errors.txt +++ /dev/null @@ -1,46 +0,0 @@ -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(12,15): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(14,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(16,15): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(18,15): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(20,18): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts(24,22): error TS2506: Only an ambient class can be merged with an interface. - - -==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts (6 errors) ==== - - interface C { } - - declare class C { } - - interface C { } - - interface C { } - - declare module M { - - interface C1 { } - ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. - - class C1 { } - ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. - - interface C1 { } - ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. - - interface C1 { } - ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. - - export class C2 { } - ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. - } - - declare module M { - export interface C2 { } - ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. - } \ No newline at end of file diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.symbols b/tests/baselines/reference/classAndInterfaceMerge.d.symbols new file mode 100644 index 00000000000..84fc2b129c1 --- /dev/null +++ b/tests/baselines/reference/classAndInterfaceMerge.d.symbols @@ -0,0 +1,39 @@ +=== tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts === + +interface C { } +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) + +declare class C { } +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) + +interface C { } +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) + +interface C { } +>C : Symbol(C, Decl(classAndInterfaceMerge.d.ts, 0, 0), Decl(classAndInterfaceMerge.d.ts, 1, 15), Decl(classAndInterfaceMerge.d.ts, 3, 19), Decl(classAndInterfaceMerge.d.ts, 5, 15)) + +declare module M { +>M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 7, 15), Decl(classAndInterfaceMerge.d.ts, 20, 1)) + + interface C1 { } +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) + + class C1 { } +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) + + interface C1 { } +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) + + interface C1 { } +>C1 : Symbol(C1, Decl(classAndInterfaceMerge.d.ts, 9, 18), Decl(classAndInterfaceMerge.d.ts, 11, 20), Decl(classAndInterfaceMerge.d.ts, 13, 16), Decl(classAndInterfaceMerge.d.ts, 15, 20)) + + export class C2 { } +>C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 17, 20), Decl(classAndInterfaceMerge.d.ts, 22, 18)) +} + +declare module M { +>M : Symbol(M, Decl(classAndInterfaceMerge.d.ts, 7, 15), Decl(classAndInterfaceMerge.d.ts, 20, 1)) + + export interface C2 { } +>C2 : Symbol(C2, Decl(classAndInterfaceMerge.d.ts, 17, 20), Decl(classAndInterfaceMerge.d.ts, 22, 18)) +} diff --git a/tests/baselines/reference/classAndInterfaceMerge.d.types b/tests/baselines/reference/classAndInterfaceMerge.d.types new file mode 100644 index 00000000000..baab121ca6e --- /dev/null +++ b/tests/baselines/reference/classAndInterfaceMerge.d.types @@ -0,0 +1,39 @@ +=== tests/cases/conformance/classes/classDeclarations/classAndInterfaceMerge.d.ts === + +interface C { } +>C : C + +declare class C { } +>C : C + +interface C { } +>C : C + +interface C { } +>C : C + +declare module M { +>M : typeof M + + interface C1 { } +>C1 : C1 + + class C1 { } +>C1 : C1 + + interface C1 { } +>C1 : C1 + + interface C1 { } +>C1 : C1 + + export class C2 { } +>C2 : C2 +} + +declare module M { +>M : typeof M + + export interface C2 { } +>C2 : C2 +} From 3a3479d7e2ed9fd17c0ea096825143678b9f186f Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 4 Jun 2015 11:08:13 -0700 Subject: [PATCH 077/309] New Test and Baseline --- ...sImplementsMergedClassInterface.errors.txt | 41 +++++++++++++++++ .../classImplementsMergedClassInterface.js | 46 +++++++++++++++++++ .../classImplementsMergedClassInterface.ts | 23 ++++++++++ 3 files changed, 110 insertions(+) create mode 100644 tests/baselines/reference/classImplementsMergedClassInterface.errors.txt create mode 100644 tests/baselines/reference/classImplementsMergedClassInterface.js create mode 100644 tests/cases/conformance/classes/classDeclarations/classImplementsMergedClassInterface.ts diff --git a/tests/baselines/reference/classImplementsMergedClassInterface.errors.txt b/tests/baselines/reference/classImplementsMergedClassInterface.errors.txt new file mode 100644 index 00000000000..3e62e72be84 --- /dev/null +++ b/tests/baselines/reference/classImplementsMergedClassInterface.errors.txt @@ -0,0 +1,41 @@ +tests/cases/conformance/classes/classDeclarations/classImplementsMergedClassInterface.ts(9,7): error TS2420: Class 'C2' incorrectly implements interface 'C1'. + Property 'x' is missing in type 'C2'. +tests/cases/conformance/classes/classDeclarations/classImplementsMergedClassInterface.ts(12,7): error TS2420: Class 'C3' incorrectly implements interface 'C1'. + Property 'y' is missing in type 'C3'. +tests/cases/conformance/classes/classDeclarations/classImplementsMergedClassInterface.ts(16,7): error TS2420: Class 'C4' incorrectly implements interface 'C1'. + Property 'x' is missing in type 'C4'. + + +==== tests/cases/conformance/classes/classDeclarations/classImplementsMergedClassInterface.ts (3 errors) ==== + declare class C1 { + x : number; + } + + interface C1 { + y : number; + } + + class C2 implements C1 { // error -- missing x + ~~ +!!! error TS2420: Class 'C2' incorrectly implements interface 'C1'. +!!! error TS2420: Property 'x' is missing in type 'C2'. + } + + class C3 implements C1 { // error -- missing y + ~~ +!!! error TS2420: Class 'C3' incorrectly implements interface 'C1'. +!!! error TS2420: Property 'y' is missing in type 'C3'. + x : number; + } + + class C4 implements C1 { // error -- missing x + ~~ +!!! error TS2420: Class 'C4' incorrectly implements interface 'C1'. +!!! error TS2420: Property 'x' is missing in type 'C4'. + y : number; + } + + class C5 implements C1 { // okay + x : number; + y : number; + } \ No newline at end of file diff --git a/tests/baselines/reference/classImplementsMergedClassInterface.js b/tests/baselines/reference/classImplementsMergedClassInterface.js new file mode 100644 index 00000000000..64a0198cc16 --- /dev/null +++ b/tests/baselines/reference/classImplementsMergedClassInterface.js @@ -0,0 +1,46 @@ +//// [classImplementsMergedClassInterface.ts] +declare class C1 { + x : number; +} + +interface C1 { + y : number; +} + +class C2 implements C1 { // error -- missing x +} + +class C3 implements C1 { // error -- missing y + x : number; +} + +class C4 implements C1 { // error -- missing x + y : number; +} + +class C5 implements C1 { // okay + x : number; + y : number; +} + +//// [classImplementsMergedClassInterface.js] +var C2 = (function () { + function C2() { + } + return C2; +})(); +var C3 = (function () { + function C3() { + } + return C3; +})(); +var C4 = (function () { + function C4() { + } + return C4; +})(); +var C5 = (function () { + function C5() { + } + return C5; +})(); diff --git a/tests/cases/conformance/classes/classDeclarations/classImplementsMergedClassInterface.ts b/tests/cases/conformance/classes/classDeclarations/classImplementsMergedClassInterface.ts new file mode 100644 index 00000000000..d5ac1b005bf --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classImplementsMergedClassInterface.ts @@ -0,0 +1,23 @@ +declare class C1 { + x : number; +} + +interface C1 { + y : number; +} + +class C2 implements C1 { // error -- missing x +} + +class C3 implements C1 { // error -- missing y + x : number; +} + +class C4 implements C1 { // error -- missing x + y : number; +} + +class C5 implements C1 { // okay + x : number; + y : number; +} \ No newline at end of file From 72a6865f93debeb72f8bf4c17f7929808f5a90fc Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 4 Jun 2015 12:08:09 -0700 Subject: [PATCH 078/309] Updated emit to align with current proposal for ES7 async functions --- src/compiler/checker.ts | 171 ++++++++++------ src/compiler/emitter.ts | 185 ++++++++++-------- src/compiler/types.ts | 6 +- .../reference/asyncArrowFunction1_es6.js | 4 +- .../reference/asyncArrowFunction6_es6.js | 4 +- .../reference/asyncArrowFunction7_es6.js | 8 +- .../reference/asyncArrowFunction8_es6.js | 4 +- .../reference/asyncArrowFunction9_es6.js | 4 +- ...owFunctionCapturesArguments_es6.errors.txt | 13 -- ...asyncArrowFunctionCapturesArguments_es6.js | 2 +- ...ncArrowFunctionCapturesArguments_es6.types | 22 +++ .../asyncArrowFunctionCapturesThis_es6.js | 2 +- .../asyncFunctionDeclaration10_es6.js | 6 +- .../asyncFunctionDeclaration11_es6.js | 4 +- .../asyncFunctionDeclaration13_es6.js | 4 +- .../asyncFunctionDeclaration14_es6.js | 4 +- .../asyncFunctionDeclaration1_es6.js | 4 +- .../asyncFunctionDeclaration6_es6.js | 6 +- .../asyncFunctionDeclaration7_es6.js | 10 +- .../asyncFunctionDeclaration9_es6.js | 4 +- .../reference/awaitBinaryExpression1_es6.js | 4 +- .../reference/awaitBinaryExpression2_es6.js | 4 +- .../reference/awaitBinaryExpression3_es6.js | 4 +- .../reference/awaitBinaryExpression4_es6.js | 4 +- .../reference/awaitBinaryExpression5_es6.js | 4 +- .../reference/awaitCallExpression1_es6.js | 4 +- .../reference/awaitCallExpression2_es6.js | 4 +- .../reference/awaitCallExpression3_es6.js | 4 +- .../reference/awaitCallExpression4_es6.js | 4 +- .../reference/awaitCallExpression5_es6.js | 4 +- .../reference/awaitCallExpression6_es6.js | 4 +- .../reference/awaitCallExpression7_es6.js | 4 +- .../reference/awaitCallExpression8_es6.js | 4 +- 33 files changed, 293 insertions(+), 226 deletions(-) delete mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt create mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 7f93b21392b..177c5776557 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -824,7 +824,7 @@ module ts { } // Resolves a qualified name and any involved aliases - function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags): Symbol { + function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, location?: Node): Symbol { if (nodeIsMissing(name)) { return undefined; } @@ -833,7 +833,7 @@ module ts { if (name.kind === SyntaxKind.Identifier) { let message = meaning === SymbolFlags.Namespace ? Diagnostics.Cannot_find_namespace_0 : Diagnostics.Cannot_find_name_0; - symbol = resolveName(name, (name).text, meaning, message, name); + symbol = resolveName(location || name, (name).text, meaning, message, name); if (!symbol) { return undefined; } @@ -842,7 +842,7 @@ module ts { let left = name.kind === SyntaxKind.QualifiedName ? (name).left : (name).expression; let right = name.kind === SyntaxKind.QualifiedName ? (name).right : (name).name; - let namespace = resolveEntityName(left, SymbolFlags.Namespace); + let namespace = resolveEntityName(left, SymbolFlags.Namespace, location); if (!namespace || namespace === unknownSymbol || nodeIsMissing(right)) { return undefined; } @@ -3834,6 +3834,20 @@ module ts { } return links.resolvedType; } + + function getEntityNameFromTypeNode(node: TypeNode): EntityName | Expression { + switch (node.kind) { + case SyntaxKind.TypeReference: + return (node).typeName; + case SyntaxKind.ExpressionWithTypeArguments: + return (node).expression + case SyntaxKind.Identifier: + case SyntaxKind.QualifiedName: + return (node); + default: + return undefined; + } + } function getTypeFromTypeNode(node: TypeNode): Type { switch (node.kind) { @@ -5643,9 +5657,10 @@ module ts { if (languageVersion < ScriptTarget.ES6) { error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); } - else if (node.parserContextFlags & ParserContextFlags.Await) { - error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression); - } + } + + if (node.parserContextFlags & ParserContextFlags.Await) { + getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments; } } @@ -7746,11 +7761,14 @@ module ts { Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node)); let isAsync = isAsyncFunctionLike(node); + if (isAsync) { + emitAwaiter = true; + } + let returnType = node.type && getTypeFromTypeNode(node.type); - let promisedType: Type; if (returnType && isAsync) { - promisedType = checkAsyncFunctionReturnType(node, returnType); + promisedType = checkAsyncFunctionReturnType(node); } if (returnType && !node.asteriskToken) { @@ -9440,56 +9458,71 @@ module ts { * a `resolve` function as one of its arguments and results in an object with a * callable `then` signature. */ - function checkAsyncFunctionReturnType(node: SignatureDeclaration, returnType: Type): Type { + function checkAsyncFunctionReturnType(node: SignatureDeclaration): Type { let globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(); - if (globalPromiseConstructorLikeType !== emptyObjectType) { - // The return type of an async function will be the type of the instance. For this - // to be a type compatible with our async function emit, we must also check that - // the type of the declaration (e.g. the static side or "constructor" type of the - // promise) is a compatible `PromiseConstructorLike`. - // - // An example might be (from lib.es6.d.ts): - // - // interface Promise { ... } - // interface PromiseConstructor { - // new (...): Promise; - // } - // declare var Promise: PromiseConstructor; - // - // When an async function declares a return type annotation of `Promise`, we - // need to get the type of the `Promise` variable declaration above, which would - // be `PromiseConstructor`. - // - // The same case applies to a class: - // - // declare class Promise { - // constructor(...); - // then(...): Promise; - // } - // - // When we get the type of the `Promise` symbol here, we get the type of the static - // side of the `Promise` class, which would be `{ new (...): Promise }`. - let declaredType = returnType.symbol ? getTypeOfSymbol(returnType.symbol) : emptyObjectType; - if (isTypeAssignableTo(declaredType, globalPromiseConstructorLikeType)) { - // Ensure we will emit the `__awaiter` helper. - emitAwaiter = true; + if (globalPromiseConstructorLikeType === emptyObjectType) { + // If we couldn't resolve the global PromiseConstructorLike type we cannot verify + // compatibility with __awaiter, so we report an error. + error(node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return unknownType; + } - // When we emit the async function, we need to ensure we emit any imports that might - // otherwise have been elided if the return type were only ever referenced in a type - // position. As such, we get the entity name of the type reference from the return - // type and check it as an expression. - let promiseConstructor = getPromiseConstructor(node); - if (promiseConstructor) { - checkExpressionOrQualifiedName(promiseConstructor); - } - - // Get and return the awaited type of the return type. - return getAwaitedType(returnType, node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); - } + // The return type of an async function will be the type of the instance. For this + // to be a type compatible with our async function emit, we must also check that + // the type of the declaration (e.g. the static side or "constructor" type of the + // promise) is a compatible `PromiseConstructorLike`. + // + // An example might be (from lib.es6.d.ts): + // + // interface Promise { ... } + // interface PromiseConstructor { + // new (...): Promise; + // } + // declare var Promise: PromiseConstructor; + // + // When an async function declares a return type annotation of `Promise`, we + // need to get the type of the `Promise` variable declaration above, which would + // be `PromiseConstructor`. + // + // The same case applies to a class: + // + // declare class Promise { + // constructor(...); + // then(...): Promise; + // } + // + // When we get the type of the `Promise` symbol here, we get the type of the static + // side of the `Promise` class, which would be `{ new (...): Promise }`. + let returnType = getTypeFromTypeNode(node.type); + let entityName = getEntityNameFromTypeNode(node.type); + let resolvedName = entityName ? resolveEntityName(entityName, SymbolFlags.Value, node) : undefined; + if (!resolvedName || !returnType.symbol) { + error(node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return unknownType; + } + + if (getMergedSymbol(resolvedName) !== getMergedSymbol(returnType.symbol)) { + // If we were unable to resolve the return type as a value, report an error. + let identifier = getFirstIdentifier(entityName); + error(resolvedName.valueDeclaration, Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, + identifier.text, + identifier.text); + return unknownType; + } + + // When we emit the async function, we need to ensure we emit any imports that might + // otherwise have been elided if the return type were only ever referenced in a type + // position. As such, we check the entity name as an expression. + let declaredType = checkExpressionOrQualifiedName(entityName); + + if (!isTypeAssignableTo(declaredType, globalPromiseConstructorLikeType)) { + // If the declared type of the return type is not assignable to a PromiseConstructorLike, report an error. + error(node, ts.Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return unknownType; } - error(node, ts.Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); - return unknownType; + // Get and return the awaited type of the return type. + return getAwaitedType(returnType, node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); } /** Check a decorator */ @@ -9635,6 +9668,10 @@ module ts { checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSignatureDeclaration(node); + let isAsync = isAsyncFunctionLike(node); + if (isAsync) { + emitAwaiter = true; + } // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including @@ -9670,10 +9707,9 @@ module ts { checkSourceElement(node.body); if (node.type && !isAccessor(node.kind) && !node.asteriskToken) { let returnType = getTypeFromTypeNode(node.type); - let isAsync = isAsyncFunctionLike(node); let promisedType: Type; if (isAsync) { - promisedType = checkAsyncFunctionReturnType(node, returnType); + promisedType = checkAsyncFunctionReturnType(node); } checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); @@ -9888,13 +9924,11 @@ module ts { } } - function getPromiseConstructor(node: SignatureDeclaration): EntityName { - if (isAsyncFunctionLike(node)) { + function getPromiseConstructor(node: SignatureDeclaration): EntityName | Expression { + if (isAsyncFunctionLike(node) && node.type) { let links = getNodeLinks(node); if (!links.promiseConstructor) { - if (node.type && node.type.kind === SyntaxKind.TypeReference) { - links.promiseConstructor = (node.type).typeName; - } + links.promiseConstructor = getEntityNameFromTypeNode(node.type); } return links.promiseConstructor; @@ -10037,8 +10071,12 @@ module ts { function checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node: Node) { if (node.modifiers) { if (inBlockOrObjectLiteralExpression(node)) { - // disallow all but the `async` modifier here - if (isAccessor(node.kind) || !isFunctionLike(node) || (node.modifiers.flags & ~NodeFlags.Async)) { + if (isAsyncFunctionLike(node)) { + if (node.modifiers.length > 1) { + return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); + } + } + else { return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); } } @@ -12973,10 +13011,15 @@ module ts { case SyntaxKind.ExportAssignment: case SyntaxKind.Parameter: break; + case SyntaxKind.FunctionDeclaration: + if (node.modifiers && (node.modifiers.length > 1 || node.modifiers[0].kind !== SyntaxKind.AsyncKeyword) && + node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.SourceFile) { + return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); + } + break; case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.VariableStatement: - case SyntaxKind.FunctionDeclaration: case SyntaxKind.TypeAliasDeclaration: if (node.modifiers && node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.SourceFile) { return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 9472ed68091..66cdebe4ee8 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -49,19 +49,20 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { };`; const awaiterHelper = ` -var __awaiter = (this && this.__awaiter) || function (generator, ctor) { - function resolve(value) { return step(generator.next(value)); } - function reject(reason) { return step(generator["throw"](reason)); } - function step(result) { - while (true) { - var done = result.done, value = result.value, then; - if (done) return value; - if (value && typeof (then = value.then) === "function") return then.call(value, resolve, reject); - result = generator.next(value); +var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, PromiseConstructor) { + PromiseConstructor || (PromiseConstructor = Promise); + return new PromiseConstructor(function (resolve, reject) { + generator = generator.call(thisArg, args); + function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); } + function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } } + function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } } + function step(verb, value) { + var result = generator[verb](value); + result.done ? resolve(result.value) : cast(result.value).then(onfulfill, onreject); } - } - return new (ctor || Promise)(function (resolver) { resolver(resolve(undefined)); }); -}`; + step("next", void 0); + }); +};`; let compilerOptions = host.getCompilerOptions(); let languageVersion = compilerOptions.target || ScriptTarget.ES3; @@ -128,7 +129,7 @@ var __awaiter = (this && this.__awaiter) || function (generator, ctor) { let writeLine = writer.writeLine; let increaseIndent = writer.increaseIndent; let decreaseIndent = writer.decreaseIndent; - + let currentSourceFile: SourceFile; // name of an exporter function if file is a System external module // System.register([...], function () {...}) @@ -3390,100 +3391,114 @@ var __awaiter = (this && this.__awaiter) || function (generator, ctor) { emitSignatureParameters(node); } - function emitAsyncSignatureAndBodyForES6(node: FunctionLikeDeclaration) { + function emitAsyncFunctionBodyForES6(node: FunctionLikeDeclaration) { let promiseConstructor = resolver.getPromiseConstructor(node); let isArrowFunction = node.kind === SyntaxKind.ArrowFunction; let args: string; // An async function is emit as an outer function that calls an inner - // generator function. Any arguments of the outer function must be - // evaluated in the context of the generator function, to ensure the correct - // environment and bindings for things like binding patterns in the - // argument list. + // generator function. To preserve lexical bindings, we pass the current + // `this` and `arguments` objects to `__awaiter`. The generator function + // passed to `__awaiter` is executed inside of the callback to the + // promise constructor. // - // For async function declarations and function expressions, we want to - // pass the `arguments` object of the outer function to the inner generator - // function in the event the async function directly manipulates the `arguments` - // object. + // The emit for an async arrow without a lexical `arguments` binding might be: // - // For async arrow functions, the `arguments` object is not bound to the arrow - // but its containing function. In that case, we must collect all of the passed - // arguments into an array which we then pass to the inner generator function to - // ensure the correct environment for any binding patterns. + // // input + // let a = async (b) => { await b; } // - // Async arrow functions do not have access to the lexical `arguments` of its - // lexical container. + // // output + // let a = (b) => __awaiter(function* (b) { + // yield b; + // }, this); // - // The emit for an async arrow without parameters will look something like this: + // The emit for an async arrow with a lexical `arguments` binding might be: // - // let a = async () => await b; + // // input + // let a = async (b) => { await arguments[0]; } // - // let a = () => __awaiter(function* () { - // return yield b; - // }.apply(this)); + // // output + // let a = (b) => __awaiter(function* (arguments) { + // yield arguments[0]; + // }, this, arguments); // - // The emit for an async arrow with parameters will look something like this: + // The emit for an async function expression without a lexical `arguments` binding + // might be: // - // let a = async (b) => await b; - // - // let a = (...arguments_1) => __awaiter(function* (b) { - // return yield b; - // }).apply(this, arguments_1); - // - // The emit for an async function expression will look something like this: - // - // let a = async function () { - // return await b; + // // input + // let a = async function (b) { + // await b; // } // - // let a = function () { + // // output + // let a = function (b) { // return __awaiter(function* () { - // return yield b; - // }.apply(this, arguments)); + // yield b; + // }, this); // } // - if (isArrowFunction) { - // Emit the outer signature for the async arrow - if (node.parameters.length) { - args = makeUniqueName("arguments"); - write(`(...${args}) => `); - } - else { - write("() => "); - } - } - else { - // Emit the outer signature for the async function expression or declaration - args = "arguments"; - write("() {"); + // The emit for an async function expression with a lexical `arguments` binding + // might be: + // + // // input + // let a = async function (b) { + // await arguments[0]; + // } + // + // // output + // let a = function (b) { + // return __awaiter(function* (arguments) { + // yield arguments[0]; + // }, this, arguments); + // } + // + + // If this is not an async arrow, emit the opening brace of the function body + // and the start of the return statement. + if (!isArrowFunction) { + write(" {"); increaseIndent(); writeLine(); - write("return "); + write("return"); } - // Emit the call to __awaiter - write("__awaiter(function *"); - // Emit the signature and body for the inner generator function - emitSignatureParameters(node); + // Emit the call to __awaiter. + let hasLexicalArguments = (resolver.getNodeCheckFlags(node) & NodeCheckFlags.CaptureArguments) !== 0; + if (hasLexicalArguments) { + write(" __awaiter(function* (arguments)"); + } + else { + write(" __awaiter(function* ()"); + } + + // Emit the signature and body for the inner generator function. emitFunctionBody(node); - // Emit the call to `apply` to ensure the correct `this` and arguments. - write(".apply(this"); - if (args) { - write(`, ${args}`); - } - write(")"); + // Emit the current `this` binding. + write(", this"); + // Optionally emit the lexical arguments. + if (hasLexicalArguments) { + write(", arguments"); + } + // If the function has an explicit type annotation for a promise, emit the // constructor. if (promiseConstructor) { + // If we did not have lexical arguments, supply undefined (void 0) for + // the `arguments` parameter. + if (!hasLexicalArguments) { + write(", void 0"); + } + write(", "); - emit(promiseConstructor); + emitNodeWithoutSourceMap(promiseConstructor); } + write(")"); - // If this is not an async arrow, emit the closing brace of the outer function body + // If this is not an async arrow, emit the closing brace of the outer function body. if (!isArrowFunction) { write(";"); decreaseIndent(); @@ -3516,20 +3531,20 @@ var __awaiter = (this && this.__awaiter) || function (generator, ctor) { tempVariables = undefined; tempParameters = undefined; - let isAsync = isAsyncFunctionLike(node); - if (isAsync && languageVersion === ScriptTarget.ES6) { - emitAsyncSignatureAndBodyForES6(node); + // When targeting ES6, emit arrow function natively in ES6 + if (shouldEmitAsArrowFunction(node)) { + emitSignatureParametersForArrow(node); + write(" =>"); } else { - // When targeting ES6, emit arrow function natively in ES6 - if (shouldEmitAsArrowFunction(node)) { - emitSignatureParametersForArrow(node); - write(" =>"); - } - else { - emitSignatureParameters(node); - } + emitSignatureParameters(node); + } + let isAsync = isAsyncFunctionLike(node); + if (isAsync && languageVersion === ScriptTarget.ES6) { + emitAsyncFunctionBodyForES6(node); + } + else { emitFunctionBody(node); } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 0d70de93e19..28b2bffa94a 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1441,7 +1441,7 @@ module ts { serializeTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[]; serializeParameterTypesOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): (string | string[])[]; serializeReturnTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[]; - getPromiseConstructor(node: SignatureDeclaration): EntityName; + getPromiseConstructor(node: SignatureDeclaration): EntityName | Expression; } export const enum SymbolFlags { @@ -1569,7 +1569,7 @@ module ts { SuperInstance = 0x00000100, // Instance 'super' reference SuperStatic = 0x00000200, // Static 'super' reference ContextChecked = 0x00000400, // Contextual types have been assigned - PromiseCollision = 0x00000800, // Declaration collides with the global 'Promise' + CaptureArguments = 0x00000800, // Lexical 'arguments' used in body (for async functions) // Values for enum members have been computed, and any errors have been reported for them. EnumValuesComputed = 0x00001000, @@ -1592,7 +1592,7 @@ module ts { assignmentChecks?: Map; // Cache of assignment checks hasReportedStatementInAmbientContext?: boolean; // Cache boolean if we report statements in ambient context importOnRightSide?: Symbol; // for import declarations - import that appear on the right side - promiseConstructor?: EntityName; + promiseConstructor?: EntityName | Expression; } export const enum TypeFlags { diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js index 78a2899d056..4ce29929de8 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.js +++ b/tests/baselines/reference/asyncArrowFunction1_es6.js @@ -4,5 +4,5 @@ var foo = async (): Promise => { }; //// [asyncArrowFunction1_es6.js] -var foo = () => __awaiter(function *() { -}.apply(this), Promise); +var foo = () => __awaiter(function* () { +}, this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js index e4da75e3cd1..1554e895d14 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.js +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -4,5 +4,5 @@ var foo = async (a = await): Promise => { } //// [asyncArrowFunction6_es6.js] -var foo = (...arguments_1) => __awaiter(function *(a = await) { -}.apply(this, arguments_1), Promise); +var foo = (a = await) => __awaiter(function* () { +}, this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js index 9bf3fdc480f..459ec413da5 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.js +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -7,8 +7,8 @@ var bar = async (): Promise => { } //// [asyncArrowFunction7_es6.js] -var bar = () => __awaiter(function *() { +var bar = () => __awaiter(function* () { // 'await' here is an identifier, and not an await expression. - var foo = (...arguments_1) => __awaiter(function *(a = await) { - }.apply(this, arguments_1), Promise); -}.apply(this), Promise); + var foo = (a = await) => __awaiter(function* () { + }, this, void 0, Promise); +}, this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js index 3f98f3a4f63..b32541fdda6 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es6.js +++ b/tests/baselines/reference/asyncArrowFunction8_es6.js @@ -5,6 +5,6 @@ var foo = async (): Promise => { } //// [asyncArrowFunction8_es6.js] -var foo = () => __awaiter(function *() { +var foo = () => __awaiter(function* () { var v = { [yield ]: foo }; -}.apply(this), Promise); +}, this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.js b/tests/baselines/reference/asyncArrowFunction9_es6.js index b78a49afdbb..8a9b663266c 100644 --- a/tests/baselines/reference/asyncArrowFunction9_es6.js +++ b/tests/baselines/reference/asyncArrowFunction9_es6.js @@ -3,5 +3,5 @@ var foo = async (a = await => await): Promise => { } //// [asyncArrowFunction9_es6.js] -var foo = (...arguments_1) => __awaiter(function *(a = await => await) { -}.apply(this, arguments_1), Promise); +var foo = (a = await => await) => __awaiter(function* () { +}, this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt deleted file mode 100644 index dcaba564e23..00000000000 --- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt +++ /dev/null @@ -1,13 +0,0 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts(4,52): error TS2522: The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression. - - -==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts (1 errors) ==== - class C { - method() { - function other() {} - var fn = async () => await other.apply(this, arguments); - ~~~~~~~~~ -!!! error TS2522: The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression. - } - } - \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js index 96926ba8f41..86a1b6e110c 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js @@ -11,6 +11,6 @@ class C { class C { method() { function other() { } - var fn = () => __awaiter(function *() { return yield other.apply(this, arguments); }.apply(this)); + var fn = () => __awaiter(function* (arguments) { return yield other.apply(this, arguments); }, this, arguments); } } diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types new file mode 100644 index 00000000000..b3f6f18cde8 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts === +class C { +>C : C + + method() { +>method : () => void + + function other() {} +>other : () => void + + var fn = async () => await other.apply(this, arguments); +>fn : () => Promise +>async () => await other.apply(this, arguments) : () => Promise +>other.apply(this, arguments) : any +>other.apply : (thisArg: any, argArray?: any) => any +>other : () => void +>apply : (thisArg: any, argArray?: any) => any +>this : C +>arguments : IArguments + } +} + diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js index 572c5fbe046..afcd73b32dc 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js +++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js @@ -9,6 +9,6 @@ class C { //// [asyncArrowFunctionCapturesThis_es6.js] class C { method() { - var fn = () => __awaiter(function *() { return yield this; }.apply(this)); + var fn = () => __awaiter(function* () { return yield this; }, this); } } diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js index e85492bee70..25319680ceb 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js @@ -3,7 +3,7 @@ async function foo(a = await => await): Promise { } //// [asyncFunctionDeclaration10_es6.js] -function foo() { - return __awaiter(function *(a = await => await) { - }.apply(this, arguments), Promise); +function foo(a = await => await) { + return __awaiter(function* () { + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js index 39bf2c20e79..37cb4bbc0d4 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js @@ -4,6 +4,6 @@ async function await(): Promise { //// [asyncFunctionDeclaration11_es6.js] function await() { - return __awaiter(function *() { - }.apply(this, arguments), Promise); + return __awaiter(function* () { + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js index 9666fb5d7c4..0423ca2341b 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js @@ -7,8 +7,8 @@ async function foo(): Promise { //// [asyncFunctionDeclaration13_es6.js] function foo() { - return __awaiter(function *() { + return __awaiter(function* () { // Legal to use 'await' in a type context. var v; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js index 2f694f02696..eccf374cdc3 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js @@ -5,7 +5,7 @@ async function foo(): Promise { //// [asyncFunctionDeclaration14_es6.js] function foo() { - return __awaiter(function *() { + return __awaiter(function* () { return; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js index 75cb74a68a5..386e1e76241 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js @@ -4,6 +4,6 @@ async function foo(): Promise { //// [asyncFunctionDeclaration1_es6.js] function foo() { - return __awaiter(function *() { - }.apply(this, arguments), Promise); + return __awaiter(function* () { + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js index 663e02604ea..9bd17a7cd0e 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js @@ -3,7 +3,7 @@ async function foo(a = await): Promise { } //// [asyncFunctionDeclaration6_es6.js] -function foo() { - return __awaiter(function *(a = await) { - }.apply(this, arguments), Promise); +function foo(a = await) { + return __awaiter(function* () { + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js index fb913e3f6f4..b32c90664ac 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js @@ -7,11 +7,11 @@ async function bar(): Promise { //// [asyncFunctionDeclaration7_es6.js] function bar() { - return __awaiter(function *() { + return __awaiter(function* () { // 'await' here is an identifier, and not a yield expression. - function foo() { - return __awaiter(function *(a = await) { - }.apply(this, arguments), Promise); + function foo(a = await) { + return __awaiter(function* () { + }, this, void 0, Promise); } - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js index 8b5ea4c4b5c..3fcf3f2f7ca 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js @@ -5,7 +5,7 @@ async function foo(): Promise { //// [asyncFunctionDeclaration9_es6.js] function foo() { - return __awaiter(function *() { + return __awaiter(function* () { var v = { [yield ]: foo }; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.js b/tests/baselines/reference/awaitBinaryExpression1_es6.js index f92324dcdac..889e9373368 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.js @@ -9,9 +9,9 @@ async function func(): Promise { //// [awaitBinaryExpression1_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = (yield p) || a; "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.js b/tests/baselines/reference/awaitBinaryExpression2_es6.js index e2d3b3ba46f..5a156d6d0d3 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.js @@ -9,9 +9,9 @@ async function func(): Promise { //// [awaitBinaryExpression2_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = (yield p) && a; "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.js b/tests/baselines/reference/awaitBinaryExpression3_es6.js index 08e98d5dafe..8b150a9fcbf 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.js @@ -9,9 +9,9 @@ async function func(): Promise { //// [awaitBinaryExpression3_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = (yield p) + a; "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.js b/tests/baselines/reference/awaitBinaryExpression4_es6.js index 0eec5e990a5..c8f42d191c0 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.js @@ -9,9 +9,9 @@ async function func(): Promise { //// [awaitBinaryExpression4_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = yield p, a; "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.js b/tests/baselines/reference/awaitBinaryExpression5_es6.js index d725d55404a..1c867a8abbf 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.js @@ -10,10 +10,10 @@ async function func(): Promise { //// [awaitBinaryExpression5_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var o; o.a = yield p; "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression1_es6.js b/tests/baselines/reference/awaitCallExpression1_es6.js index 3391274ae7a..dc73da972ac 100644 --- a/tests/baselines/reference/awaitCallExpression1_es6.js +++ b/tests/baselines/reference/awaitCallExpression1_es6.js @@ -13,9 +13,9 @@ async function func(): Promise { //// [awaitCallExpression1_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = fn(a, a, a); "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression2_es6.js b/tests/baselines/reference/awaitCallExpression2_es6.js index fd7129e8418..a0f0944d796 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.js +++ b/tests/baselines/reference/awaitCallExpression2_es6.js @@ -13,9 +13,9 @@ async function func(): Promise { //// [awaitCallExpression2_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = fn(yield p, a, a); "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression3_es6.js b/tests/baselines/reference/awaitCallExpression3_es6.js index 4f0d55185e2..75e77883993 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.js +++ b/tests/baselines/reference/awaitCallExpression3_es6.js @@ -13,9 +13,9 @@ async function func(): Promise { //// [awaitCallExpression3_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = fn(a, yield p, a); "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression4_es6.js b/tests/baselines/reference/awaitCallExpression4_es6.js index 7ec6c6ff90e..8f1756393cb 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.js +++ b/tests/baselines/reference/awaitCallExpression4_es6.js @@ -13,9 +13,9 @@ async function func(): Promise { //// [awaitCallExpression4_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = (yield pfn)(a, a, a); "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression5_es6.js b/tests/baselines/reference/awaitCallExpression5_es6.js index f41d0ae994f..0752c02758b 100644 --- a/tests/baselines/reference/awaitCallExpression5_es6.js +++ b/tests/baselines/reference/awaitCallExpression5_es6.js @@ -13,9 +13,9 @@ async function func(): Promise { //// [awaitCallExpression5_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = o.fn(a, a, a); "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression6_es6.js b/tests/baselines/reference/awaitCallExpression6_es6.js index d6c0e370748..3fc683dc399 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.js +++ b/tests/baselines/reference/awaitCallExpression6_es6.js @@ -13,9 +13,9 @@ async function func(): Promise { //// [awaitCallExpression6_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = o.fn(yield p, a, a); "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression7_es6.js b/tests/baselines/reference/awaitCallExpression7_es6.js index 45e8a9fa646..8618313587a 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.js +++ b/tests/baselines/reference/awaitCallExpression7_es6.js @@ -13,9 +13,9 @@ async function func(): Promise { //// [awaitCallExpression7_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = o.fn(a, yield p, a); "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression8_es6.js b/tests/baselines/reference/awaitCallExpression8_es6.js index 3ffac0006ae..ceab826c58a 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.js +++ b/tests/baselines/reference/awaitCallExpression8_es6.js @@ -13,9 +13,9 @@ async function func(): Promise { //// [awaitCallExpression8_es6.js] function func() { - return __awaiter(function *() { + return __awaiter(function* () { "before"; var b = (yield po).fn(a, a, a); "after"; - }.apply(this, arguments), Promise); + }, this, void 0, Promise); } From 3c59481a92370f2c11c512f447bef21d6aec8f1f Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Thu, 4 Jun 2015 16:06:12 -0700 Subject: [PATCH 079/309] Add missing overloads for texImage2D and texSubImage2D --- src/lib/dom.generated.d.ts | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts index 5a4151c0c1c..e1f06f11009 100644 --- a/src/lib/dom.generated.d.ts +++ b/src/lib/dom.generated.d.ts @@ -7677,10 +7677,10 @@ declare var MediaQueryList: { interface MediaSource extends EventTarget { activeSourceBuffers: SourceBufferList; duration: number; - readyState: string; + readyState: number; sourceBuffers: SourceBufferList; addSourceBuffer(type: string): SourceBuffer; - endOfStream(error?: string): void; + endOfStream(error?: number): void; removeSourceBuffer(sourceBuffer: SourceBuffer): void; } @@ -8409,7 +8409,7 @@ declare var PopStateEvent: { interface Position { coords: Coordinates; - timestamp: Date; + timestamp: number; } declare var Position: { @@ -11090,9 +11090,17 @@ interface WebGLRenderingContext { stencilMaskSeparate(face: number, mask: number): void; stencilOp(fail: number, zfail: number, zpass: number): void; stencilOpSeparate(face: number, fail: number, zfail: number, zpass: number): void; + texImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, image: HTMLImageElement): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, canvas: HTMLCanvasElement): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, video: HTMLVideoElement): void; texImage2D(target: number, level: number, internalformat: number, format: number, type: number, pixels: ImageData): void; texParameterf(target: number, pname: number, param: number): void; texParameteri(target: number, pname: number, param: number): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, type: number, pixels: ArrayBufferView): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, image: HTMLImageElement): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, canvas: HTMLCanvasElement): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, video: HTMLVideoElement): void; texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, pixels: ImageData): void; uniform1f(location: WebGLUniformLocation, x: number): void; uniform1fv(location: WebGLUniformLocation, v: any): void; @@ -12332,10 +12340,11 @@ interface DocumentEvent { createEvent(eventInterface:"AriaRequestEvent"): AriaRequestEvent; createEvent(eventInterface:"AudioProcessingEvent"): AudioProcessingEvent; createEvent(eventInterface:"BeforeUnloadEvent"): BeforeUnloadEvent; + createEvent(eventInterface:"ClipboardEvent"): ClipboardEvent; createEvent(eventInterface:"CloseEvent"): CloseEvent; createEvent(eventInterface:"CommandEvent"): CommandEvent; createEvent(eventInterface:"CompositionEvent"): CompositionEvent; - createEvent(eventInterface: "CustomEvent"): CustomEvent; + createEvent(eventInterface:"CustomEvent"): CustomEvent; createEvent(eventInterface:"DeviceMotionEvent"): DeviceMotionEvent; createEvent(eventInterface:"DeviceOrientationEvent"): DeviceOrientationEvent; createEvent(eventInterface:"DragEvent"): DragEvent; @@ -12358,8 +12367,6 @@ interface DocumentEvent { createEvent(eventInterface:"MouseEvent"): MouseEvent; createEvent(eventInterface:"MouseEvents"): MouseEvent; createEvent(eventInterface:"MouseWheelEvent"): MouseWheelEvent; - createEvent(eventInterface:"MSGestureEvent"): MSGestureEvent; - createEvent(eventInterface:"MSPointerEvent"): MSPointerEvent; createEvent(eventInterface:"MutationEvent"): MutationEvent; createEvent(eventInterface:"MutationEvents"): MutationEvent; createEvent(eventInterface:"NavigationCompletedEvent"): NavigationCompletedEvent; @@ -12971,4 +12978,4 @@ declare function addEventListener(type: "unload", listener: (ev: Event) => any, declare function addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "wheel", listener: (ev: WheelEvent) => any, useCapture?: boolean): void; -declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; \ No newline at end of file +declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; From 6f45524b9ff0f35ac75dd7889ee817bcbb14fe50 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Thu, 4 Jun 2015 16:35:30 -0700 Subject: [PATCH 080/309] Update LKG --- bin/lib.d.ts | 20 ++++++++++++++------ bin/lib.dom.d.ts | 21 ++++++++++++++------- bin/lib.es6.d.ts | 20 ++++++++++++++------ bin/tsc.js | 13 +++++++++---- bin/tsserver.js | 13 +++++++++---- bin/typescript.js | 18 ++++++++++++++---- bin/typescriptServices.js | 18 ++++++++++++++---- 7 files changed, 88 insertions(+), 35 deletions(-) diff --git a/bin/lib.d.ts b/bin/lib.d.ts index e583f1ac783..4724459e73d 100644 --- a/bin/lib.d.ts +++ b/bin/lib.d.ts @@ -11335,10 +11335,10 @@ declare var MediaQueryList: { interface MediaSource extends EventTarget { activeSourceBuffers: SourceBufferList; duration: number; - readyState: string; + readyState: number; sourceBuffers: SourceBufferList; addSourceBuffer(type: string): SourceBuffer; - endOfStream(error?: string): void; + endOfStream(error?: number): void; removeSourceBuffer(sourceBuffer: SourceBuffer): void; } @@ -12067,7 +12067,7 @@ declare var PopStateEvent: { interface Position { coords: Coordinates; - timestamp: Date; + timestamp: number; } declare var Position: { @@ -14748,9 +14748,17 @@ interface WebGLRenderingContext { stencilMaskSeparate(face: number, mask: number): void; stencilOp(fail: number, zfail: number, zpass: number): void; stencilOpSeparate(face: number, fail: number, zfail: number, zpass: number): void; + texImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, image: HTMLImageElement): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, canvas: HTMLCanvasElement): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, video: HTMLVideoElement): void; texImage2D(target: number, level: number, internalformat: number, format: number, type: number, pixels: ImageData): void; texParameterf(target: number, pname: number, param: number): void; texParameteri(target: number, pname: number, param: number): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, type: number, pixels: ArrayBufferView): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, image: HTMLImageElement): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, canvas: HTMLCanvasElement): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, video: HTMLVideoElement): void; texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, pixels: ImageData): void; uniform1f(location: WebGLUniformLocation, x: number): void; uniform1fv(location: WebGLUniformLocation, v: any): void; @@ -15990,10 +15998,11 @@ interface DocumentEvent { createEvent(eventInterface:"AriaRequestEvent"): AriaRequestEvent; createEvent(eventInterface:"AudioProcessingEvent"): AudioProcessingEvent; createEvent(eventInterface:"BeforeUnloadEvent"): BeforeUnloadEvent; + createEvent(eventInterface:"ClipboardEvent"): ClipboardEvent; createEvent(eventInterface:"CloseEvent"): CloseEvent; createEvent(eventInterface:"CommandEvent"): CommandEvent; createEvent(eventInterface:"CompositionEvent"): CompositionEvent; - createEvent(eventInterface: "CustomEvent"): CustomEvent; + createEvent(eventInterface:"CustomEvent"): CustomEvent; createEvent(eventInterface:"DeviceMotionEvent"): DeviceMotionEvent; createEvent(eventInterface:"DeviceOrientationEvent"): DeviceOrientationEvent; createEvent(eventInterface:"DragEvent"): DragEvent; @@ -16016,8 +16025,6 @@ interface DocumentEvent { createEvent(eventInterface:"MouseEvent"): MouseEvent; createEvent(eventInterface:"MouseEvents"): MouseEvent; createEvent(eventInterface:"MouseWheelEvent"): MouseWheelEvent; - createEvent(eventInterface:"MSGestureEvent"): MSGestureEvent; - createEvent(eventInterface:"MSPointerEvent"): MSPointerEvent; createEvent(eventInterface:"MutationEvent"): MutationEvent; createEvent(eventInterface:"MutationEvents"): MutationEvent; createEvent(eventInterface:"NavigationCompletedEvent"): NavigationCompletedEvent; @@ -16630,6 +16637,7 @@ declare function addEventListener(type: "volumechange", listener: (ev: Event) => declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "wheel", listener: (ev: WheelEvent) => any, useCapture?: boolean): void; declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; + ///////////////////////////// /// WorkerGlobalScope APIs ///////////////////////////// diff --git a/bin/lib.dom.d.ts b/bin/lib.dom.d.ts index 142486a1662..7d83676acc7 100644 --- a/bin/lib.dom.d.ts +++ b/bin/lib.dom.d.ts @@ -10165,10 +10165,10 @@ declare var MediaQueryList: { interface MediaSource extends EventTarget { activeSourceBuffers: SourceBufferList; duration: number; - readyState: string; + readyState: number; sourceBuffers: SourceBufferList; addSourceBuffer(type: string): SourceBuffer; - endOfStream(error?: string): void; + endOfStream(error?: number): void; removeSourceBuffer(sourceBuffer: SourceBuffer): void; } @@ -10897,7 +10897,7 @@ declare var PopStateEvent: { interface Position { coords: Coordinates; - timestamp: Date; + timestamp: number; } declare var Position: { @@ -13578,9 +13578,17 @@ interface WebGLRenderingContext { stencilMaskSeparate(face: number, mask: number): void; stencilOp(fail: number, zfail: number, zpass: number): void; stencilOpSeparate(face: number, fail: number, zfail: number, zpass: number): void; + texImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, image: HTMLImageElement): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, canvas: HTMLCanvasElement): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, video: HTMLVideoElement): void; texImage2D(target: number, level: number, internalformat: number, format: number, type: number, pixels: ImageData): void; texParameterf(target: number, pname: number, param: number): void; texParameteri(target: number, pname: number, param: number): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, type: number, pixels: ArrayBufferView): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, image: HTMLImageElement): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, canvas: HTMLCanvasElement): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, video: HTMLVideoElement): void; texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, pixels: ImageData): void; uniform1f(location: WebGLUniformLocation, x: number): void; uniform1fv(location: WebGLUniformLocation, v: any): void; @@ -14820,10 +14828,11 @@ interface DocumentEvent { createEvent(eventInterface:"AriaRequestEvent"): AriaRequestEvent; createEvent(eventInterface:"AudioProcessingEvent"): AudioProcessingEvent; createEvent(eventInterface:"BeforeUnloadEvent"): BeforeUnloadEvent; + createEvent(eventInterface:"ClipboardEvent"): ClipboardEvent; createEvent(eventInterface:"CloseEvent"): CloseEvent; createEvent(eventInterface:"CommandEvent"): CommandEvent; createEvent(eventInterface:"CompositionEvent"): CompositionEvent; - createEvent(eventInterface: "CustomEvent"): CustomEvent; + createEvent(eventInterface:"CustomEvent"): CustomEvent; createEvent(eventInterface:"DeviceMotionEvent"): DeviceMotionEvent; createEvent(eventInterface:"DeviceOrientationEvent"): DeviceOrientationEvent; createEvent(eventInterface:"DragEvent"): DragEvent; @@ -14846,8 +14855,6 @@ interface DocumentEvent { createEvent(eventInterface:"MouseEvent"): MouseEvent; createEvent(eventInterface:"MouseEvents"): MouseEvent; createEvent(eventInterface:"MouseWheelEvent"): MouseWheelEvent; - createEvent(eventInterface:"MSGestureEvent"): MSGestureEvent; - createEvent(eventInterface:"MSPointerEvent"): MSPointerEvent; createEvent(eventInterface:"MutationEvent"): MutationEvent; createEvent(eventInterface:"MutationEvents"): MutationEvent; createEvent(eventInterface:"NavigationCompletedEvent"): NavigationCompletedEvent; @@ -15459,4 +15466,4 @@ declare function addEventListener(type: "unload", listener: (ev: Event) => any, declare function addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "wheel", listener: (ev: WheelEvent) => any, useCapture?: boolean): void; -declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; \ No newline at end of file +declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; diff --git a/bin/lib.es6.d.ts b/bin/lib.es6.d.ts index d6ca7245140..396361a49f5 100644 --- a/bin/lib.es6.d.ts +++ b/bin/lib.es6.d.ts @@ -12716,10 +12716,10 @@ declare var MediaQueryList: { interface MediaSource extends EventTarget { activeSourceBuffers: SourceBufferList; duration: number; - readyState: string; + readyState: number; sourceBuffers: SourceBufferList; addSourceBuffer(type: string): SourceBuffer; - endOfStream(error?: string): void; + endOfStream(error?: number): void; removeSourceBuffer(sourceBuffer: SourceBuffer): void; } @@ -13448,7 +13448,7 @@ declare var PopStateEvent: { interface Position { coords: Coordinates; - timestamp: Date; + timestamp: number; } declare var Position: { @@ -16129,9 +16129,17 @@ interface WebGLRenderingContext { stencilMaskSeparate(face: number, mask: number): void; stencilOp(fail: number, zfail: number, zpass: number): void; stencilOpSeparate(face: number, fail: number, zfail: number, zpass: number): void; + texImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, image: HTMLImageElement): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, canvas: HTMLCanvasElement): void; + texImage2D(target: number, level: number, internalformat: number, format: number, type: number, video: HTMLVideoElement): void; texImage2D(target: number, level: number, internalformat: number, format: number, type: number, pixels: ImageData): void; texParameterf(target: number, pname: number, param: number): void; texParameteri(target: number, pname: number, param: number): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, type: number, pixels: ArrayBufferView): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, image: HTMLImageElement): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, canvas: HTMLCanvasElement): void; + texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, video: HTMLVideoElement): void; texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, pixels: ImageData): void; uniform1f(location: WebGLUniformLocation, x: number): void; uniform1fv(location: WebGLUniformLocation, v: any): void; @@ -17371,10 +17379,11 @@ interface DocumentEvent { createEvent(eventInterface:"AriaRequestEvent"): AriaRequestEvent; createEvent(eventInterface:"AudioProcessingEvent"): AudioProcessingEvent; createEvent(eventInterface:"BeforeUnloadEvent"): BeforeUnloadEvent; + createEvent(eventInterface:"ClipboardEvent"): ClipboardEvent; createEvent(eventInterface:"CloseEvent"): CloseEvent; createEvent(eventInterface:"CommandEvent"): CommandEvent; createEvent(eventInterface:"CompositionEvent"): CompositionEvent; - createEvent(eventInterface: "CustomEvent"): CustomEvent; + createEvent(eventInterface:"CustomEvent"): CustomEvent; createEvent(eventInterface:"DeviceMotionEvent"): DeviceMotionEvent; createEvent(eventInterface:"DeviceOrientationEvent"): DeviceOrientationEvent; createEvent(eventInterface:"DragEvent"): DragEvent; @@ -17397,8 +17406,6 @@ interface DocumentEvent { createEvent(eventInterface:"MouseEvent"): MouseEvent; createEvent(eventInterface:"MouseEvents"): MouseEvent; createEvent(eventInterface:"MouseWheelEvent"): MouseWheelEvent; - createEvent(eventInterface:"MSGestureEvent"): MSGestureEvent; - createEvent(eventInterface:"MSPointerEvent"): MSPointerEvent; createEvent(eventInterface:"MutationEvent"): MutationEvent; createEvent(eventInterface:"MutationEvents"): MutationEvent; createEvent(eventInterface:"NavigationCompletedEvent"): NavigationCompletedEvent; @@ -18011,6 +18018,7 @@ declare function addEventListener(type: "volumechange", listener: (ev: Event) => declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "wheel", listener: (ev: WheelEvent) => any, useCapture?: boolean): void; declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; + ///////////////////////////// /// WorkerGlobalScope APIs ///////////////////////////// diff --git a/bin/tsc.js b/bin/tsc.js index a6d28976046..e7a41e8aa7e 100644 --- a/bin/tsc.js +++ b/bin/tsc.js @@ -21533,7 +21533,12 @@ var ts; return result; } function parenthesizeForAccess(expr) { - if (ts.isLeftHandSideExpression(expr) && expr.kind !== 159 && expr.kind !== 7) { + while (expr.kind === 161) { + expr = expr.expression; + } + if (ts.isLeftHandSideExpression(expr) && + expr.kind !== 159 && + expr.kind !== 7) { return expr; } var node = ts.createSynthesizedNode(162); @@ -21740,7 +21745,7 @@ var ts; } } function emitParenExpression(node) { - if (!node.parent || node.parent.kind !== 164) { + if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 164) { if (node.expression.kind === 161) { var operand = node.expression.expression; while (operand.kind == 161) { @@ -23727,7 +23732,7 @@ var ts; emitDeclarationName(node); write("\", "); emitDeclarationName(node); - write(")"); + write(");"); } emitExportMemberAssignments(node.name); } @@ -23835,7 +23840,7 @@ var ts; emitDeclarationName(node); write("\", "); emitDeclarationName(node); - write(")"); + write(");"); } emitExportMemberAssignments(node.name); } diff --git a/bin/tsserver.js b/bin/tsserver.js index 194f0768196..8536491127d 100644 --- a/bin/tsserver.js +++ b/bin/tsserver.js @@ -21923,7 +21923,12 @@ var ts; return result; } function parenthesizeForAccess(expr) { - if (ts.isLeftHandSideExpression(expr) && expr.kind !== 159 && expr.kind !== 7) { + while (expr.kind === 161) { + expr = expr.expression; + } + if (ts.isLeftHandSideExpression(expr) && + expr.kind !== 159 && + expr.kind !== 7) { return expr; } var node = ts.createSynthesizedNode(162); @@ -22130,7 +22135,7 @@ var ts; } } function emitParenExpression(node) { - if (!node.parent || node.parent.kind !== 164) { + if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 164) { if (node.expression.kind === 161) { var operand = node.expression.expression; while (operand.kind == 161) { @@ -24117,7 +24122,7 @@ var ts; emitDeclarationName(node); write("\", "); emitDeclarationName(node); - write(")"); + write(");"); } emitExportMemberAssignments(node.name); } @@ -24225,7 +24230,7 @@ var ts; emitDeclarationName(node); write("\", "); emitDeclarationName(node); - write(")"); + write(");"); } emitExportMemberAssignments(node.name); } diff --git a/bin/typescript.js b/bin/typescript.js index dac610e2504..b393f2ee881 100644 --- a/bin/typescript.js +++ b/bin/typescript.js @@ -25628,6 +25628,11 @@ var ts; return result; } function parenthesizeForAccess(expr) { + // When diagnosing whether the expression needs parentheses, the decision should be based + // on the innermost expression in a chain of nested type assertions. + while (expr.kind === 161 /* TypeAssertionExpression */) { + expr = expr.expression; + } // isLeftHandSideExpression is almost the correct criterion for when it is not necessary // to parenthesize the expression before a dot. The known exceptions are: // @@ -25636,7 +25641,9 @@ var ts; // NumberLiteral // 1.x -> not the same as (1).x // - if (ts.isLeftHandSideExpression(expr) && expr.kind !== 159 /* NewExpression */ && expr.kind !== 7 /* NumericLiteral */) { + if (ts.isLeftHandSideExpression(expr) && + expr.kind !== 159 /* NewExpression */ && + expr.kind !== 7 /* NumericLiteral */) { return expr; } var node = ts.createSynthesizedNode(162 /* ParenthesizedExpression */); @@ -25867,7 +25874,10 @@ var ts; } } function emitParenExpression(node) { - if (!node.parent || node.parent.kind !== 164 /* ArrowFunction */) { + // If the node is synthesized, it means the emitter put the parentheses there, + // not the user. If we didn't want them, the emitter would not have put them + // there. + if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 164 /* ArrowFunction */) { if (node.expression.kind === 161 /* TypeAssertionExpression */) { var operand = node.expression.expression; // Make sure we consider all nested cast expressions, e.g.: @@ -28149,7 +28159,7 @@ var ts; emitDeclarationName(node); write("\", "); emitDeclarationName(node); - write(")"); + write(");"); } emitExportMemberAssignments(node.name); } @@ -28259,7 +28269,7 @@ var ts; emitDeclarationName(node); write("\", "); emitDeclarationName(node); - write(")"); + write(");"); } emitExportMemberAssignments(node.name); } diff --git a/bin/typescriptServices.js b/bin/typescriptServices.js index dac610e2504..b393f2ee881 100644 --- a/bin/typescriptServices.js +++ b/bin/typescriptServices.js @@ -25628,6 +25628,11 @@ var ts; return result; } function parenthesizeForAccess(expr) { + // When diagnosing whether the expression needs parentheses, the decision should be based + // on the innermost expression in a chain of nested type assertions. + while (expr.kind === 161 /* TypeAssertionExpression */) { + expr = expr.expression; + } // isLeftHandSideExpression is almost the correct criterion for when it is not necessary // to parenthesize the expression before a dot. The known exceptions are: // @@ -25636,7 +25641,9 @@ var ts; // NumberLiteral // 1.x -> not the same as (1).x // - if (ts.isLeftHandSideExpression(expr) && expr.kind !== 159 /* NewExpression */ && expr.kind !== 7 /* NumericLiteral */) { + if (ts.isLeftHandSideExpression(expr) && + expr.kind !== 159 /* NewExpression */ && + expr.kind !== 7 /* NumericLiteral */) { return expr; } var node = ts.createSynthesizedNode(162 /* ParenthesizedExpression */); @@ -25867,7 +25874,10 @@ var ts; } } function emitParenExpression(node) { - if (!node.parent || node.parent.kind !== 164 /* ArrowFunction */) { + // If the node is synthesized, it means the emitter put the parentheses there, + // not the user. If we didn't want them, the emitter would not have put them + // there. + if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 164 /* ArrowFunction */) { if (node.expression.kind === 161 /* TypeAssertionExpression */) { var operand = node.expression.expression; // Make sure we consider all nested cast expressions, e.g.: @@ -28149,7 +28159,7 @@ var ts; emitDeclarationName(node); write("\", "); emitDeclarationName(node); - write(")"); + write(");"); } emitExportMemberAssignments(node.name); } @@ -28259,7 +28269,7 @@ var ts; emitDeclarationName(node); write("\", "); emitDeclarationName(node); - write(")"); + write(");"); } emitExportMemberAssignments(node.name); } From 7c8a50336d6c1bb56d0daef91cf52d05fc12ff56 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Wed, 3 Jun 2015 14:55:42 -0700 Subject: [PATCH 081/309] emit module name for system modules, add moduleName argument to 'transpile' function Conflicts: src/services/services.ts --- src/compiler/emitter.ts | 10 +++++++--- src/compiler/parser.ts | 2 +- src/compiler/types.ts | 2 +- src/services/services.ts | 7 +++++-- .../baselines/reference/systemModule12.errors.txt | 10 ++++++++++ tests/baselines/reference/systemModule12.js | 14 ++++++++++++++ tests/cases/compiler/systemModule12.ts | 5 +++++ 7 files changed, 43 insertions(+), 7 deletions(-) create mode 100644 tests/baselines/reference/systemModule12.errors.txt create mode 100644 tests/baselines/reference/systemModule12.js create mode 100644 tests/cases/compiler/systemModule12.ts diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 165f0da5cfd..7d0a29f9e26 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -5477,7 +5477,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { Debug.assert(!exportFunctionForFile); // make sure that name of 'exports' function does not conflict with existing identifiers exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write(`"${node.moduleName}", `); + } + write("[") for (let i = 0; i < externalImports.length; ++i) { let text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -5563,8 +5567,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, /*includeNonAmdDependencies*/ true); write(") {"); diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 055fc1b6f74..07da065c1ae 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -4820,7 +4820,7 @@ module ts { sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile: SourceFile) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 1db5e57d298..1a72e9fc94a 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1001,7 +1001,7 @@ module ts { text: string; amdDependencies: {path: string; name: string}[]; - amdModuleName: string; + moduleName: string; referencedFiles: FileReference[]; hasNoDefaultLib: boolean; diff --git a/src/services/services.ts b/src/services/services.ts index 6a497c87307..ece411ae1ea 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -735,7 +735,7 @@ module ts { public endOfFileToken: Node; public amdDependencies: { name: string; path: string }[]; - public amdModuleName: string; + public moduleName: string; public referencedFiles: FileReference[]; public syntacticDiagnostics: Diagnostic[]; @@ -1766,7 +1766,7 @@ module ts { * - noLib = true * - noResolve = true */ - export function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string { + export function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string { let options = compilerOptions ? clone(compilerOptions) : getDefaultCompilerOptions(); options.isolatedModules = true; @@ -1785,6 +1785,9 @@ module ts { // Parse let inputFileName = fileName || "module.ts"; let sourceFile = createSourceFile(inputFileName, input, options.target); + if (moduleName) { + sourceFile.moduleName = moduleName; + } // Store syntactic diagnostics if (diagnostics && sourceFile.parseDiagnostics) { diff --git a/tests/baselines/reference/systemModule12.errors.txt b/tests/baselines/reference/systemModule12.errors.txt new file mode 100644 index 00000000000..5c89e2e65d6 --- /dev/null +++ b/tests/baselines/reference/systemModule12.errors.txt @@ -0,0 +1,10 @@ +tests/cases/compiler/systemModule12.ts(3,15): error TS2307: Cannot find module 'file1'. + + +==== tests/cases/compiler/systemModule12.ts (1 errors) ==== + + /// + import n from 'file1' + ~~~~~~~ +!!! error TS2307: Cannot find module 'file1'. + \ No newline at end of file diff --git a/tests/baselines/reference/systemModule12.js b/tests/baselines/reference/systemModule12.js new file mode 100644 index 00000000000..0b5f5a3e850 --- /dev/null +++ b/tests/baselines/reference/systemModule12.js @@ -0,0 +1,14 @@ +//// [systemModule12.ts] + +/// +import n from 'file1' + + +//// [systemModule12.js] +System.register("NamedModule", [], function(exports_1) { + return { + setters:[], + execute: function() { + } + } +}); diff --git a/tests/cases/compiler/systemModule12.ts b/tests/cases/compiler/systemModule12.ts new file mode 100644 index 00000000000..690fabc0a28 --- /dev/null +++ b/tests/cases/compiler/systemModule12.ts @@ -0,0 +1,5 @@ +// @module: system +// @isolatedModules: true + +/// +import n from 'file1' From 3c630aa247e079af94a6dd045a7d07cad7cb2b26 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Thu, 4 Jun 2015 22:22:25 -0700 Subject: [PATCH 082/309] added tests --- tests/cases/unittests/transpile.ts | 33 +++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/tests/cases/unittests/transpile.ts b/tests/cases/unittests/transpile.ts index c906c03a9e0..7aa9106880b 100644 --- a/tests/cases/unittests/transpile.ts +++ b/tests/cases/unittests/transpile.ts @@ -3,9 +3,9 @@ module ts { describe("Transpile", () => { - function runTest(input: string, compilerOptions: ts.CompilerOptions = {}, expectedOutput?: string, expectedDiagnosticCodes: number[] = []): void { + function runTest(input: string, compilerOptions: ts.CompilerOptions = {}, moduleName?: string, expectedOutput?: string, expectedDiagnosticCodes: number[] = []): void { let diagnostics: Diagnostic[] = []; - let result = transpile(input, compilerOptions, "file.ts", diagnostics); + let result = transpile(input, compilerOptions, "file.ts", diagnostics, moduleName); for (let i = 0; i < expectedDiagnosticCodes.length; i++) { assert.equal(expectedDiagnosticCodes[i], diagnostics[i] && diagnostics[i].code, `Could not find expeced diagnostic.`); @@ -19,41 +19,54 @@ module ts { it("Generates correct compilerOptions diagnostics", () => { // Expecting 5047: "Option 'isolatedModules' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher." - runTest(`var x = 0;`, {}, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ [5047]); + runTest(`var x = 0;`, {}, /*moduleName*/undefined, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ [5047]); }); it("Generates no diagnostics with valid inputs", () => { // No errors - runTest(`var x = 0;`, { module: ModuleKind.CommonJS }, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ []); + runTest(`var x = 0;`, { module: ModuleKind.CommonJS }, /*moduleName*/undefined, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ []); }); it("Generates no diagnostics for missing file references", () => { runTest(`/// var x = 0;`, - { module: ModuleKind.CommonJS }, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ []); + { module: ModuleKind.CommonJS }, /*moduleName*/undefined, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ []); }); it("Generates no diagnostics for missing module imports", () => { runTest(`import {a} from "module2";`, - { module: ModuleKind.CommonJS }, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ []); + { module: ModuleKind.CommonJS }, /*moduleName*/undefined, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ []); }); it("Generates expected syntactic diagnostics", () => { runTest(`a b`, - { module: ModuleKind.CommonJS }, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ [1005]); /// 1005: ';' Expected + { module: ModuleKind.CommonJS }, /*moduleName*/undefined, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ [1005]); /// 1005: ';' Expected }); it("Does not generate semantic diagnostics", () => { runTest(`var x: string = 0;`, - { module: ModuleKind.CommonJS }, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ []); + { module: ModuleKind.CommonJS }, /*moduleName*/undefined, /*expectedOutput*/ undefined, /*expectedDiagnosticCodes*/ []); }); it("Generates module output", () => { - runTest(`var x = 0;`, { module: ModuleKind.AMD }, `define(["require", "exports"], function (require, exports) {\r\n var x = 0;\r\n});\r\n`); + runTest(`var x = 0;`, { module: ModuleKind.AMD }, /*moduleName*/undefined, `define(["require", "exports"], function (require, exports) {\r\n var x = 0;\r\n});\r\n`); }); it("Uses correct newLine character", () => { - runTest(`var x = 0;`, { module: ModuleKind.CommonJS, newLine: NewLineKind.LineFeed }, `var x = 0;\n`, /*expectedDiagnosticCodes*/ []); + runTest(`var x = 0;`, { module: ModuleKind.CommonJS, newLine: NewLineKind.LineFeed }, /*moduleName*/undefined, `var x = 0;\n`, /*expectedDiagnosticCodes*/ []); + }); + + it("Sets module name", () => { + let output = + `System.register("NamedModule", [], function(exports_1) {\n var x;\n` + + ` return {\n` + + ` setters:[],\n` + + ` execute: function() {\n` + + ` var x = 1;\n` + + ` }\n` + + ` }\n` + + `});\n`; + runTest("var x = 1;", { module: ModuleKind.System, newLine: NewLineKind.LineFeed }, "NamedModule", output) }); }); } From 26a1ed60171236ea9af4dcc2991537d134eb3164 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Mon, 8 Jun 2015 18:31:56 -0700 Subject: [PATCH 083/309] move temp declarations out of object literal --- src/compiler/emitter.ts | 2 +- tests/baselines/reference/systemModule8.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 165f0da5cfd..5919e62633a 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -5327,10 +5327,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(/*newLine*/ true) decreaseIndent(); writeLine(); write("}"); // return + emitTempDeclarations(/*newLine*/ true) } function emitSetters(exportStarFunction: string) { diff --git a/tests/baselines/reference/systemModule8.js b/tests/baselines/reference/systemModule8.js index 578814d0ab2..14f7a4c6fbe 100644 --- a/tests/baselines/reference/systemModule8.js +++ b/tests/baselines/reference/systemModule8.js @@ -66,6 +66,6 @@ System.register([], function(exports_1) { exports_1("x", x = _b[_i][0]); } } - var _a; } + var _a; }); From 185b2aff088b0c8ad0bf6b04b7511f0bbd5ed146 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Mon, 8 Jun 2015 22:46:59 -0700 Subject: [PATCH 084/309] added missing semicolon --- src/compiler/emitter.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 5919e62633a..857a5404524 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -5330,7 +5330,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { decreaseIndent(); writeLine(); write("}"); // return - emitTempDeclarations(/*newLine*/ true) + emitTempDeclarations(/*newLine*/ true); } function emitSetters(exportStarFunction: string) { From 02557b140310f3247edf5e881da43640cc72b093 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Tue, 9 Jun 2015 14:50:46 -0700 Subject: [PATCH 085/309] Emit awaiter arguments on new line --- src/compiler/emitter.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 66cdebe4ee8..d5eb314c478 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -3476,7 +3476,9 @@ var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, emitFunctionBody(node); // Emit the current `this` binding. - write(", this"); + write(","); + writeLine(); + write("this"); // Optionally emit the lexical arguments. if (hasLexicalArguments) { From 371583b1eee87bbf923e1e04b9ac2d5ab31c4790 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Tue, 9 Jun 2015 17:08:15 -0700 Subject: [PATCH 086/309] Update baselines for emit change --- tests/baselines/reference/asyncArrowFunction1_es6.js | 3 ++- tests/baselines/reference/asyncArrowFunction6_es6.js | 3 ++- tests/baselines/reference/asyncArrowFunction7_es6.js | 6 ++++-- tests/baselines/reference/asyncArrowFunction8_es6.js | 3 ++- tests/baselines/reference/asyncArrowFunction9_es6.js | 3 ++- .../reference/asyncArrowFunctionCapturesArguments_es6.js | 3 ++- .../reference/asyncArrowFunctionCapturesThis_es6.js | 3 ++- tests/baselines/reference/asyncFunctionDeclaration10_es6.js | 3 ++- tests/baselines/reference/asyncFunctionDeclaration11_es6.js | 3 ++- tests/baselines/reference/asyncFunctionDeclaration13_es6.js | 3 ++- tests/baselines/reference/asyncFunctionDeclaration14_es6.js | 3 ++- tests/baselines/reference/asyncFunctionDeclaration1_es6.js | 3 ++- tests/baselines/reference/asyncFunctionDeclaration6_es6.js | 3 ++- tests/baselines/reference/asyncFunctionDeclaration7_es6.js | 6 ++++-- tests/baselines/reference/asyncFunctionDeclaration9_es6.js | 3 ++- tests/baselines/reference/awaitBinaryExpression1_es6.js | 3 ++- tests/baselines/reference/awaitBinaryExpression2_es6.js | 3 ++- tests/baselines/reference/awaitBinaryExpression3_es6.js | 3 ++- tests/baselines/reference/awaitBinaryExpression4_es6.js | 3 ++- tests/baselines/reference/awaitBinaryExpression5_es6.js | 3 ++- tests/baselines/reference/awaitCallExpression1_es6.js | 3 ++- tests/baselines/reference/awaitCallExpression2_es6.js | 3 ++- tests/baselines/reference/awaitCallExpression3_es6.js | 3 ++- tests/baselines/reference/awaitCallExpression4_es6.js | 3 ++- tests/baselines/reference/awaitCallExpression5_es6.js | 3 ++- tests/baselines/reference/awaitCallExpression6_es6.js | 3 ++- tests/baselines/reference/awaitCallExpression7_es6.js | 3 ++- tests/baselines/reference/awaitCallExpression8_es6.js | 3 ++- 28 files changed, 60 insertions(+), 30 deletions(-) diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js index 4ce29929de8..257b147dbc7 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.js +++ b/tests/baselines/reference/asyncArrowFunction1_es6.js @@ -5,4 +5,5 @@ var foo = async (): Promise => { //// [asyncArrowFunction1_es6.js] var foo = () => __awaiter(function* () { -}, this, void 0, Promise); +}, +this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js index 1554e895d14..48035057fe0 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.js +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -5,4 +5,5 @@ var foo = async (a = await): Promise => { //// [asyncArrowFunction6_es6.js] var foo = (a = await) => __awaiter(function* () { -}, this, void 0, Promise); +}, +this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js index 459ec413da5..6f8cf6141a8 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.js +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -10,5 +10,7 @@ var bar = async (): Promise => { var bar = () => __awaiter(function* () { // 'await' here is an identifier, and not an await expression. var foo = (a = await) => __awaiter(function* () { - }, this, void 0, Promise); -}, this, void 0, Promise); + }, + this, void 0, Promise); +}, +this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js index b32541fdda6..e4383a16220 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es6.js +++ b/tests/baselines/reference/asyncArrowFunction8_es6.js @@ -7,4 +7,5 @@ var foo = async (): Promise => { //// [asyncArrowFunction8_es6.js] var foo = () => __awaiter(function* () { var v = { [yield ]: foo }; -}, this, void 0, Promise); +}, +this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.js b/tests/baselines/reference/asyncArrowFunction9_es6.js index 8a9b663266c..42511dd87f5 100644 --- a/tests/baselines/reference/asyncArrowFunction9_es6.js +++ b/tests/baselines/reference/asyncArrowFunction9_es6.js @@ -4,4 +4,5 @@ var foo = async (a = await => await): Promise => { //// [asyncArrowFunction9_es6.js] var foo = (a = await => await) => __awaiter(function* () { -}, this, void 0, Promise); +}, +this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js index 86a1b6e110c..888c935cc3f 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js @@ -11,6 +11,7 @@ class C { class C { method() { function other() { } - var fn = () => __awaiter(function* (arguments) { return yield other.apply(this, arguments); }, this, arguments); + var fn = () => __awaiter(function* (arguments) { return yield other.apply(this, arguments); }, + this, arguments); } } diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js index afcd73b32dc..67279d7f1be 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js +++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js @@ -9,6 +9,7 @@ class C { //// [asyncArrowFunctionCapturesThis_es6.js] class C { method() { - var fn = () => __awaiter(function* () { return yield this; }, this); + var fn = () => __awaiter(function* () { return yield this; }, + this); } } diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js index 25319680ceb..7048ca2ffa4 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js @@ -5,5 +5,6 @@ async function foo(a = await => await): Promise { //// [asyncFunctionDeclaration10_es6.js] function foo(a = await => await) { return __awaiter(function* () { - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js index 37cb4bbc0d4..dbf2d489a92 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js @@ -5,5 +5,6 @@ async function await(): Promise { //// [asyncFunctionDeclaration11_es6.js] function await() { return __awaiter(function* () { - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js index 0423ca2341b..35f6af6b2ff 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js @@ -10,5 +10,6 @@ function foo() { return __awaiter(function* () { // Legal to use 'await' in a type context. var v; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js index eccf374cdc3..3610cabbdec 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js @@ -7,5 +7,6 @@ async function foo(): Promise { function foo() { return __awaiter(function* () { return; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js index 386e1e76241..e3e1fb65096 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js @@ -5,5 +5,6 @@ async function foo(): Promise { //// [asyncFunctionDeclaration1_es6.js] function foo() { return __awaiter(function* () { - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js index 9bd17a7cd0e..a74d55c35ca 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js @@ -5,5 +5,6 @@ async function foo(a = await): Promise { //// [asyncFunctionDeclaration6_es6.js] function foo(a = await) { return __awaiter(function* () { - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js index b32c90664ac..fcc2394a1d1 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js @@ -11,7 +11,9 @@ function bar() { // 'await' here is an identifier, and not a yield expression. function foo(a = await) { return __awaiter(function* () { - }, this, void 0, Promise); + }, + this, void 0, Promise); } - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js index 3fcf3f2f7ca..7f23510f942 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js @@ -7,5 +7,6 @@ async function foo(): Promise { function foo() { return __awaiter(function* () { var v = { [yield ]: foo }; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.js b/tests/baselines/reference/awaitBinaryExpression1_es6.js index 889e9373368..0531f7643fc 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.js @@ -13,5 +13,6 @@ function func() { "before"; var b = (yield p) || a; "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.js b/tests/baselines/reference/awaitBinaryExpression2_es6.js index 5a156d6d0d3..36545440f1f 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.js @@ -13,5 +13,6 @@ function func() { "before"; var b = (yield p) && a; "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.js b/tests/baselines/reference/awaitBinaryExpression3_es6.js index 8b150a9fcbf..bfe95956ebc 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.js @@ -13,5 +13,6 @@ function func() { "before"; var b = (yield p) + a; "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.js b/tests/baselines/reference/awaitBinaryExpression4_es6.js index c8f42d191c0..fa2dd17143e 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.js @@ -13,5 +13,6 @@ function func() { "before"; var b = yield p, a; "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.js b/tests/baselines/reference/awaitBinaryExpression5_es6.js index 1c867a8abbf..615320e8ebb 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.js @@ -15,5 +15,6 @@ function func() { var o; o.a = yield p; "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression1_es6.js b/tests/baselines/reference/awaitCallExpression1_es6.js index dc73da972ac..9e329e14ad2 100644 --- a/tests/baselines/reference/awaitCallExpression1_es6.js +++ b/tests/baselines/reference/awaitCallExpression1_es6.js @@ -17,5 +17,6 @@ function func() { "before"; var b = fn(a, a, a); "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression2_es6.js b/tests/baselines/reference/awaitCallExpression2_es6.js index a0f0944d796..4f8e088b55d 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.js +++ b/tests/baselines/reference/awaitCallExpression2_es6.js @@ -17,5 +17,6 @@ function func() { "before"; var b = fn(yield p, a, a); "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression3_es6.js b/tests/baselines/reference/awaitCallExpression3_es6.js index 75e77883993..54b5d8411d7 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.js +++ b/tests/baselines/reference/awaitCallExpression3_es6.js @@ -17,5 +17,6 @@ function func() { "before"; var b = fn(a, yield p, a); "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression4_es6.js b/tests/baselines/reference/awaitCallExpression4_es6.js index 8f1756393cb..9e32395df83 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.js +++ b/tests/baselines/reference/awaitCallExpression4_es6.js @@ -17,5 +17,6 @@ function func() { "before"; var b = (yield pfn)(a, a, a); "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression5_es6.js b/tests/baselines/reference/awaitCallExpression5_es6.js index 0752c02758b..76ccf06b105 100644 --- a/tests/baselines/reference/awaitCallExpression5_es6.js +++ b/tests/baselines/reference/awaitCallExpression5_es6.js @@ -17,5 +17,6 @@ function func() { "before"; var b = o.fn(a, a, a); "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression6_es6.js b/tests/baselines/reference/awaitCallExpression6_es6.js index 3fc683dc399..90b96a06ad7 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.js +++ b/tests/baselines/reference/awaitCallExpression6_es6.js @@ -17,5 +17,6 @@ function func() { "before"; var b = o.fn(yield p, a, a); "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression7_es6.js b/tests/baselines/reference/awaitCallExpression7_es6.js index 8618313587a..e9a2edb8a91 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.js +++ b/tests/baselines/reference/awaitCallExpression7_es6.js @@ -17,5 +17,6 @@ function func() { "before"; var b = o.fn(a, yield p, a); "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } diff --git a/tests/baselines/reference/awaitCallExpression8_es6.js b/tests/baselines/reference/awaitCallExpression8_es6.js index ceab826c58a..e172dde417d 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.js +++ b/tests/baselines/reference/awaitCallExpression8_es6.js @@ -17,5 +17,6 @@ function func() { "before"; var b = (yield po).fn(a, a, a); "after"; - }, this, void 0, Promise); + }, + this, void 0, Promise); } From d0763060c9c837d6c3a235e58271313e54cb3146 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Wed, 10 Jun 2015 12:32:24 -0700 Subject: [PATCH 087/309] added more tests --- tests/baselines/reference/systemModule13.js | 21 ++++++++++++ .../reference/systemModule13.symbols | 17 ++++++++++ .../baselines/reference/systemModule13.types | 32 +++++++++++++++++++ tests/cases/compiler/systemModule13.ts | 5 +++ 4 files changed, 75 insertions(+) create mode 100644 tests/baselines/reference/systemModule13.js create mode 100644 tests/baselines/reference/systemModule13.symbols create mode 100644 tests/baselines/reference/systemModule13.types create mode 100644 tests/cases/compiler/systemModule13.ts diff --git a/tests/baselines/reference/systemModule13.js b/tests/baselines/reference/systemModule13.js new file mode 100644 index 00000000000..c66e123c738 --- /dev/null +++ b/tests/baselines/reference/systemModule13.js @@ -0,0 +1,21 @@ +//// [systemModule13.ts] + +export let [x,y,z] = [1, 2, 3]; +export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; +for ([x] of [[1]]) {} + +//// [systemModule13.js] +System.register([], function(exports_1) { + var x, y, z, z0, z1; + return { + setters:[], + execute: function() { + _a = [1, 2, 3], exports_1("x", x = _a[0]), exports_1("y", y = _a[1]), exports_1("z", z = _a[2]); + _b = { a: true, b: { c: "123" } }, exports_1("z0", z0 = _b.a), exports_1("z1", z1 = _b.b.c); + for (var _i = 0, _c = [[1]]; _i < _c.length; _i++) { + exports_1("x", x = _c[_i][0]); + } + } + } + var _a, _b; +}); diff --git a/tests/baselines/reference/systemModule13.symbols b/tests/baselines/reference/systemModule13.symbols new file mode 100644 index 00000000000..d9e64335c2b --- /dev/null +++ b/tests/baselines/reference/systemModule13.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/systemModule13.ts === + +export let [x,y,z] = [1, 2, 3]; +>x : Symbol(x, Decl(systemModule13.ts, 1, 12)) +>y : Symbol(y, Decl(systemModule13.ts, 1, 14)) +>z : Symbol(z, Decl(systemModule13.ts, 1, 16)) + +export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; +>z0 : Symbol(z0, Decl(systemModule13.ts, 2, 14)) +>z1 : Symbol(z1, Decl(systemModule13.ts, 2, 25)) +>a : Symbol(a, Decl(systemModule13.ts, 2, 36)) +>b : Symbol(b, Decl(systemModule13.ts, 2, 44)) +>c : Symbol(c, Decl(systemModule13.ts, 2, 49)) + +for ([x] of [[1]]) {} +>x : Symbol(x, Decl(systemModule13.ts, 1, 12)) + diff --git a/tests/baselines/reference/systemModule13.types b/tests/baselines/reference/systemModule13.types new file mode 100644 index 00000000000..35f22be98b8 --- /dev/null +++ b/tests/baselines/reference/systemModule13.types @@ -0,0 +1,32 @@ +=== tests/cases/compiler/systemModule13.ts === + +export let [x,y,z] = [1, 2, 3]; +>x : number +>y : number +>z : number +>[1, 2, 3] : [number, number, number] +>1 : number +>2 : number +>3 : number + +export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; +>a : any +>z0 : boolean +>b : any +>c : any +>z1 : string +>{a: true, b: {c: "123"}} : { a: boolean; b: { c: string; }; } +>a : boolean +>true : boolean +>b : { c: string; } +>{c: "123"} : { c: string; } +>c : string +>"123" : string + +for ([x] of [[1]]) {} +>[x] : number[] +>x : number +>[[1]] : number[][] +>[1] : number[] +>1 : number + diff --git a/tests/cases/compiler/systemModule13.ts b/tests/cases/compiler/systemModule13.ts new file mode 100644 index 00000000000..2f92d99ab21 --- /dev/null +++ b/tests/cases/compiler/systemModule13.ts @@ -0,0 +1,5 @@ +// @module: system + +export let [x,y,z] = [1, 2, 3]; +export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}}; +for ([x] of [[1]]) {} \ No newline at end of file From cd0662725756c84e12061df26760a0527e45834d Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 10 Jun 2015 15:43:22 -0700 Subject: [PATCH 088/309] Fixed Some indentation --- src/compiler/checker.ts | 100 ++++++++++++++++++++-------------------- 1 file changed, 50 insertions(+), 50 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 4adc1ad65c7..89d30e93f5d 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1358,7 +1358,7 @@ module ts { return result; } - function signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string { + function signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string  { let writer = getSingleLineStringWriter(); getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); let result = writer.string(); @@ -1978,7 +1978,7 @@ module ts { // If the binding pattern is empty, this variable declaration is not visible return false; } - // Otherwise fall through + // Otherwise fall through case SyntaxKind.ModuleDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: @@ -2172,8 +2172,8 @@ module ts { // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature, // or otherwise the type of the string index signature. type = getTypeOfPropertyOfType(parentType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) || - getIndexTypeOfType(parentType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) || + getIndexTypeOfType(parentType, IndexKind.String); if (!type) { error(name, Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(parentType), declarationNameToString(name)); return unknownType; @@ -2556,7 +2556,7 @@ module ts { // Appends the outer type parameters of a node to a set of type parameters and returns the resulting set. The function // allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set in-place and // returns the same array. - function appendOuterTypeParameters(typeParameters: TypeParameter[], node: Node): TypeParameter[]{ + function appendOuterTypeParameters(typeParameters: TypeParameter[], node: Node): TypeParameter[] { while (true) { node = node.parent; if (!node) { @@ -2867,7 +2867,7 @@ module ts { sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); } - function getDefaultConstructSignatures(classType: InterfaceType): Signature[]{ + function getDefaultConstructSignatures(classType: InterfaceType): Signature[] { let baseTypes = getBaseTypes(classType); if (baseTypes.length) { let baseType = baseTypes[0]; @@ -3606,12 +3606,12 @@ module ts { // We only support expressions that are simple qualified names. For other expressions this produces undefined. let typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (node).typeName : isSupportedExpressionWithTypeArguments(node) ? (node).expression : - undefined; + undefined; let symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol; let type = symbol === unknownSymbol ? unknownType : symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) : - symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : - getTypeFromNonGenericTypeReference(node, symbol); + symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the // type reference in checkTypeReferenceOrExpressionWithTypeArguments. links.resolvedSymbol = symbol; @@ -4687,7 +4687,7 @@ module ts { if (source.typePredicate && target.typePredicate) { let hasDifferentParameterIndex = source.typePredicate.parameterIndex !== target.typePredicate.parameterIndex; let hasDifferentTypes: boolean; - if (hasDifferentParameterIndex || + if (hasDifferentParameterIndex || (hasDifferentTypes = !isTypeIdenticalTo(source.typePredicate.type, target.typePredicate.type))) { if (reportErrors) { @@ -4697,12 +4697,12 @@ module ts { let targetTypeText = typeToString(target.typePredicate.type); if (hasDifferentParameterIndex) { - reportError(Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, + reportError(Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, sourceParamText, targetParamText); } else if (hasDifferentTypes) { - reportError(Diagnostics.Type_0_is_not_assignable_to_type_1, + reportError(Diagnostics.Type_0_is_not_assignable_to_type_1, sourceTypeText, targetTypeText); } @@ -5699,7 +5699,7 @@ module ts { if (!assumeTrue) { if (type.flags & TypeFlags.Union) { return getUnionType(filter((type).types, t => !isTypeSubtypeOf(t, signature.typePredicate.type))); - } + } return type; } return getNarrowedType(type, signature.typePredicate.type); @@ -5931,20 +5931,20 @@ module ts { if (container && container.parent && container.parent.kind === SyntaxKind.ClassDeclaration) { if (container.flags & NodeFlags.Static) { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor; } else { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor || - container.kind === SyntaxKind.PropertyDeclaration || - container.kind === SyntaxKind.PropertySignature || - container.kind === SyntaxKind.Constructor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor || + container.kind === SyntaxKind.PropertyDeclaration || + container.kind === SyntaxKind.PropertySignature || + container.kind === SyntaxKind.Constructor; } } } @@ -6409,7 +6409,7 @@ module ts { let restArrayType = checkExpression((e).expression, contextualMapper); let restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) || (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined); - + if (restElementType) { elementTypes.push(restElementType); } @@ -7314,7 +7314,7 @@ module ts { if (!hasCorrectArity(node, args, originalCandidate)) { continue; } - + let candidate: Signature; let typeArgumentsAreValid: boolean; let inferenceContext = originalCandidate.typeParameters @@ -8061,8 +8061,8 @@ module ts { let type = isTypeAny(sourceType) ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || - getIndexTypeOfType(sourceType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || + getIndexTypeOfType(sourceType, IndexKind.String); if (type) { checkDestructuringAssignment((p).initializer || name, type); } @@ -8257,7 +8257,7 @@ module ts { if (!checkForDisallowedESSymbolOperand(operator)) { return booleanType; } - // Fall through + // Fall through case SyntaxKind.EqualsEqualsToken: case SyntaxKind.ExclamationEqualsToken: case SyntaxKind.EqualsEqualsEqualsToken: @@ -8285,8 +8285,8 @@ module ts { function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean { let offendingSymbolOperand = someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? node.left : - someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : - undefined; + someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : + undefined; if (offendingSymbolOperand) { error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator)); return false; @@ -8336,7 +8336,7 @@ module ts { function isYieldExpressionInClass(node: YieldExpression): boolean { let current: Node = node let parent = node.parent; - while (parent) { + while (parent) { if (isFunctionLike(parent) && current === (parent).body) { return false; } @@ -8703,12 +8703,12 @@ module ts { if (hasReportedError) { break; } - if (param.name.kind === SyntaxKind.ObjectBindingPattern || + if (param.name.kind === SyntaxKind.ObjectBindingPattern || param.name.kind === SyntaxKind.ArrayBindingPattern) { (function checkBindingPattern(pattern: BindingPattern) { for (let element of pattern.elements) { - if (element.name.kind === SyntaxKind.Identifier && + if (element.name.kind === SyntaxKind.Identifier && (element.name).text === typePredicate.parameterName) { error(typePredicateNode.parameterName, @@ -9463,7 +9463,7 @@ module ts { if (!nodeCanBeDecorated(node)) { return; } - + if (!compilerOptions.experimentalDecorators) { error(node, Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalDecorators_to_remove_this_warning); } @@ -9480,7 +9480,7 @@ module ts { case SyntaxKind.MethodDeclaration: checkParameterTypeAnnotationsAsExpressions(node); - // fall-through + // fall-through case SyntaxKind.SetAccessor: case SyntaxKind.GetAccessor: @@ -10061,7 +10061,7 @@ module ts { if (allowStringInput) { return checkElementTypeOfArrayOrString(inputType, errorNode); } - + if (isArrayLikeType(inputType)) { let indexType = getIndexTypeOfType(inputType, IndexKind.Number); if (indexType) { @@ -11147,7 +11147,7 @@ module ts { // if the module merges with a class declaration in the same lexical scope, // we need to track this to ensure the correct emit. - let mergedClass = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration); + let mergedClass = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration); if (mergedClass && inSameLexicalScope(node, mergedClass)) { getNodeLinks(node).flags |= NodeCheckFlags.LexicalModuleMergesWithClass; @@ -11378,7 +11378,7 @@ module ts { } function checkTypePredicate(node: TypePredicateNode) { - if(!isInLegalTypePredicatePosition(node)) { + if (!isInLegalTypePredicatePosition(node)) { error(node, Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); } } @@ -12112,7 +12112,7 @@ module ts { if (links.isNestedRedeclaration === undefined) { let container = getEnclosingBlockScopeContainer(symbol.valueDeclaration); links.isNestedRedeclaration = isStatementWithLocals(container) && - !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); + !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); } return links.isNestedRedeclaration; } @@ -12346,7 +12346,7 @@ module ts { break; } } - + return "Object"; } @@ -12472,7 +12472,7 @@ module ts { let isVariableDeclarationOrBindingElement = n.parent.kind === SyntaxKind.BindingElement || (n.parent.kind === SyntaxKind.VariableDeclaration && (n.parent).name === n); - let symbol = + let symbol = (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) || getNodeLinks(n).resolvedSymbol || resolveName(n, n.text, SymbolFlags.Value | SymbolFlags.Alias, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined); @@ -12500,7 +12500,7 @@ module ts { if (!signature) { return unknownType; } - + let instantiatedSignature = getSignatureInstantiation(signature, typeArguments); return getOrCreateTypeFromSignature(instantiatedSignature); } @@ -12719,7 +12719,7 @@ module ts { } // TODO (yuisu): Fix when module is a strict mode - let errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText)|| + let errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || grammarErrorOnNode(node, Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); return errorReport; } @@ -12843,8 +12843,8 @@ module ts { flags |= NodeFlags.Static; lastStatic = modifier; break; - - case SyntaxKind.ExportKeyword: + + case SyntaxKind.ExportKeyword: if (flags & NodeFlags.Export) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "export"); } @@ -13196,13 +13196,13 @@ module ts { let currentKind: number; if (prop.kind === SyntaxKind.PropertyAssignment || prop.kind === SyntaxKind.ShorthandPropertyAssignment) { // Grammar checking for computedPropertName and shorthandPropertyAssignment - checkGrammarForInvalidQuestionMark(prop,(prop).questionToken, Diagnostics.An_object_member_cannot_be_declared_optional); + checkGrammarForInvalidQuestionMark(prop, (prop).questionToken, Diagnostics.An_object_member_cannot_be_declared_optional); if (name.kind === SyntaxKind.NumericLiteral) { checkGrammarNumericLiteral(name); } currentKind = Property; } - else if ( prop.kind === SyntaxKind.MethodDeclaration) { + else if (prop.kind === SyntaxKind.MethodDeclaration) { currentKind = Property; } else if (prop.kind === SyntaxKind.GetAccessor) { @@ -13471,7 +13471,7 @@ module ts { } } - let checkLetConstNames = languageVersion >= ScriptTarget.ES6 && (isLet(node) || isConst(node)); + let checkLetConstNames = languageVersion >= ScriptTarget.ES6 && (isLet(node) || isConst(node)); // 1. LexicalDeclaration : LetOrConst BindingList ; // It is a Syntax Error if the BoundNames of BindingList contains "let". @@ -13630,7 +13630,7 @@ module ts { // otherwise report generic error message. // reportGrammarErrorInClassDeclaration only return true if grammar error is successfully reported and false otherwise let reportErrorInClassDeclaration = reportStrictModeGrammarErrorInClassDeclaration(identifier, Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode, nameText); - if (!reportErrorInClassDeclaration){ + if (!reportErrorInClassDeclaration) { return grammarErrorOnNode(identifier, Diagnostics.Invalid_use_of_0_in_strict_mode, nameText); } return reportErrorInClassDeclaration; From 25c093673cceb508a4d7f855754c0b9006a0e5f8 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Wed, 3 Jun 2015 13:48:34 -0700 Subject: [PATCH 089/309] introduce FileMap to store mappings with filenames as keys --- src/compiler/core.ts | 32 +++++++++++++++++++++++ src/compiler/program.ts | 17 ++++++------ src/services/services.ts | 56 +++++++++++++++++++++------------------- src/services/shims.ts | 10 ++++++- 4 files changed, 80 insertions(+), 35 deletions(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index c753f7ff42d..bba10a635e4 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -15,6 +15,38 @@ module ts { True = -1 } + export class FileMap { + private files: Map = {}; + + constructor(private getCanonicalFileName: (fileName: string) => string) { + } + + public set(fileName: string, value: T) { + this.files[this.normalizeKey(fileName)] = value; + } + + public get(fileName: string) { + return this.files[this.normalizeKey(fileName)]; + } + + public contains(fileName: string) { + return hasProperty(this.files, this.normalizeKey(fileName)); + } + + public delete(fileName: string) { + let key = this.normalizeKey(fileName); + delete this.files[key]; + } + + public forEachValue(f: (value: T) => void) { + forEachValue(this.files, f); + } + + private normalizeKey(key: string) { + return this.getCanonicalFileName(normalizeSlashes(key)); + } + } + export const enum Comparison { LessThan = -1, EqualTo = 0, diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 0af94b3d854..fa794bbb77e 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -143,7 +143,6 @@ module ts { export function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program { let program: Program; let files: SourceFile[] = []; - let filesByName: Map = {}; let diagnostics = createDiagnosticCollection(); let seenNoDefaultLib = options.noLib; let commonSourceDirectory: string; @@ -153,6 +152,8 @@ module ts { let start = new Date().getTime(); host = host || createCompilerHost(options); + let filesByName: FileMap = new FileMap(host.getCanonicalFileName); + forEach(rootNames, name => processRootFile(name, false)); if (!seenNoDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); @@ -233,8 +234,7 @@ module ts { } function getSourceFile(fileName: string) { - fileName = host.getCanonicalFileName(normalizeSlashes(fileName)); - return hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile: SourceFile, getDiagnostics: (sourceFile: SourceFile) => Diagnostic[]): Diagnostic[] { @@ -352,19 +352,19 @@ module ts { // Get source file from normalized fileName function findSourceFile(fileName: string, isDefaultLib: boolean, refFile?: SourceFile, refStart?: number, refLength?: number): SourceFile { let canonicalName = host.getCanonicalFileName(normalizeSlashes(fileName)); - if (hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { // We've already looked for this file, use cached result return getSourceFileFromCache(fileName, canonicalName, /*useAbsolutePath*/ false); } else { let normalizedAbsolutePath = getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); let canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, /*useAbsolutePath*/ true); } // We haven't looked for this file, do so now and cache result - let file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, hostErrorMessage => { + let file = host.getSourceFile(fileName, options.target, hostErrorMessage => { if (refFile) { diagnostics.add(createFileDiagnostic(refFile, refStart, refLength, Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); @@ -373,11 +373,12 @@ module ts { diagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; // Set the source file for normalized absolute path - filesByName[canonicalAbsolutePath] = file; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { let basePath = getDirectoryPath(fileName); @@ -396,7 +397,7 @@ module ts { } function getSourceFileFromCache(fileName: string, canonicalName: string, useAbsolutePath: boolean): SourceFile { - let file = filesByName[canonicalName]; + let file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { let sourceFileName = useAbsolutePath ? getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { diff --git a/src/services/services.ts b/src/services/services.ts index ece411ae1ea..b6f95c2f13a 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -960,6 +960,7 @@ module ts { log? (s: string): void; trace? (s: string): void; error? (s: string): void; + useCaseSensitiveFileNames? (): boolean; } // @@ -1630,12 +1631,12 @@ module ts { // at each language service public entry point, since we don't know when // set of scripts handled by the host changes. class HostCache { - private fileNameToEntry: Map; + private fileNameToEntry: FileMap; private _compilationSettings: CompilerOptions; - constructor(private host: LanguageServiceHost, private getCanonicalFileName: (fileName: string) => string) { + constructor(private host: LanguageServiceHost, getCanonicalFileName: (fileName: string) => string) { // script id => script index - this.fileNameToEntry = {}; + this.fileNameToEntry = new FileMap(getCanonicalFileName); // Initialize the list with the root file names let rootFileNames = host.getScriptFileNames(); @@ -1651,10 +1652,6 @@ module ts { return this._compilationSettings; } - private normalizeFileName(fileName: string): string { - return this.getCanonicalFileName(normalizeSlashes(fileName)); - } - private createEntry(fileName: string) { let entry: HostFileInformation; let scriptSnapshot = this.host.getScriptSnapshot(fileName); @@ -1666,15 +1663,16 @@ module ts { }; } - return this.fileNameToEntry[this.normalizeFileName(fileName)] = entry; + this.fileNameToEntry.set(fileName, entry); + return entry; } private getEntry(fileName: string): HostFileInformation { - return lookUp(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.get(fileName); } private contains(fileName: string): boolean { - return hasProperty(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.contains(fileName); } public getOrCreateEntry(fileName: string): HostFileInformation { @@ -1688,10 +1686,9 @@ module ts { public getRootFileNames(): string[] { let fileNames: string[] = []; - forEachKey(this.fileNameToEntry, key => { - let entry = this.getEntry(key); - if (entry) { - fileNames.push(entry.hostFileName); + this.fileNameToEntry.forEachValue(value => { + if (value) { + fileNames.push(value.hostFileName); } }); @@ -1885,20 +1882,28 @@ module ts { return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, /*setNodeParents:*/ true); } - export function createDocumentRegistry(): DocumentRegistry { + function createGetCanonicalFileName(useCaseSensitivefileNames: boolean): (fileName: string) => string { + return useCaseSensitivefileNames + ? ((fileName) => fileName) + : ((fileName) => fileName.toLowerCase()); + } + + + export function createDocumentRegistry(useCaseSensitiveFileNames?: boolean): DocumentRegistry { // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have // for those settings. - let buckets: Map> = {}; + let buckets: Map> = {}; + let getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames || false); function getKeyFromCompilationSettings(settings: CompilerOptions): string { return "_" + settings.target; // + "|" + settings.propagateEnumConstantoString() } - function getBucketForCompilationSettings(settings: CompilerOptions, createIfMissing: boolean): Map { + function getBucketForCompilationSettings(settings: CompilerOptions, createIfMissing: boolean): FileMap { let key = getKeyFromCompilationSettings(settings); let bucket = lookUp(buckets, key); if (!bucket && createIfMissing) { - buckets[key] = bucket = {}; + buckets[key] = bucket = new FileMap(getCanonicalFileName); } return bucket; } @@ -1908,7 +1913,7 @@ module ts { let entries = lookUp(buckets, name); let sourceFiles: { name: string; refCount: number; references: string[]; }[] = []; for (let i in entries) { - let entry = entries[i]; + let entry = entries.get(i); sourceFiles.push({ name: i, refCount: entry.languageServiceRefCount, @@ -1940,18 +1945,19 @@ module ts { acquiring: boolean): SourceFile { let bucket = getBucketForCompilationSettings(compilationSettings, /*createIfMissing*/ true); - let entry = lookUp(bucket, fileName); + let entry = bucket.get(fileName); if (!entry) { Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?"); // Have never seen this file with these settings. Create a new source file for it. let sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, /*setNodeParents:*/ false); - bucket[fileName] = entry = { + entry = { sourceFile: sourceFile, languageServiceRefCount: 0, owners: [] }; + bucket.set(fileName, entry); } else { // We have an entry for this file. However, it may be for a different version of @@ -1979,12 +1985,12 @@ module ts { let bucket = getBucketForCompilationSettings(compilationSettings, false); Debug.assert(bucket !== undefined); - let entry = lookUp(bucket, fileName); + let entry = bucket.get(fileName); entry.languageServiceRefCount--; Debug.assert(entry.languageServiceRefCount >= 0); if (entry.languageServiceRefCount === 0) { - delete bucket[fileName]; + bucket.delete(fileName); } } @@ -2412,9 +2418,7 @@ module ts { } } - function getCanonicalFileName(fileName: string) { - return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); - } + let getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames); function getValidSourceFile(fileName: string): SourceFile { fileName = normalizeSlashes(fileName); diff --git a/src/services/shims.ts b/src/services/shims.ts index d3f59737538..4dfab444cde 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -56,6 +56,7 @@ module ts { getDefaultLibFileName(options: string): string; getNewLine?(): string; getProjectVersion?(): string; + useCaseSensitiveFileNames?(): boolean; } /** Public interface of the the of a config service shim instance.*/ @@ -270,6 +271,10 @@ module ts { return this.shimHost.getProjectVersion(); } + public useCaseSensitiveFileNames(): boolean { + return this.shimHost.useCaseSensitiveFileNames && this.useCaseSensitiveFileNames(); + } + public getCompilationSettings(): CompilerOptions { var settingsJson = this.shimHost.getCompilationSettings(); if (settingsJson == null || settingsJson == "") { @@ -909,7 +914,7 @@ module ts { export class TypeScriptServicesFactory implements ShimFactory { private _shims: Shim[] = []; - private documentRegistry: DocumentRegistry = createDocumentRegistry(); + private documentRegistry: DocumentRegistry; /* * Returns script API version. @@ -920,6 +925,9 @@ module ts { public createLanguageServiceShim(host: LanguageServiceShimHost): LanguageServiceShim { try { + if (this.documentRegistry === undefined) { + this.documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames()); + } var hostAdapter = new LanguageServiceShimHostAdapter(host); var languageService = createLanguageService(hostAdapter, this.documentRegistry); return new LanguageServiceShimObject(this, host, languageService); From b4f1df2afa039e3c31fd833a2483de5124cb4f90 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Wed, 3 Jun 2015 15:22:17 -0700 Subject: [PATCH 090/309] address PR feedback --- src/compiler/core.ts | 38 +++++++++++++++++++++----------------- src/compiler/program.ts | 2 +- src/compiler/types.ts | 8 ++++++++ src/services/services.ts | 6 +++--- src/services/shims.ts | 2 +- 5 files changed, 34 insertions(+), 22 deletions(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index bba10a635e4..1f04f9968ca 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -15,35 +15,39 @@ module ts { True = -1 } - export class FileMap { - private files: Map = {}; - - constructor(private getCanonicalFileName: (fileName: string) => string) { + export function createFileMap(getCanonicalFileName: (fileName: string) => string): FileMap { + let files: Map = {}; + return { + get, + set, + contains, + delete: deleteItem, + forEachValue: forEachValueInMap } - public set(fileName: string, value: T) { - this.files[this.normalizeKey(fileName)] = value; + function set(fileName: string, value: T) { + files[normalizeKey(fileName)] = value; } - public get(fileName: string) { - return this.files[this.normalizeKey(fileName)]; + function get(fileName: string) { + return files[normalizeKey(fileName)]; } - public contains(fileName: string) { - return hasProperty(this.files, this.normalizeKey(fileName)); + function contains(fileName: string) { + return hasProperty(files, normalizeKey(fileName)); } - public delete(fileName: string) { - let key = this.normalizeKey(fileName); - delete this.files[key]; + function deleteItem (fileName: string) { + let key = normalizeKey(fileName); + delete files[key]; } - public forEachValue(f: (value: T) => void) { - forEachValue(this.files, f); + function forEachValueInMap(f: (value: T) => void) { + forEachValue(files, f); } - private normalizeKey(key: string) { - return this.getCanonicalFileName(normalizeSlashes(key)); + function normalizeKey(key: string) { + return getCanonicalFileName(normalizeSlashes(key)); } } diff --git a/src/compiler/program.ts b/src/compiler/program.ts index fa794bbb77e..5c40230484a 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -152,7 +152,7 @@ module ts { let start = new Date().getTime(); host = host || createCompilerHost(options); - let filesByName: FileMap = new FileMap(host.getCanonicalFileName); + let filesByName = createFileMap(host.getCanonicalFileName); forEach(rootNames, name => processRootFile(name, false)); if (!seenNoDefaultLib) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 1a72e9fc94a..c3ce9d44ae3 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -3,6 +3,14 @@ module ts { [index: string]: T; } + export interface FileMap { + get(fileName: string): T; + set(fileName: string, value: T): void; + contains(fileName: string): boolean; + delete(fileName: string): void; + forEachValue(f: (v: T) => void): void; + } + export interface TextRange { pos: number; end: number; diff --git a/src/services/services.ts b/src/services/services.ts index b6f95c2f13a..2329eeb2e83 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1636,7 +1636,7 @@ module ts { constructor(private host: LanguageServiceHost, getCanonicalFileName: (fileName: string) => string) { // script id => script index - this.fileNameToEntry = new FileMap(getCanonicalFileName); + this.fileNameToEntry = createFileMap(getCanonicalFileName); // Initialize the list with the root file names let rootFileNames = host.getScriptFileNames(); @@ -1893,7 +1893,7 @@ module ts { // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have // for those settings. let buckets: Map> = {}; - let getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames || false); + let getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames); function getKeyFromCompilationSettings(settings: CompilerOptions): string { return "_" + settings.target; // + "|" + settings.propagateEnumConstantoString() @@ -1903,7 +1903,7 @@ module ts { let key = getKeyFromCompilationSettings(settings); let bucket = lookUp(buckets, key); if (!bucket && createIfMissing) { - buckets[key] = bucket = new FileMap(getCanonicalFileName); + buckets[key] = bucket = createFileMap(getCanonicalFileName); } return bucket; } diff --git a/src/services/shims.ts b/src/services/shims.ts index 4dfab444cde..004393fb3b5 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -272,7 +272,7 @@ module ts { } public useCaseSensitiveFileNames(): boolean { - return this.shimHost.useCaseSensitiveFileNames && this.useCaseSensitiveFileNames(); + return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false; } public getCompilationSettings(): CompilerOptions { From 522248a042cd08594a2de4e0475c0f72f4bf9ba1 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Thu, 4 Jun 2015 11:18:05 -0700 Subject: [PATCH 091/309] rename 'FileMap.delete' to 'FileMap.remove' --- src/compiler/core.ts | 4 ++-- src/compiler/types.ts | 2 +- src/services/services.ts | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 1f04f9968ca..d9a1fc5368a 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -21,7 +21,7 @@ module ts { get, set, contains, - delete: deleteItem, + remove, forEachValue: forEachValueInMap } @@ -37,7 +37,7 @@ module ts { return hasProperty(files, normalizeKey(fileName)); } - function deleteItem (fileName: string) { + function remove (fileName: string) { let key = normalizeKey(fileName); delete files[key]; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index c3ce9d44ae3..e1f565969d8 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -7,7 +7,7 @@ module ts { get(fileName: string): T; set(fileName: string, value: T): void; contains(fileName: string): boolean; - delete(fileName: string): void; + remove(fileName: string): void; forEachValue(f: (v: T) => void): void; } diff --git a/src/services/services.ts b/src/services/services.ts index 2329eeb2e83..521c6db155a 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1990,7 +1990,7 @@ module ts { Debug.assert(entry.languageServiceRefCount >= 0); if (entry.languageServiceRefCount === 0) { - bucket.delete(fileName); + bucket.remove(fileName); } } From 9a57e6ff172cdb591f35ec6a02ad7d9f6401a08b Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Mon, 15 Jun 2015 12:04:15 -0700 Subject: [PATCH 092/309] Updated baselines --- src/harness/runner.ts | 2 +- .../argumentsObjectIterator02_ES6.symbols | 6 +- .../reference/arrayLiterals2ES6.symbols | 6 +- .../reference/asyncArrowFunction1_es6.symbols | 2 +- .../reference/asyncArrowFunction9_es6.symbols | 2 +- .../asyncFunctionDeclaration10_es6.symbols | 2 +- .../asyncFunctionDeclaration11_es6.symbols | 2 +- .../asyncFunctionDeclaration14_es6.symbols | 2 +- .../asyncFunctionDeclaration1_es6.symbols | 2 +- .../awaitBinaryExpression1_es6.symbols | 4 +- .../awaitBinaryExpression2_es6.symbols | 4 +- .../awaitBinaryExpression3_es6.symbols | 4 +- .../awaitBinaryExpression4_es6.symbols | 4 +- .../awaitBinaryExpression5_es6.symbols | 4 +- .../awaitCallExpression1_es6.symbols | 8 +- .../awaitCallExpression2_es6.symbols | 8 +- .../awaitCallExpression3_es6.symbols | 8 +- .../awaitCallExpression4_es6.symbols | 8 +- .../awaitCallExpression5_es6.symbols | 8 +- .../awaitCallExpression6_es6.symbols | 8 +- .../awaitCallExpression7_es6.symbols | 8 +- .../awaitCallExpression8_es6.symbols | 8 +- .../reference/callWithSpreadES6.symbols | 2 +- ...tructuringParameterDeclaration3ES5.symbols | 16 +- ...tructuringParameterDeclaration3ES6.symbols | 16 +- ...owFunctionWhenUsingArguments14_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments15_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments16_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments17_ES6.symbols | 2 +- ...owFunctionWhenUsingArguments18_ES6.symbols | 2 +- tests/baselines/reference/for-of13.symbols | 4 +- tests/baselines/reference/for-of18.symbols | 6 +- tests/baselines/reference/for-of19.symbols | 6 +- tests/baselines/reference/for-of20.symbols | 6 +- tests/baselines/reference/for-of21.symbols | 6 +- tests/baselines/reference/for-of22.symbols | 6 +- tests/baselines/reference/for-of23.symbols | 6 +- tests/baselines/reference/for-of25.symbols | 6 +- tests/baselines/reference/for-of26.symbols | 6 +- tests/baselines/reference/for-of27.symbols | 6 +- tests/baselines/reference/for-of28.symbols | 6 +- tests/baselines/reference/for-of37.symbols | 2 +- tests/baselines/reference/for-of38.symbols | 2 +- tests/baselines/reference/for-of40.symbols | 2 +- tests/baselines/reference/for-of44.symbols | 2 +- tests/baselines/reference/for-of45.symbols | 2 +- tests/baselines/reference/for-of50.symbols | 2 +- tests/baselines/reference/for-of57.symbols | 2 +- .../reference/generatorES6_6.symbols | 6 +- .../reference/generatorOverloads4.symbols | 6 +- .../reference/generatorOverloads5.symbols | 6 +- .../reference/generatorTypeCheck1.symbols | 2 +- .../reference/generatorTypeCheck10.symbols | 2 +- .../reference/generatorTypeCheck11.symbols | 2 +- .../reference/generatorTypeCheck12.symbols | 2 +- .../reference/generatorTypeCheck13.symbols | 2 +- .../reference/generatorTypeCheck17.symbols | 2 +- .../reference/generatorTypeCheck19.symbols | 2 +- .../reference/generatorTypeCheck2.symbols | 2 +- .../reference/generatorTypeCheck26.symbols | 2 +- .../reference/generatorTypeCheck27.symbols | 2 +- .../reference/generatorTypeCheck28.symbols | 8 +- .../reference/generatorTypeCheck29.symbols | 4 +- .../reference/generatorTypeCheck3.symbols | 2 +- .../reference/generatorTypeCheck30.symbols | 4 +- .../reference/generatorTypeCheck45.symbols | 2 +- .../reference/generatorTypeCheck46.symbols | 8 +- .../reference/iterableArrayPattern1.symbols | 8 +- .../reference/iterableArrayPattern11.symbols | 6 +- .../reference/iterableArrayPattern12.symbols | 6 +- .../reference/iterableArrayPattern13.symbols | 6 +- .../reference/iterableArrayPattern2.symbols | 8 +- .../reference/iterableArrayPattern3.symbols | 6 +- .../reference/iterableArrayPattern30.symbols | 2 +- .../reference/iterableArrayPattern4.symbols | 6 +- .../reference/iterableArrayPattern9.symbols | 6 +- .../iterableContextualTyping1.symbols | 2 +- .../reference/iteratorSpreadInArray.symbols | 8 +- .../reference/iteratorSpreadInArray11.symbols | 2 +- .../reference/iteratorSpreadInArray2.symbols | 14 +- .../reference/iteratorSpreadInArray3.symbols | 8 +- .../reference/iteratorSpreadInArray4.symbols | 8 +- .../reference/iteratorSpreadInArray7.symbols | 8 +- .../reference/iteratorSpreadInCall11.symbols | 8 +- .../reference/iteratorSpreadInCall12.symbols | 14 +- .../reference/iteratorSpreadInCall3.symbols | 8 +- .../reference/iteratorSpreadInCall5.symbols | 14 +- .../reference/parserSymbolProperty1.symbols | 6 +- .../reference/parserSymbolProperty2.symbols | 6 +- .../reference/parserSymbolProperty3.symbols | 6 +- .../reference/parserSymbolProperty4.symbols | 6 +- .../reference/parserSymbolProperty5.symbols | 6 +- .../reference/parserSymbolProperty6.symbols | 6 +- .../reference/parserSymbolProperty7.symbols | 6 +- .../reference/parserSymbolProperty8.symbols | 6 +- .../reference/parserSymbolProperty9.symbols | 6 +- .../promiseVoidErrorCallback.symbols | 16 +- .../reference/symbolDeclarationEmit1.symbols | 6 +- .../reference/symbolDeclarationEmit10.symbols | 12 +- .../reference/symbolDeclarationEmit11.symbols | 24 +- .../reference/symbolDeclarationEmit13.symbols | 12 +- .../reference/symbolDeclarationEmit14.symbols | 12 +- .../reference/symbolDeclarationEmit2.symbols | 6 +- .../reference/symbolDeclarationEmit3.symbols | 18 +- .../reference/symbolDeclarationEmit4.symbols | 12 +- .../reference/symbolDeclarationEmit5.symbols | 6 +- .../reference/symbolDeclarationEmit6.symbols | 6 +- .../reference/symbolDeclarationEmit7.symbols | 6 +- .../reference/symbolDeclarationEmit8.symbols | 6 +- .../reference/symbolDeclarationEmit9.symbols | 6 +- .../reference/symbolProperty11.symbols | 6 +- .../reference/symbolProperty13.symbols | 12 +- .../reference/symbolProperty14.symbols | 12 +- .../reference/symbolProperty15.symbols | 6 +- .../reference/symbolProperty16.symbols | 12 +- .../reference/symbolProperty18.symbols | 36 +- .../reference/symbolProperty19.symbols | 24 +- .../reference/symbolProperty2.symbols | 2 +- .../reference/symbolProperty20.symbols | 24 +- .../reference/symbolProperty21.symbols | 30 +- .../reference/symbolProperty22.symbols | 12 +- .../reference/symbolProperty23.symbols | 12 +- .../reference/symbolProperty26.symbols | 12 +- .../reference/symbolProperty27.symbols | 12 +- .../reference/symbolProperty28.symbols | 12 +- .../reference/symbolProperty4.symbols | 6 +- .../reference/symbolProperty40.symbols | 30 +- .../reference/symbolProperty41.symbols | 30 +- .../reference/symbolProperty45.symbols | 12 +- .../reference/symbolProperty5.symbols | 18 +- .../reference/symbolProperty50.symbols | 6 +- .../reference/symbolProperty51.symbols | 6 +- .../reference/symbolProperty55.symbols | 12 +- .../reference/symbolProperty56.symbols | 6 +- .../reference/symbolProperty57.symbols | 8 +- .../reference/symbolProperty6.symbols | 24 +- .../reference/symbolProperty8.symbols | 12 +- .../baselines/reference/symbolType11.symbols | 6 +- .../baselines/reference/symbolType16.symbols | 2 +- ...teStringWithEmbeddedNewOperatorES6.symbols | 2 +- tests/baselines/reference/typedArrays.symbols | 330 +++++++++--------- 141 files changed, 691 insertions(+), 691 deletions(-) diff --git a/src/harness/runner.ts b/src/harness/runner.ts index 42c2d5667c4..13d93302f18 100644 --- a/src/harness/runner.ts +++ b/src/harness/runner.ts @@ -49,7 +49,7 @@ if (testConfigFile !== '') { if (!option) { continue; } - ts.sys.write("Option: " + option + "\r\n"); + switch (option) { case 'compiler': runners.push(new CompilerBaselineRunner(CompilerTestType.Conformance)); diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols index 2b150438662..208646dc101 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols @@ -9,9 +9,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe let blah = arguments[Symbol.iterator]; >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7)) >arguments : Symbol(arguments) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) let result = []; >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols index 5a13a359581..faf0b130738 100644 --- a/tests/baselines/reference/arrayLiterals2ES6.symbols +++ b/tests/baselines/reference/arrayLiterals2ES6.symbols @@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]]; interface myArray extends Array { } >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) interface myArray2 extends Array { } >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) var d0 = [1, true, ...temp, ]; // has type (string|number|boolean)[] >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3)) diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols index db101992135..81712c324c0 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols @@ -2,6 +2,6 @@ var foo = async (): Promise => { >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) }; diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.symbols b/tests/baselines/reference/asyncArrowFunction9_es6.symbols index 706baa3fbb4..9714b119e72 100644 --- a/tests/baselines/reference/asyncArrowFunction9_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction9_es6.symbols @@ -4,5 +4,5 @@ var foo = async (a = await => await): Promise => { >a : Symbol(a, Decl(asyncArrowFunction9_es6.ts, 0, 17)) >await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) >await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols index e4fb76ac698..3bf5baec3b1 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols @@ -4,5 +4,5 @@ async function foo(a = await => await): Promise { >a : Symbol(a, Decl(asyncFunctionDeclaration10_es6.ts, 0, 19)) >await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) >await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols index 58bc3fc0146..339108848fa 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts === async function await(): Promise { >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols index b0a05f8d521..a9679f38692 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts === async function foo(): Promise { >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) return; } diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols index b5c3c1b837d..ce3b922cae8 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts === async function foo(): Promise { >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) } diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols index 19a480a376d..ea5174c2035 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = await p || a; diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols index b0398a73998..6b12c72bce4 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = await p && a; diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols index 0c0bd1815f5..c4e568a54e9 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols @@ -4,11 +4,11 @@ declare var a: number; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = await p + a; diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols index d5c3fa80d58..77c80010b64 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = await p, a; diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols index b1d75d324a4..451311947aa 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var o: { a: boolean; }; diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols index f574a34dd51..5d44f790f23 100644 --- a/tests/baselines/reference/awaitCallExpression1_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = fn(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols index 4e474e1db99..fdd6975f45b 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = fn(await p, a, a); diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols index 242b35baa3b..17ba0bf92c7 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = fn(a, await p, a); diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols index 66974f24a71..5bff8aa3b2e 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = (await pfn)(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols index 848168bc8d7..a5a88378074 100644 --- a/tests/baselines/reference/awaitCallExpression5_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = o.fn(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols index e8d1c38e9e2..ed6f52a4a50 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = o.fn(await p, a, a); diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols index ef8834d4050..3e901f6dd1b 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = o.fn(a, await p, a); diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols index 888062d58d2..fda2b254b17 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) "before"; var b = (await po).fn(a, a, a); diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols index 9cb8319d414..0e236821020 100644 --- a/tests/baselines/reference/callWithSpreadES6.symbols +++ b/tests/baselines/reference/callWithSpreadES6.symbols @@ -94,7 +94,7 @@ xa[1].foo(1, 2, ...a, "abc"); >a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) (xa[1].foo)(...[1, 2, "abc"]); ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 1367, 1)) +>Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 1368, 1)) >xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) >xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3)) >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols index 9f46ea81288..c232eb24636 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols @@ -8,18 +8,18 @@ type arrayString = Array >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) type someArray = Array | number[]; >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) type stringOrNumArray = Array; >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) function a1(...x: (number|string)[]) { } @@ -33,8 +33,8 @@ function a2(...a) { } function a3(...a: Array) { } >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) function a4(...a: arrayString) { } >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols index f5f6f0cc6fd..89f62f97185 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols @@ -8,18 +8,18 @@ type arrayString = Array >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) type someArray = Array | number[]; >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) type stringOrNumArray = Array; >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) function a1(...x: (number|string)[]) { } @@ -33,8 +33,8 @@ function a2(...a) { } function a3(...a: Array) { } >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1451, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1452, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) function a4(...a: arrayString) { } >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols index 98cb744f549..ad1482e7f1a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols @@ -5,7 +5,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1703, 60)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1704, 60)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) let arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols index 84dbbf9fca4..42db5aeaa85 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols @@ -8,7 +8,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1703, 60)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1704, 60)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) const arguments = 100; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols index d1b92562299..453e04d7521 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols @@ -8,7 +8,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1703, 60)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1704, 60)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments[0]; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols index 96973f9dbf4..b686dd19592 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols @@ -9,7 +9,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1703, 60)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1704, 60)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments[0]; diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols index 0b4e4b37fec..4ac60f9b429 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols @@ -9,7 +9,7 @@ function f() { if (Math.random()) { >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1703, 60)) +>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1704, 60)) >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) return () => arguments; diff --git a/tests/baselines/reference/for-of13.symbols b/tests/baselines/reference/for-of13.symbols index bc4595f73cf..08e5f4ff468 100644 --- a/tests/baselines/reference/for-of13.symbols +++ b/tests/baselines/reference/for-of13.symbols @@ -4,6 +4,6 @@ var v: string; for (v of [""].values()) { } >v : Symbol(v, Decl(for-of13.ts, 0, 3)) ->[""].values : Symbol(Array.values, Decl(lib.d.ts, 1465, 37)) ->values : Symbol(Array.values, Decl(lib.d.ts, 1465, 37)) +>[""].values : Symbol(Array.values, Decl(lib.d.ts, 1466, 37)) +>values : Symbol(Array.values, Decl(lib.d.ts, 1466, 37)) diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols index f5688d73566..066d9534051 100644 --- a/tests/baselines/reference/for-of18.symbols +++ b/tests/baselines/reference/for-of18.symbols @@ -22,9 +22,9 @@ class StringIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(StringIterator, Decl(for-of18.ts, 1, 33)) diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols index 182d45a3369..8c34f6f0d7a 100644 --- a/tests/baselines/reference/for-of19.symbols +++ b/tests/baselines/reference/for-of19.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(for-of19.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols index 4697f3283a6..4e7aaf7e362 100644 --- a/tests/baselines/reference/for-of20.symbols +++ b/tests/baselines/reference/for-of20.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(for-of20.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols index fcaf9b069dc..70c1132afbd 100644 --- a/tests/baselines/reference/for-of21.symbols +++ b/tests/baselines/reference/for-of21.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(for-of21.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols index f72094cdf4f..46507255937 100644 --- a/tests/baselines/reference/for-of22.symbols +++ b/tests/baselines/reference/for-of22.symbols @@ -28,9 +28,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(for-of22.ts, 5, 13)) diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols index 205a57d2c07..8401de024d9 100644 --- a/tests/baselines/reference/for-of23.symbols +++ b/tests/baselines/reference/for-of23.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(for-of23.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of25.symbols b/tests/baselines/reference/for-of25.symbols index 6ff68dea5d4..93e918c4bcd 100644 --- a/tests/baselines/reference/for-of25.symbols +++ b/tests/baselines/reference/for-of25.symbols @@ -10,9 +10,9 @@ class StringIterator { >StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 1, 37)) [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return x; >x : Symbol(x, Decl(for-of25.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of26.symbols b/tests/baselines/reference/for-of26.symbols index 19e917e7190..04445f50171 100644 --- a/tests/baselines/reference/for-of26.symbols +++ b/tests/baselines/reference/for-of26.symbols @@ -16,9 +16,9 @@ class StringIterator { >x : Symbol(x, Decl(for-of26.ts, 0, 3)) } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(StringIterator, Decl(for-of26.ts, 1, 37)) diff --git a/tests/baselines/reference/for-of27.symbols b/tests/baselines/reference/for-of27.symbols index edf8ab0a84c..4c645d359dd 100644 --- a/tests/baselines/reference/for-of27.symbols +++ b/tests/baselines/reference/for-of27.symbols @@ -7,7 +7,7 @@ class StringIterator { >StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 37)) [Symbol.iterator]: any; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) } diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols index d569ffae2f6..6887b46a44d 100644 --- a/tests/baselines/reference/for-of28.symbols +++ b/tests/baselines/reference/for-of28.symbols @@ -10,9 +10,9 @@ class StringIterator { >next : Symbol(next, Decl(for-of28.ts, 2, 22)) [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(StringIterator, Decl(for-of28.ts, 0, 37)) diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols index e4f958d5ac9..09d3b036829 100644 --- a/tests/baselines/reference/for-of37.symbols +++ b/tests/baselines/reference/for-of37.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of37.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of37.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1876, 1), Decl(lib.d.ts, 1898, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1877, 1), Decl(lib.d.ts, 1899, 11)) for (var v of map) { >v : Symbol(v, Decl(for-of37.ts, 1, 8)) diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols index e8205819ba1..d4958740698 100644 --- a/tests/baselines/reference/for-of38.symbols +++ b/tests/baselines/reference/for-of38.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of38.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of38.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1876, 1), Decl(lib.d.ts, 1898, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1877, 1), Decl(lib.d.ts, 1899, 11)) for (var [k, v] of map) { >k : Symbol(k, Decl(for-of38.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols index 3e54e9651a7..3ab18252114 100644 --- a/tests/baselines/reference/for-of40.symbols +++ b/tests/baselines/reference/for-of40.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of40.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of40.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1876, 1), Decl(lib.d.ts, 1898, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1877, 1), Decl(lib.d.ts, 1899, 11)) for (var [k = "", v = false] of map) { >k : Symbol(k, Decl(for-of40.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of44.symbols b/tests/baselines/reference/for-of44.symbols index 2c4ebb582f9..a9ea283d673 100644 --- a/tests/baselines/reference/for-of44.symbols +++ b/tests/baselines/reference/for-of44.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of44.ts === var array: [number, string | boolean | symbol][] = [[0, ""], [0, true], [1, Symbol()]] >array : Symbol(array, Decl(for-of44.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) for (var [num, strBoolSym] of array) { >num : Symbol(num, Decl(for-of44.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols index 96180033a37..3f746c05206 100644 --- a/tests/baselines/reference/for-of45.symbols +++ b/tests/baselines/reference/for-of45.symbols @@ -5,7 +5,7 @@ var k: string, v: boolean; var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of45.ts, 1, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1876, 1), Decl(lib.d.ts, 1898, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1877, 1), Decl(lib.d.ts, 1899, 11)) for ([k = "", v = false] of map) { >k : Symbol(k, Decl(for-of45.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols index a80a91b4fb6..e96abcae76e 100644 --- a/tests/baselines/reference/for-of50.symbols +++ b/tests/baselines/reference/for-of50.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of50.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of50.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1876, 1), Decl(lib.d.ts, 1898, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1877, 1), Decl(lib.d.ts, 1899, 11)) for (const [k, v] of map) { >k : Symbol(k, Decl(for-of50.ts, 1, 12)) diff --git a/tests/baselines/reference/for-of57.symbols b/tests/baselines/reference/for-of57.symbols index da7d83844f8..b8d01d3bd1b 100644 --- a/tests/baselines/reference/for-of57.symbols +++ b/tests/baselines/reference/for-of57.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of57.ts === var iter: Iterable; >iter : Symbol(iter, Decl(for-of57.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) for (let num of iter) { } >num : Symbol(num, Decl(for-of57.ts, 1, 8)) diff --git a/tests/baselines/reference/generatorES6_6.symbols b/tests/baselines/reference/generatorES6_6.symbols index 1a9c76911ef..7f30b4f6797 100644 --- a/tests/baselines/reference/generatorES6_6.symbols +++ b/tests/baselines/reference/generatorES6_6.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(generatorES6_6.ts, 0, 0)) *[Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) let a = yield 1; >a : Symbol(a, Decl(generatorES6_6.ts, 2, 7)) diff --git a/tests/baselines/reference/generatorOverloads4.symbols b/tests/baselines/reference/generatorOverloads4.symbols index 7327e0f22ce..c4fb9401517 100644 --- a/tests/baselines/reference/generatorOverloads4.symbols +++ b/tests/baselines/reference/generatorOverloads4.symbols @@ -5,15 +5,15 @@ class C { f(s: string): Iterable; >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32)) >s : Symbol(s, Decl(generatorOverloads4.ts, 1, 6)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) f(s: number): Iterable; >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32)) >s : Symbol(s, Decl(generatorOverloads4.ts, 2, 6)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) *f(s: any): Iterable { } >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32)) >s : Symbol(s, Decl(generatorOverloads4.ts, 3, 7)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) } diff --git a/tests/baselines/reference/generatorOverloads5.symbols b/tests/baselines/reference/generatorOverloads5.symbols index a0cb5ed3610..509ed22d197 100644 --- a/tests/baselines/reference/generatorOverloads5.symbols +++ b/tests/baselines/reference/generatorOverloads5.symbols @@ -5,15 +5,15 @@ module M { function f(s: string): Iterable; >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41)) >s : Symbol(s, Decl(generatorOverloads5.ts, 1, 15)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) function f(s: number): Iterable; >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41)) >s : Symbol(s, Decl(generatorOverloads5.ts, 2, 15)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) function* f(s: any): Iterable { } >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41)) >s : Symbol(s, Decl(generatorOverloads5.ts, 3, 16)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) } diff --git a/tests/baselines/reference/generatorTypeCheck1.symbols b/tests/baselines/reference/generatorTypeCheck1.symbols index 775148b80e1..79cc3e275ad 100644 --- a/tests/baselines/reference/generatorTypeCheck1.symbols +++ b/tests/baselines/reference/generatorTypeCheck1.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts === function* g1(): Iterator { } >g1 : Symbol(g1, Decl(generatorTypeCheck1.ts, 0, 0)) ->Iterator : Symbol(Iterator, Decl(lib.d.ts, 1674, 1)) +>Iterator : Symbol(Iterator, Decl(lib.d.ts, 1675, 1)) diff --git a/tests/baselines/reference/generatorTypeCheck10.symbols b/tests/baselines/reference/generatorTypeCheck10.symbols index bd652fdae92..6247bd7b85c 100644 --- a/tests/baselines/reference/generatorTypeCheck10.symbols +++ b/tests/baselines/reference/generatorTypeCheck10.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts === function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck10.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) return; } diff --git a/tests/baselines/reference/generatorTypeCheck11.symbols b/tests/baselines/reference/generatorTypeCheck11.symbols index 2ede04e04ce..dce2524d1ba 100644 --- a/tests/baselines/reference/generatorTypeCheck11.symbols +++ b/tests/baselines/reference/generatorTypeCheck11.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts === function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck11.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) return 0; } diff --git a/tests/baselines/reference/generatorTypeCheck12.symbols b/tests/baselines/reference/generatorTypeCheck12.symbols index 49309243b64..f9c9b7b6e22 100644 --- a/tests/baselines/reference/generatorTypeCheck12.symbols +++ b/tests/baselines/reference/generatorTypeCheck12.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts === function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck12.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) return ""; } diff --git a/tests/baselines/reference/generatorTypeCheck13.symbols b/tests/baselines/reference/generatorTypeCheck13.symbols index 13f633d527e..bc43ea8c8f9 100644 --- a/tests/baselines/reference/generatorTypeCheck13.symbols +++ b/tests/baselines/reference/generatorTypeCheck13.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts === function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck13.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) yield 0; return ""; diff --git a/tests/baselines/reference/generatorTypeCheck17.symbols b/tests/baselines/reference/generatorTypeCheck17.symbols index ce5f683d238..789eb22347c 100644 --- a/tests/baselines/reference/generatorTypeCheck17.symbols +++ b/tests/baselines/reference/generatorTypeCheck17.symbols @@ -10,7 +10,7 @@ class Bar extends Foo { y: string } function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck17.ts, 1, 35)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) >Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0)) yield; diff --git a/tests/baselines/reference/generatorTypeCheck19.symbols b/tests/baselines/reference/generatorTypeCheck19.symbols index 0b4d61fb292..e7a5898099f 100644 --- a/tests/baselines/reference/generatorTypeCheck19.symbols +++ b/tests/baselines/reference/generatorTypeCheck19.symbols @@ -10,7 +10,7 @@ class Bar extends Foo { y: string } function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck19.ts, 1, 35)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) >Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0)) yield; diff --git a/tests/baselines/reference/generatorTypeCheck2.symbols b/tests/baselines/reference/generatorTypeCheck2.symbols index 009568c15a7..5a0aec4d592 100644 --- a/tests/baselines/reference/generatorTypeCheck2.symbols +++ b/tests/baselines/reference/generatorTypeCheck2.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts === function* g1(): Iterable { } >g1 : Symbol(g1, Decl(generatorTypeCheck2.ts, 0, 0)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols index 6feb9b6fabd..08cc7289ef8 100644 --- a/tests/baselines/reference/generatorTypeCheck26.symbols +++ b/tests/baselines/reference/generatorTypeCheck26.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts === function* g(): IterableIterator<(x: string) => number> { >g : Symbol(g, Decl(generatorTypeCheck26.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33)) yield x => x.length; diff --git a/tests/baselines/reference/generatorTypeCheck27.symbols b/tests/baselines/reference/generatorTypeCheck27.symbols index 01cd720ca77..fcee922d1e9 100644 --- a/tests/baselines/reference/generatorTypeCheck27.symbols +++ b/tests/baselines/reference/generatorTypeCheck27.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts === function* g(): IterableIterator<(x: string) => number> { >g : Symbol(g, Decl(generatorTypeCheck27.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) >x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33)) yield * function* () { diff --git a/tests/baselines/reference/generatorTypeCheck28.symbols b/tests/baselines/reference/generatorTypeCheck28.symbols index 11ddf19bf40..27b246515f6 100644 --- a/tests/baselines/reference/generatorTypeCheck28.symbols +++ b/tests/baselines/reference/generatorTypeCheck28.symbols @@ -1,14 +1,14 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts === function* g(): IterableIterator<(x: string) => number> { >g : Symbol(g, Decl(generatorTypeCheck28.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) >x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33)) yield * { *[Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) yield x => x.length; >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17)) diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols index 72e4d2dc749..260137dd1cf 100644 --- a/tests/baselines/reference/generatorTypeCheck29.symbols +++ b/tests/baselines/reference/generatorTypeCheck29.symbols @@ -1,8 +1,8 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts === function* g2(): Iterator number>> { >g2 : Symbol(g2, Decl(generatorTypeCheck29.ts, 0, 0)) ->Iterator : Symbol(Iterator, Decl(lib.d.ts, 1674, 1)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterator : Symbol(Iterator, Decl(lib.d.ts, 1675, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35)) yield function* () { diff --git a/tests/baselines/reference/generatorTypeCheck3.symbols b/tests/baselines/reference/generatorTypeCheck3.symbols index f39c8675d98..a149a592e3d 100644 --- a/tests/baselines/reference/generatorTypeCheck3.symbols +++ b/tests/baselines/reference/generatorTypeCheck3.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts === function* g1(): IterableIterator { } >g1 : Symbol(g1, Decl(generatorTypeCheck3.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1684, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1685, 1)) diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols index c489eb83f2b..086c65685a8 100644 --- a/tests/baselines/reference/generatorTypeCheck30.symbols +++ b/tests/baselines/reference/generatorTypeCheck30.symbols @@ -1,8 +1,8 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts === function* g2(): Iterator number>> { >g2 : Symbol(g2, Decl(generatorTypeCheck30.ts, 0, 0)) ->Iterator : Symbol(Iterator, Decl(lib.d.ts, 1674, 1)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterator : Symbol(Iterator, Decl(lib.d.ts, 1675, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35)) yield function* () { diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols index ccf9fbe57eb..89c01ff0203 100644 --- a/tests/baselines/reference/generatorTypeCheck45.symbols +++ b/tests/baselines/reference/generatorTypeCheck45.symbols @@ -6,7 +6,7 @@ declare function foo(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 27)) >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21)) >fun : Symbol(fun, Decl(generatorTypeCheck45.ts, 0, 32)) ->Iterator : Symbol(Iterator, Decl(lib.d.ts, 1674, 1)) +>Iterator : Symbol(Iterator, Decl(lib.d.ts, 1675, 1)) >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 54)) >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21)) >U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23)) diff --git a/tests/baselines/reference/generatorTypeCheck46.symbols b/tests/baselines/reference/generatorTypeCheck46.symbols index 853f0ffab16..72d8ebf57a1 100644 --- a/tests/baselines/reference/generatorTypeCheck46.symbols +++ b/tests/baselines/reference/generatorTypeCheck46.symbols @@ -6,7 +6,7 @@ declare function foo(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 27)) >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21)) >fun : Symbol(fun, Decl(generatorTypeCheck46.ts, 0, 32)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 54)) >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21)) >U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23)) @@ -21,9 +21,9 @@ foo("", function* () { yield* { *[Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) yield x => x.length >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17)) diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols index d7877b5947a..3920dc1cef4 100644 --- a/tests/baselines/reference/iterableArrayPattern1.symbols +++ b/tests/baselines/reference/iterableArrayPattern1.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iterableArrayPattern1.ts, 3, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iterableArrayPattern1.ts, 4, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iterableArrayPattern1.ts, 0, 32)) diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols index a4dae0104c8..06e38c57af4 100644 --- a/tests/baselines/reference/iterableArrayPattern11.symbols +++ b/tests/baselines/reference/iterableArrayPattern11.symbols @@ -36,9 +36,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern11.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols index 124fc600b06..e16fe5255e4 100644 --- a/tests/baselines/reference/iterableArrayPattern12.symbols +++ b/tests/baselines/reference/iterableArrayPattern12.symbols @@ -36,9 +36,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern12.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols index 43641993f34..b8709197829 100644 --- a/tests/baselines/reference/iterableArrayPattern13.symbols +++ b/tests/baselines/reference/iterableArrayPattern13.symbols @@ -35,9 +35,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern13.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols index ded5eea8726..17ac6a1feac 100644 --- a/tests/baselines/reference/iterableArrayPattern2.symbols +++ b/tests/baselines/reference/iterableArrayPattern2.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iterableArrayPattern2.ts, 3, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iterableArrayPattern2.ts, 4, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iterableArrayPattern2.ts, 0, 35)) diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols index 85ecd34218b..468866ca324 100644 --- a/tests/baselines/reference/iterableArrayPattern3.symbols +++ b/tests/baselines/reference/iterableArrayPattern3.symbols @@ -37,9 +37,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern3.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols index af6f8c617b2..3701cc85ed8 100644 --- a/tests/baselines/reference/iterableArrayPattern30.symbols +++ b/tests/baselines/reference/iterableArrayPattern30.symbols @@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]) >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11)) >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18)) >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21)) ->Map : Symbol(Map, Decl(lib.d.ts, 1876, 1), Decl(lib.d.ts, 1898, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1877, 1), Decl(lib.d.ts, 1899, 11)) diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols index b6b569d15c6..10225e183e6 100644 --- a/tests/baselines/reference/iterableArrayPattern4.symbols +++ b/tests/baselines/reference/iterableArrayPattern4.symbols @@ -37,9 +37,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern4.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols index 0722765c4de..86c46812688 100644 --- a/tests/baselines/reference/iterableArrayPattern9.symbols +++ b/tests/baselines/reference/iterableArrayPattern9.symbols @@ -32,9 +32,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern9.ts, 2, 27)) diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols index 3960aa4d5d1..ae99a4b5255 100644 --- a/tests/baselines/reference/iterableContextualTyping1.symbols +++ b/tests/baselines/reference/iterableContextualTyping1.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts === var iter: Iterable<(x: string) => number> = [s => s.length]; >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20)) >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45)) >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols index e7085745aa7..c4a2459e262 100644 --- a/tests/baselines/reference/iteratorSpreadInArray.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray.ts, 0, 36)) diff --git a/tests/baselines/reference/iteratorSpreadInArray11.symbols b/tests/baselines/reference/iteratorSpreadInArray11.symbols index 882df437fd3..c2fce062fb0 100644 --- a/tests/baselines/reference/iteratorSpreadInArray11.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray11.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts === var iter: Iterable; >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1680, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1681, 1)) var array = [...iter]; >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3)) diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols index 7bc6808d849..cdc7bb3e2bc 100644 --- a/tests/baselines/reference/iteratorSpreadInArray2.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray2.ts, 5, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray2.ts, 0, 59)) @@ -48,9 +48,9 @@ class NumberIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(NumberIterator, Decl(iteratorSpreadInArray2.ts, 13, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols index bded5309f83..e4d1b508bb5 100644 --- a/tests/baselines/reference/iteratorSpreadInArray3.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray3.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray3.ts, 0, 47)) diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols index 0dbe4711e95..bd6760dd0aa 100644 --- a/tests/baselines/reference/iteratorSpreadInArray4.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray4.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray4.ts, 0, 42)) diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols index 50725a3f99f..d0bc9790752 100644 --- a/tests/baselines/reference/iteratorSpreadInArray7.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols @@ -17,7 +17,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray7.ts, 6, 28)) @@ -26,9 +26,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 1, 38)) diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols index ac52c5d172a..a7e5d7b8919 100644 --- a/tests/baselines/reference/iteratorSpreadInCall11.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols @@ -19,7 +19,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 6, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall11.ts, 7, 28)) @@ -28,9 +28,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall11.ts, 2, 42)) diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols index 8ac205edcc5..67b9e9e500d 100644 --- a/tests/baselines/reference/iteratorSpreadInCall12.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols @@ -22,7 +22,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 8, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall12.ts, 9, 28)) @@ -31,9 +31,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall12.ts, 4, 1)) @@ -57,9 +57,9 @@ class StringIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 17, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols index 12e4bd1bb9b..0c3c11c84f4 100644 --- a/tests/baselines/reference/iteratorSpreadInCall3.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols @@ -16,7 +16,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall3.ts, 6, 28)) @@ -25,9 +25,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall3.ts, 2, 32)) diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols index 06226958069..03faf4b593e 100644 --- a/tests/baselines/reference/iteratorSpreadInCall5.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols @@ -17,7 +17,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall5.ts, 6, 28)) @@ -26,9 +26,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall5.ts, 2, 43)) @@ -52,9 +52,9 @@ class StringIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) return this; >this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 14, 1)) diff --git a/tests/baselines/reference/parserSymbolProperty1.symbols b/tests/baselines/reference/parserSymbolProperty1.symbols index 72d4ad96aac..5d97b2d7a01 100644 --- a/tests/baselines/reference/parserSymbolProperty1.symbols +++ b/tests/baselines/reference/parserSymbolProperty1.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(parserSymbolProperty1.ts, 0, 0)) [Symbol.iterator]: string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) } diff --git a/tests/baselines/reference/parserSymbolProperty2.symbols b/tests/baselines/reference/parserSymbolProperty2.symbols index 77eb6c61059..69764d70b45 100644 --- a/tests/baselines/reference/parserSymbolProperty2.symbols +++ b/tests/baselines/reference/parserSymbolProperty2.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(parserSymbolProperty2.ts, 0, 0)) [Symbol.unscopables](): string; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty3.symbols b/tests/baselines/reference/parserSymbolProperty3.symbols index 5f7f13956a8..c42bb3abb83 100644 --- a/tests/baselines/reference/parserSymbolProperty3.symbols +++ b/tests/baselines/reference/parserSymbolProperty3.symbols @@ -3,7 +3,7 @@ declare class C { >C : Symbol(C, Decl(parserSymbolProperty3.ts, 0, 0)) [Symbol.unscopables](): string; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty4.symbols b/tests/baselines/reference/parserSymbolProperty4.symbols index 94701b8908a..ba93afde837 100644 --- a/tests/baselines/reference/parserSymbolProperty4.symbols +++ b/tests/baselines/reference/parserSymbolProperty4.symbols @@ -3,7 +3,7 @@ declare class C { >C : Symbol(C, Decl(parserSymbolProperty4.ts, 0, 0)) [Symbol.toPrimitive]: string; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty5.symbols b/tests/baselines/reference/parserSymbolProperty5.symbols index b91cd771c5d..4829677f516 100644 --- a/tests/baselines/reference/parserSymbolProperty5.symbols +++ b/tests/baselines/reference/parserSymbolProperty5.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty5.ts, 0, 0)) [Symbol.toPrimitive]: string; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty6.symbols b/tests/baselines/reference/parserSymbolProperty6.symbols index 4762fb4fd70..793b925b382 100644 --- a/tests/baselines/reference/parserSymbolProperty6.symbols +++ b/tests/baselines/reference/parserSymbolProperty6.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty6.ts, 0, 0)) [Symbol.toStringTag]: string = ""; ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty7.symbols b/tests/baselines/reference/parserSymbolProperty7.symbols index 0eb96fa03b0..e1b85f2a3b9 100644 --- a/tests/baselines/reference/parserSymbolProperty7.symbols +++ b/tests/baselines/reference/parserSymbolProperty7.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty7.ts, 0, 0)) [Symbol.toStringTag](): void { } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) } diff --git a/tests/baselines/reference/parserSymbolProperty8.symbols b/tests/baselines/reference/parserSymbolProperty8.symbols index cc11d61259e..05b002eb569 100644 --- a/tests/baselines/reference/parserSymbolProperty8.symbols +++ b/tests/baselines/reference/parserSymbolProperty8.symbols @@ -3,7 +3,7 @@ var x: { >x : Symbol(x, Decl(parserSymbolProperty8.ts, 0, 3)) [Symbol.toPrimitive](): string ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) } diff --git a/tests/baselines/reference/parserSymbolProperty9.symbols b/tests/baselines/reference/parserSymbolProperty9.symbols index eae90071b65..774eb2dcc4b 100644 --- a/tests/baselines/reference/parserSymbolProperty9.symbols +++ b/tests/baselines/reference/parserSymbolProperty9.symbols @@ -3,7 +3,7 @@ var x: { >x : Symbol(x, Decl(parserSymbolProperty9.ts, 0, 3)) [Symbol.toPrimitive]: string ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) } diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols index aa15fc01659..b01825c8ad9 100644 --- a/tests/baselines/reference/promiseVoidErrorCallback.symbols +++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols @@ -22,13 +22,13 @@ interface T3 { function f1(): Promise { >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0)) return Promise.resolve({ __t1: "foo_t1" }); ->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4835, 39), Decl(lib.d.ts, 4842, 54)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4767, 1), Decl(lib.d.ts, 4853, 11)) ->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4835, 39), Decl(lib.d.ts, 4842, 54)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4836, 39), Decl(lib.d.ts, 4843, 54)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4836, 39), Decl(lib.d.ts, 4843, 54)) >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28)) } @@ -47,12 +47,12 @@ function f2(x: T1): T2 { var x3 = f1() >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3)) ->f1() .then(f2, (e: Error) => { throw e;}) .then : Symbol(Promise.then, Decl(lib.d.ts, 4772, 22), Decl(lib.d.ts, 4779, 158)) ->f1() .then : Symbol(Promise.then, Decl(lib.d.ts, 4772, 22), Decl(lib.d.ts, 4779, 158)) +>f1() .then(f2, (e: Error) => { throw e;}) .then : Symbol(Promise.then, Decl(lib.d.ts, 4773, 22), Decl(lib.d.ts, 4780, 158)) +>f1() .then : Symbol(Promise.then, Decl(lib.d.ts, 4773, 22), Decl(lib.d.ts, 4780, 158)) >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) .then(f2, (e: Error) => { ->then : Symbol(Promise.then, Decl(lib.d.ts, 4772, 22), Decl(lib.d.ts, 4779, 158)) +>then : Symbol(Promise.then, Decl(lib.d.ts, 4773, 22), Decl(lib.d.ts, 4780, 158)) >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1)) >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15)) >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) @@ -62,7 +62,7 @@ var x3 = f1() }) .then((x: T2) => { ->then : Symbol(Promise.then, Decl(lib.d.ts, 4772, 22), Decl(lib.d.ts, 4779, 158)) +>then : Symbol(Promise.then, Decl(lib.d.ts, 4773, 22), Decl(lib.d.ts, 4780, 158)) >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11)) >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1)) diff --git a/tests/baselines/reference/symbolDeclarationEmit1.symbols b/tests/baselines/reference/symbolDeclarationEmit1.symbols index 0b0e820404b..9fae9d57c4f 100644 --- a/tests/baselines/reference/symbolDeclarationEmit1.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit1.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit1.ts, 0, 0)) [Symbol.toPrimitive]: number; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols index 5ed853abd19..5dba2268d26 100644 --- a/tests/baselines/reference/symbolDeclarationEmit10.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols @@ -3,13 +3,13 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3)) get [Symbol.isConcatSpreadable]() { return '' }, ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) set [Symbol.isConcatSpreadable](x) { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) >x : Symbol(x, Decl(symbolDeclarationEmit10.ts, 2, 36)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit11.symbols b/tests/baselines/reference/symbolDeclarationEmit11.symbols index 44115a3e730..a6019a364e4 100644 --- a/tests/baselines/reference/symbolDeclarationEmit11.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit11.symbols @@ -3,23 +3,23 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit11.ts, 0, 0)) static [Symbol.iterator] = 0; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) static [Symbol.isConcatSpreadable]() { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) static get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) static set [Symbol.toPrimitive](x) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit11.ts, 4, 36)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit13.symbols b/tests/baselines/reference/symbolDeclarationEmit13.symbols index a0aa4e1142a..e16ec738489 100644 --- a/tests/baselines/reference/symbolDeclarationEmit13.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit13.symbols @@ -3,13 +3,13 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit13.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) set [Symbol.toStringTag](x) { } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) >x : Symbol(x, Decl(symbolDeclarationEmit13.ts, 2, 29)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit14.symbols b/tests/baselines/reference/symbolDeclarationEmit14.symbols index 0acef2d8a71..b2f520351f2 100644 --- a/tests/baselines/reference/symbolDeclarationEmit14.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit14.symbols @@ -3,12 +3,12 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit14.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) get [Symbol.toStringTag]() { return ""; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit2.symbols b/tests/baselines/reference/symbolDeclarationEmit2.symbols index bfcf6243d9e..7e9d06cd332 100644 --- a/tests/baselines/reference/symbolDeclarationEmit2.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit2.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit2.ts, 0, 0)) [Symbol.toPrimitive] = ""; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit3.symbols b/tests/baselines/reference/symbolDeclarationEmit3.symbols index fcfcd0efe14..177180b5bca 100644 --- a/tests/baselines/reference/symbolDeclarationEmit3.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit3.symbols @@ -3,20 +3,20 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit3.ts, 0, 0)) [Symbol.toPrimitive](x: number); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 1, 25)) [Symbol.toPrimitive](x: string); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 2, 25)) [Symbol.toPrimitive](x: any) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 3, 25)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit4.symbols b/tests/baselines/reference/symbolDeclarationEmit4.symbols index 28d4602b181..98cb277ad47 100644 --- a/tests/baselines/reference/symbolDeclarationEmit4.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit4.symbols @@ -3,13 +3,13 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit4.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) set [Symbol.toPrimitive](x) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) >x : Symbol(x, Decl(symbolDeclarationEmit4.ts, 2, 29)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit5.symbols b/tests/baselines/reference/symbolDeclarationEmit5.symbols index c8a7ab36e94..17bda345253 100644 --- a/tests/baselines/reference/symbolDeclarationEmit5.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit5.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(symbolDeclarationEmit5.ts, 0, 0)) [Symbol.isConcatSpreadable](): string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit6.symbols b/tests/baselines/reference/symbolDeclarationEmit6.symbols index d535c8ce1ec..c4b046cc146 100644 --- a/tests/baselines/reference/symbolDeclarationEmit6.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit6.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(symbolDeclarationEmit6.ts, 0, 0)) [Symbol.isConcatSpreadable]: string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit7.symbols b/tests/baselines/reference/symbolDeclarationEmit7.symbols index 0860dae4a27..58a661412da 100644 --- a/tests/baselines/reference/symbolDeclarationEmit7.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit7.symbols @@ -3,7 +3,7 @@ var obj: { >obj : Symbol(obj, Decl(symbolDeclarationEmit7.ts, 0, 3)) [Symbol.isConcatSpreadable]: string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols index 21faad44029..7879d28b02f 100644 --- a/tests/baselines/reference/symbolDeclarationEmit8.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols @@ -3,7 +3,7 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3)) [Symbol.isConcatSpreadable]: 0 ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols index 9212123105d..17901fb713a 100644 --- a/tests/baselines/reference/symbolDeclarationEmit9.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols @@ -3,7 +3,7 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3)) [Symbol.isConcatSpreadable]() { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) } diff --git a/tests/baselines/reference/symbolProperty11.symbols b/tests/baselines/reference/symbolProperty11.symbols index 952846d768d..4028da455a6 100644 --- a/tests/baselines/reference/symbolProperty11.symbols +++ b/tests/baselines/reference/symbolProperty11.symbols @@ -6,9 +6,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty11.ts, 0, 11)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty11.ts, 2, 25)) } diff --git a/tests/baselines/reference/symbolProperty13.symbols b/tests/baselines/reference/symbolProperty13.symbols index 3b5685d1d77..07e9b6bae26 100644 --- a/tests/baselines/reference/symbolProperty13.symbols +++ b/tests/baselines/reference/symbolProperty13.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(symbolProperty13.ts, 0, 0)) [Symbol.iterator]: { x; y }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty13.ts, 1, 24)) >y : Symbol(y, Decl(symbolProperty13.ts, 1, 27)) } @@ -13,9 +13,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty13.ts, 2, 1)) [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty13.ts, 4, 24)) } diff --git a/tests/baselines/reference/symbolProperty14.symbols b/tests/baselines/reference/symbolProperty14.symbols index b47ae5d912d..d4e79a064a9 100644 --- a/tests/baselines/reference/symbolProperty14.symbols +++ b/tests/baselines/reference/symbolProperty14.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(symbolProperty14.ts, 0, 0)) [Symbol.iterator]: { x; y }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty14.ts, 1, 24)) >y : Symbol(y, Decl(symbolProperty14.ts, 1, 27)) } @@ -13,9 +13,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty14.ts, 2, 1)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty14.ts, 4, 25)) } diff --git a/tests/baselines/reference/symbolProperty15.symbols b/tests/baselines/reference/symbolProperty15.symbols index ac05eb6195e..2a83145da03 100644 --- a/tests/baselines/reference/symbolProperty15.symbols +++ b/tests/baselines/reference/symbolProperty15.symbols @@ -6,9 +6,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty15.ts, 0, 11)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty15.ts, 2, 25)) } diff --git a/tests/baselines/reference/symbolProperty16.symbols b/tests/baselines/reference/symbolProperty16.symbols index c45b22056af..1b4b23e9511 100644 --- a/tests/baselines/reference/symbolProperty16.symbols +++ b/tests/baselines/reference/symbolProperty16.symbols @@ -3,18 +3,18 @@ class C { >C : Symbol(C, Decl(symbolProperty16.ts, 0, 0)) private [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty16.ts, 1, 32)) } interface I { >I : Symbol(I, Decl(symbolProperty16.ts, 2, 1)) [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty16.ts, 4, 24)) } diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols index 40c5a86c0e9..89df72d6543 100644 --- a/tests/baselines/reference/symbolProperty18.symbols +++ b/tests/baselines/reference/symbolProperty18.symbols @@ -3,39 +3,39 @@ var i = { >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) [Symbol.iterator]: 0, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) [Symbol.toStringTag]() { return "" }, ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) set [Symbol.toPrimitive](p: boolean) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) >p : Symbol(p, Decl(symbolProperty18.ts, 3, 29)) } var it = i[Symbol.iterator]; >it : Symbol(it, Decl(symbolProperty18.ts, 6, 3)) >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) var str = i[Symbol.toStringTag](); >str : Symbol(str, Decl(symbolProperty18.ts, 7, 3)) >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) i[Symbol.toPrimitive] = false; >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols index 909c6394ec2..3ee9ed595c2 100644 --- a/tests/baselines/reference/symbolProperty19.symbols +++ b/tests/baselines/reference/symbolProperty19.symbols @@ -3,15 +3,15 @@ var i = { >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) [Symbol.iterator]: { p: null }, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >p : Symbol(p, Decl(symbolProperty19.ts, 1, 24)) [Symbol.toStringTag]() { return { p: undefined }; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37)) >undefined : Symbol(undefined) } @@ -19,14 +19,14 @@ var i = { var it = i[Symbol.iterator]; >it : Symbol(it, Decl(symbolProperty19.ts, 5, 3)) >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) var str = i[Symbol.toStringTag](); >str : Symbol(str, Decl(symbolProperty19.ts, 6, 3)) >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols index 9d618e7751f..b52c4087d71 100644 --- a/tests/baselines/reference/symbolProperty2.symbols +++ b/tests/baselines/reference/symbolProperty2.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/Symbols/symbolProperty2.ts === var s = Symbol(); >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) var x = { >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3)) diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols index b12874d028b..ad4f0c79523 100644 --- a/tests/baselines/reference/symbolProperty20.symbols +++ b/tests/baselines/reference/symbolProperty20.symbols @@ -3,15 +3,15 @@ interface I { >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0)) [Symbol.iterator]: (s: string) => string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >s : Symbol(s, Decl(symbolProperty20.ts, 1, 24)) [Symbol.toStringTag](s: number): number; ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) >s : Symbol(s, Decl(symbolProperty20.ts, 2, 25)) } @@ -20,16 +20,16 @@ var i: I = { >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0)) [Symbol.iterator]: s => s, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22)) >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22)) [Symbol.toStringTag](n) { return n; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25)) >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25)) } diff --git a/tests/baselines/reference/symbolProperty21.symbols b/tests/baselines/reference/symbolProperty21.symbols index b0632e2eaae..09997f687d5 100644 --- a/tests/baselines/reference/symbolProperty21.symbols +++ b/tests/baselines/reference/symbolProperty21.symbols @@ -5,15 +5,15 @@ interface I { >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14)) [Symbol.unscopables]: T; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) >T : Symbol(T, Decl(symbolProperty21.ts, 0, 12)) [Symbol.isConcatSpreadable]: U; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14)) } @@ -34,18 +34,18 @@ foo({ >foo : Symbol(foo, Decl(symbolProperty21.ts, 3, 1)) [Symbol.isConcatSpreadable]: "", ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1242, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1243, 24)) [Symbol.toPrimitive]: 0, ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) [Symbol.unscopables]: true ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) }); diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols index 4c8ec1aa7f5..b62037e32a5 100644 --- a/tests/baselines/reference/symbolProperty22.symbols +++ b/tests/baselines/reference/symbolProperty22.symbols @@ -5,9 +5,9 @@ interface I { >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14)) [Symbol.unscopables](x: T): U; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) >x : Symbol(x, Decl(symbolProperty22.ts, 1, 25)) >T : Symbol(T, Decl(symbolProperty22.ts, 0, 12)) >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14)) @@ -27,9 +27,9 @@ declare function foo(p1: T, p2: I): U; foo("", { [Symbol.unscopables]: s => s.length }); >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1)) ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31)) >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31)) diff --git a/tests/baselines/reference/symbolProperty23.symbols b/tests/baselines/reference/symbolProperty23.symbols index a8ebaf95345..da9d07ffeed 100644 --- a/tests/baselines/reference/symbolProperty23.symbols +++ b/tests/baselines/reference/symbolProperty23.symbols @@ -3,9 +3,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0)) [Symbol.toPrimitive]: () => boolean; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) } class C implements I { @@ -13,9 +13,9 @@ class C implements I { >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0)) [Symbol.toPrimitive]() { ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) return true; } diff --git a/tests/baselines/reference/symbolProperty26.symbols b/tests/baselines/reference/symbolProperty26.symbols index b5c726712e4..46babb69a87 100644 --- a/tests/baselines/reference/symbolProperty26.symbols +++ b/tests/baselines/reference/symbolProperty26.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) return ""; } @@ -16,9 +16,9 @@ class C2 extends C1 { >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) return ""; } diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols index 039963b02aa..69fe473e17c 100644 --- a/tests/baselines/reference/symbolProperty27.symbols +++ b/tests/baselines/reference/symbolProperty27.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) return {}; } @@ -16,9 +16,9 @@ class C2 extends C1 { >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) return ""; } diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols index 6ba9c126943..cf6ab1f5edb 100644 --- a/tests/baselines/reference/symbolProperty28.symbols +++ b/tests/baselines/reference/symbolProperty28.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty28.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) return { x: "" }; >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) @@ -24,8 +24,8 @@ var obj = c[Symbol.toStringTag]().x; >obj : Symbol(obj, Decl(symbolProperty28.ts, 9, 3)) >c[Symbol.toStringTag]().x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) >c : Symbol(c, Decl(symbolProperty28.ts, 8, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols index 99961ec6629..4e17e561bce 100644 --- a/tests/baselines/reference/symbolProperty4.symbols +++ b/tests/baselines/reference/symbolProperty4.symbols @@ -3,13 +3,13 @@ var x = { >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3)) [Symbol()]: 0, ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) [Symbol()]() { }, ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) get [Symbol()]() { ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) return 0; } diff --git a/tests/baselines/reference/symbolProperty40.symbols b/tests/baselines/reference/symbolProperty40.symbols index 62acefd45c2..e3e469764a8 100644 --- a/tests/baselines/reference/symbolProperty40.symbols +++ b/tests/baselines/reference/symbolProperty40.symbols @@ -3,21 +3,21 @@ class C { >C : Symbol(C, Decl(symbolProperty40.ts, 0, 0)) [Symbol.iterator](x: string): string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 1, 22)) [Symbol.iterator](x: number): number; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 2, 22)) [Symbol.iterator](x: any) { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty40.ts, 3, 22)) return undefined; @@ -31,13 +31,13 @@ var c = new C; c[Symbol.iterator](""); >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) c[Symbol.iterator](0); >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) diff --git a/tests/baselines/reference/symbolProperty41.symbols b/tests/baselines/reference/symbolProperty41.symbols index 1635419694d..622d1b693e8 100644 --- a/tests/baselines/reference/symbolProperty41.symbols +++ b/tests/baselines/reference/symbolProperty41.symbols @@ -3,24 +3,24 @@ class C { >C : Symbol(C, Decl(symbolProperty41.ts, 0, 0)) [Symbol.iterator](x: string): { x: string }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 1, 22)) >x : Symbol(x, Decl(symbolProperty41.ts, 1, 35)) [Symbol.iterator](x: "hello"): { x: string; hello: string }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 2, 22)) >x : Symbol(x, Decl(symbolProperty41.ts, 2, 36)) >hello : Symbol(hello, Decl(symbolProperty41.ts, 2, 47)) [Symbol.iterator](x: any) { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >x : Symbol(x, Decl(symbolProperty41.ts, 3, 22)) return undefined; @@ -34,13 +34,13 @@ var c = new C; c[Symbol.iterator](""); >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) c[Symbol.iterator]("hello"); >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) diff --git a/tests/baselines/reference/symbolProperty45.symbols b/tests/baselines/reference/symbolProperty45.symbols index 67fce3aefab..5aba3b8c104 100644 --- a/tests/baselines/reference/symbolProperty45.symbols +++ b/tests/baselines/reference/symbolProperty45.symbols @@ -3,16 +3,16 @@ class C { >C : Symbol(C, Decl(symbolProperty45.ts, 0, 0)) get [Symbol.hasInstance]() { ->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1234, 32)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1234, 32)) +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1235, 32)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1235, 32)) return ""; } get [Symbol.toPrimitive]() { ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) return ""; } diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols index 4dc58d689d8..7b57003e607 100644 --- a/tests/baselines/reference/symbolProperty5.symbols +++ b/tests/baselines/reference/symbolProperty5.symbols @@ -3,19 +3,19 @@ var x = { >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3)) [Symbol.iterator]: 0, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) [Symbol.toPrimitive]() { }, ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) get [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) return 0; } diff --git a/tests/baselines/reference/symbolProperty50.symbols b/tests/baselines/reference/symbolProperty50.symbols index 9201435c09e..4beb1f6d9e2 100644 --- a/tests/baselines/reference/symbolProperty50.symbols +++ b/tests/baselines/reference/symbolProperty50.symbols @@ -9,8 +9,8 @@ module M { >C : Symbol(C, Decl(symbolProperty50.ts, 1, 24)) [Symbol.iterator]() { } ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) } } diff --git a/tests/baselines/reference/symbolProperty51.symbols b/tests/baselines/reference/symbolProperty51.symbols index 199c51e65a3..32240efd986 100644 --- a/tests/baselines/reference/symbolProperty51.symbols +++ b/tests/baselines/reference/symbolProperty51.symbols @@ -9,8 +9,8 @@ module M { >C : Symbol(C, Decl(symbolProperty51.ts, 1, 21)) [Symbol.iterator]() { } ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) } } diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols index 95521c7e714..05eeace3b86 100644 --- a/tests/baselines/reference/symbolProperty55.symbols +++ b/tests/baselines/reference/symbolProperty55.symbols @@ -3,9 +3,9 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) }; @@ -14,13 +14,13 @@ module M { var Symbol: SymbolConstructor; >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7)) ->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 1208, 1)) +>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 1209, 1)) // The following should be of type 'any'. This is because even though obj has a property keyed by Symbol.iterator, // the key passed in here is the *wrong* Symbol.iterator. It is not the iterator property of the global Symbol. obj[Symbol.iterator]; >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) } diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols index 97f9966e196..a4e335cc7d7 100644 --- a/tests/baselines/reference/symbolProperty56.symbols +++ b/tests/baselines/reference/symbolProperty56.symbols @@ -3,9 +3,9 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) }; diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols index bc1497aaa14..249545872b1 100644 --- a/tests/baselines/reference/symbolProperty57.symbols +++ b/tests/baselines/reference/symbolProperty57.symbols @@ -3,14 +3,14 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) }; // Should give type 'any'. obj[Symbol["nonsense"]]; >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) diff --git a/tests/baselines/reference/symbolProperty6.symbols b/tests/baselines/reference/symbolProperty6.symbols index 0dbda66432f..78be14d0862 100644 --- a/tests/baselines/reference/symbolProperty6.symbols +++ b/tests/baselines/reference/symbolProperty6.symbols @@ -3,24 +3,24 @@ class C { >C : Symbol(C, Decl(symbolProperty6.ts, 0, 0)) [Symbol.iterator] = 0; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1248, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1249, 31)) [Symbol.unscopables]: number; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) [Symbol.toPrimitive]() { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) get [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1290, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1291, 24)) return 0; } diff --git a/tests/baselines/reference/symbolProperty8.symbols b/tests/baselines/reference/symbolProperty8.symbols index 07f572b03bc..64452f49c9c 100644 --- a/tests/baselines/reference/symbolProperty8.symbols +++ b/tests/baselines/reference/symbolProperty8.symbols @@ -3,12 +3,12 @@ interface I { >I : Symbol(I, Decl(symbolProperty8.ts, 0, 0)) [Symbol.unscopables]: number; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1296, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1297, 24)) [Symbol.toPrimitive](); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1284, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1285, 18)) } diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols index 11be00dba40..d40e0e72724 100644 --- a/tests/baselines/reference/symbolType11.symbols +++ b/tests/baselines/reference/symbolType11.symbols @@ -1,9 +1,9 @@ === tests/cases/conformance/es6/Symbols/symbolType11.ts === var s = Symbol.for("logical"); >s : Symbol(s, Decl(symbolType11.ts, 0, 3)) ->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1220, 42)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11)) ->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1220, 42)) +>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1221, 42)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11)) +>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1221, 42)) s && s; >s : Symbol(s, Decl(symbolType11.ts, 0, 3)) diff --git a/tests/baselines/reference/symbolType16.symbols b/tests/baselines/reference/symbolType16.symbols index 7791f4ee2ba..4b61749b898 100644 --- a/tests/baselines/reference/symbolType16.symbols +++ b/tests/baselines/reference/symbolType16.symbols @@ -1,6 +1,6 @@ === tests/cases/conformance/es6/Symbols/symbolType16.ts === interface Symbol { ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1198, 53), Decl(lib.d.ts, 1304, 11), Decl(symbolType16.ts, 0, 0)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1199, 52), Decl(lib.d.ts, 1305, 11), Decl(symbolType16.ts, 0, 0)) newSymbolProp: number; >newSymbolProp : Symbol(newSymbolProp, Decl(symbolType16.ts, 0, 18)) diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols index 8133afb5273..baa4613d26b 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols +++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts === var x = `abc${ new String("Hi") }def`; >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1555, 1)) +>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1556, 1)) diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols index 47ceb90c04e..f4a310ef0fc 100644 --- a/tests/baselines/reference/typedArrays.symbols +++ b/tests/baselines/reference/typedArrays.symbols @@ -8,39 +8,39 @@ function CreateTypedArrayTypes() { typedArrays[0] = Int8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2116, 42), Decl(lib.d.ts, 2406, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2117, 42), Decl(lib.d.ts, 2407, 11)) typedArrays[1] = Uint8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2406, 44), Decl(lib.d.ts, 2696, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2407, 44), Decl(lib.d.ts, 2697, 11)) typedArrays[2] = Int16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2986, 60), Decl(lib.d.ts, 3276, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2987, 60), Decl(lib.d.ts, 3277, 11)) typedArrays[3] = Uint16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3276, 46), Decl(lib.d.ts, 3566, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3277, 46), Decl(lib.d.ts, 3567, 11)) typedArrays[4] = Int32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3566, 48), Decl(lib.d.ts, 3856, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3567, 48), Decl(lib.d.ts, 3857, 11)) typedArrays[5] = Uint32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3856, 46), Decl(lib.d.ts, 4146, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3857, 46), Decl(lib.d.ts, 4147, 11)) typedArrays[6] = Float32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4146, 48), Decl(lib.d.ts, 4436, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4147, 48), Decl(lib.d.ts, 4437, 11)) typedArrays[7] = Float64Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4436, 50), Decl(lib.d.ts, 4726, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4437, 50), Decl(lib.d.ts, 4727, 11)) typedArrays[8] = Uint8ClampedArray; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2696, 46), Decl(lib.d.ts, 2986, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2697, 46), Decl(lib.d.ts, 2987, 11)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) @@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2116, 42), Decl(lib.d.ts, 2406, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2117, 42), Decl(lib.d.ts, 2407, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2406, 44), Decl(lib.d.ts, 2696, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2407, 44), Decl(lib.d.ts, 2697, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2986, 60), Decl(lib.d.ts, 3276, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2987, 60), Decl(lib.d.ts, 3277, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3276, 46), Decl(lib.d.ts, 3566, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3277, 46), Decl(lib.d.ts, 3567, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3566, 48), Decl(lib.d.ts, 3856, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3567, 48), Decl(lib.d.ts, 3857, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3856, 46), Decl(lib.d.ts, 4146, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3857, 46), Decl(lib.d.ts, 4147, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4146, 48), Decl(lib.d.ts, 4436, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4147, 48), Decl(lib.d.ts, 4437, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4436, 50), Decl(lib.d.ts, 4726, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4437, 50), Decl(lib.d.ts, 4727, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2696, 46), Decl(lib.d.ts, 2986, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2697, 46), Decl(lib.d.ts, 2987, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) return typedArrays; @@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2116, 42), Decl(lib.d.ts, 2406, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2117, 42), Decl(lib.d.ts, 2407, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2406, 44), Decl(lib.d.ts, 2696, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2407, 44), Decl(lib.d.ts, 2697, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2986, 60), Decl(lib.d.ts, 3276, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2987, 60), Decl(lib.d.ts, 3277, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3276, 46), Decl(lib.d.ts, 3566, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3277, 46), Decl(lib.d.ts, 3567, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3566, 48), Decl(lib.d.ts, 3856, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3567, 48), Decl(lib.d.ts, 3857, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3856, 46), Decl(lib.d.ts, 4146, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3857, 46), Decl(lib.d.ts, 4147, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4146, 48), Decl(lib.d.ts, 4436, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4147, 48), Decl(lib.d.ts, 4437, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4436, 50), Decl(lib.d.ts, 4726, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4437, 50), Decl(lib.d.ts, 4727, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2696, 46), Decl(lib.d.ts, 2986, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2697, 46), Decl(lib.d.ts, 2987, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) return typedArrays; @@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2396, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2116, 42), Decl(lib.d.ts, 2406, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2396, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2397, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2117, 42), Decl(lib.d.ts, 2407, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2397, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2686, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2406, 44), Decl(lib.d.ts, 2696, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2686, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2687, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2407, 44), Decl(lib.d.ts, 2697, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2687, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3266, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2986, 60), Decl(lib.d.ts, 3276, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3266, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3267, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2987, 60), Decl(lib.d.ts, 3277, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3267, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3556, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3276, 46), Decl(lib.d.ts, 3566, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3556, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3557, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3277, 46), Decl(lib.d.ts, 3567, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3557, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3846, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3566, 48), Decl(lib.d.ts, 3856, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3846, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3847, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3567, 48), Decl(lib.d.ts, 3857, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3847, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4136, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3856, 46), Decl(lib.d.ts, 4146, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4136, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4137, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3857, 46), Decl(lib.d.ts, 4147, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4137, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4426, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4146, 48), Decl(lib.d.ts, 4436, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4426, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4427, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4147, 48), Decl(lib.d.ts, 4437, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4427, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4716, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4436, 50), Decl(lib.d.ts, 4726, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4716, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4717, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4437, 50), Decl(lib.d.ts, 4727, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4717, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2976, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2696, 46), Decl(lib.d.ts, 2986, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2976, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2977, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2697, 46), Decl(lib.d.ts, 2987, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2977, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) return typedArrays; @@ -235,72 +235,72 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >CreateIntegerTypedArraysFromArrayLike : Symbol(CreateIntegerTypedArraysFromArrayLike, Decl(typedArrays.ts, 59, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1446, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1447, 1)) var typedArrays = []; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2396, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2116, 42), Decl(lib.d.ts, 2406, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2396, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2397, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2117, 42), Decl(lib.d.ts, 2407, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2397, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2686, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2406, 44), Decl(lib.d.ts, 2696, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2686, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2687, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2407, 44), Decl(lib.d.ts, 2697, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2687, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3266, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2986, 60), Decl(lib.d.ts, 3276, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3266, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3267, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2987, 60), Decl(lib.d.ts, 3277, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3267, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3556, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3276, 46), Decl(lib.d.ts, 3566, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3556, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3557, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3277, 46), Decl(lib.d.ts, 3567, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3557, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3846, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3566, 48), Decl(lib.d.ts, 3856, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3846, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3847, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3567, 48), Decl(lib.d.ts, 3857, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3847, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4136, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3856, 46), Decl(lib.d.ts, 4146, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4136, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4137, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3857, 46), Decl(lib.d.ts, 4147, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4137, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4426, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4146, 48), Decl(lib.d.ts, 4436, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4426, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4427, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4147, 48), Decl(lib.d.ts, 4437, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4427, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4716, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4436, 50), Decl(lib.d.ts, 4726, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4716, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4717, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4437, 50), Decl(lib.d.ts, 4727, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4717, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2976, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2696, 46), Decl(lib.d.ts, 2986, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2976, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2977, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2697, 46), Decl(lib.d.ts, 2987, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2977, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) return typedArrays; @@ -332,57 +332,57 @@ function CreateTypedArraysOf2() { typedArrays[0] = Int8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2390, 30)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2116, 42), Decl(lib.d.ts, 2406, 11)) ->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2390, 30)) +>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2391, 30)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2117, 42), Decl(lib.d.ts, 2407, 11)) +>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2391, 30)) typedArrays[1] = Uint8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2680, 30)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2406, 44), Decl(lib.d.ts, 2696, 11)) ->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2680, 30)) +>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2681, 30)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2407, 44), Decl(lib.d.ts, 2697, 11)) +>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2681, 30)) typedArrays[2] = Int16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3260, 30)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2986, 60), Decl(lib.d.ts, 3276, 11)) ->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3260, 30)) +>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3261, 30)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2987, 60), Decl(lib.d.ts, 3277, 11)) +>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3261, 30)) typedArrays[3] = Uint16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3550, 30)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3276, 46), Decl(lib.d.ts, 3566, 11)) ->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3550, 30)) +>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3551, 30)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3277, 46), Decl(lib.d.ts, 3567, 11)) +>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3551, 30)) typedArrays[4] = Int32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3840, 30)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3566, 48), Decl(lib.d.ts, 3856, 11)) ->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3840, 30)) +>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3841, 30)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3567, 48), Decl(lib.d.ts, 3857, 11)) +>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3841, 30)) typedArrays[5] = Uint32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4130, 30)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3856, 46), Decl(lib.d.ts, 4146, 11)) ->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4130, 30)) +>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4131, 30)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3857, 46), Decl(lib.d.ts, 4147, 11)) +>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4131, 30)) typedArrays[6] = Float32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4420, 30)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4146, 48), Decl(lib.d.ts, 4436, 11)) ->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4420, 30)) +>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4421, 30)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4147, 48), Decl(lib.d.ts, 4437, 11)) +>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4421, 30)) typedArrays[7] = Float64Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4710, 30)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4436, 50), Decl(lib.d.ts, 4726, 11)) ->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4710, 30)) +>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4711, 30)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4437, 50), Decl(lib.d.ts, 4727, 11)) +>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4711, 30)) typedArrays[8] = Uint8ClampedArray.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2970, 30)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2696, 46), Decl(lib.d.ts, 2986, 11)) ->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2970, 30)) +>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2971, 30)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2697, 46), Decl(lib.d.ts, 2987, 11)) +>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2971, 30)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) @@ -391,7 +391,7 @@ function CreateTypedArraysOf2() { function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:number)=> number) { >CreateTypedArraysFromMapFn : Symbol(CreateTypedArraysFromMapFn, Decl(typedArrays.ts, 106, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1446, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1447, 1)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) >n : Symbol(n, Decl(typedArrays.ts, 108, 67)) >v : Symbol(v, Decl(typedArrays.ts, 108, 76)) @@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n typedArrays[0] = Int8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2396, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2116, 42), Decl(lib.d.ts, 2406, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2396, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2397, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2117, 42), Decl(lib.d.ts, 2407, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2397, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[1] = Uint8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2686, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2406, 44), Decl(lib.d.ts, 2696, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2686, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2687, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2407, 44), Decl(lib.d.ts, 2697, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2687, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[2] = Int16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3266, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2986, 60), Decl(lib.d.ts, 3276, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3266, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3267, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2987, 60), Decl(lib.d.ts, 3277, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3267, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[3] = Uint16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3556, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3276, 46), Decl(lib.d.ts, 3566, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3556, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3557, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3277, 46), Decl(lib.d.ts, 3567, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3557, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[4] = Int32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3846, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3566, 48), Decl(lib.d.ts, 3856, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3846, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3847, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3567, 48), Decl(lib.d.ts, 3857, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3847, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[5] = Uint32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4136, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3856, 46), Decl(lib.d.ts, 4146, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4136, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4137, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3857, 46), Decl(lib.d.ts, 4147, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4137, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[6] = Float32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4426, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4146, 48), Decl(lib.d.ts, 4436, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4426, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4427, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4147, 48), Decl(lib.d.ts, 4437, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4427, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[7] = Float64Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4716, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4436, 50), Decl(lib.d.ts, 4726, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4716, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4717, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4437, 50), Decl(lib.d.ts, 4727, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4717, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2976, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2696, 46), Decl(lib.d.ts, 2986, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2976, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2977, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2697, 46), Decl(lib.d.ts, 2987, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2977, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) @@ -478,7 +478,7 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v:number)=> number, thisArg: {}) { >CreateTypedArraysFromThisObj : Symbol(CreateTypedArraysFromThisObj, Decl(typedArrays.ts, 121, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1446, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1447, 1)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >n : Symbol(n, Decl(typedArrays.ts, 123, 69)) >v : Symbol(v, Decl(typedArrays.ts, 123, 78)) @@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v typedArrays[0] = Int8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2396, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2116, 42), Decl(lib.d.ts, 2406, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2396, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2397, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2117, 42), Decl(lib.d.ts, 2407, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2397, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2686, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2406, 44), Decl(lib.d.ts, 2696, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2686, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2687, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2407, 44), Decl(lib.d.ts, 2697, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2687, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[2] = Int16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3266, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2986, 60), Decl(lib.d.ts, 3276, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3266, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3267, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2987, 60), Decl(lib.d.ts, 3277, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3267, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3556, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3276, 46), Decl(lib.d.ts, 3566, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3556, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3557, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3277, 46), Decl(lib.d.ts, 3567, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3557, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[4] = Int32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3846, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3566, 48), Decl(lib.d.ts, 3856, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3846, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3847, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3567, 48), Decl(lib.d.ts, 3857, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3847, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4136, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3856, 46), Decl(lib.d.ts, 4146, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4136, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4137, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3857, 46), Decl(lib.d.ts, 4147, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4137, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[6] = Float32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4426, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4146, 48), Decl(lib.d.ts, 4436, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4426, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4427, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4147, 48), Decl(lib.d.ts, 4437, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4427, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[7] = Float64Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4716, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4436, 50), Decl(lib.d.ts, 4726, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4716, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4717, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4437, 50), Decl(lib.d.ts, 4727, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4717, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2976, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2696, 46), Decl(lib.d.ts, 2986, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2976, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2977, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2697, 46), Decl(lib.d.ts, 2987, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2977, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) From 54edbaeea72af18b7536f1d4564a7b5164dc6515 Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Mon, 15 Jun 2015 16:28:29 -0700 Subject: [PATCH 093/309] Parse class member with a missing identifier in the presence of a modifier --- src/compiler/parser.ts | 4 +-- ...lassMemberWithMissingIdentifier.errors.txt | 12 ++++++++ .../classMemberWithMissingIdentifier.js | 12 ++++++++ ...assMemberWithMissingIdentifier2.errors.txt | 30 +++++++++++++++++++ .../classMemberWithMissingIdentifier2.js | 13 ++++++++ .../classMemberWithMissingIdentifier.ts | 3 ++ .../classMemberWithMissingIdentifier2.ts | 3 ++ 7 files changed, 75 insertions(+), 2 deletions(-) create mode 100644 tests/baselines/reference/classMemberWithMissingIdentifier.errors.txt create mode 100644 tests/baselines/reference/classMemberWithMissingIdentifier.js create mode 100644 tests/baselines/reference/classMemberWithMissingIdentifier2.errors.txt create mode 100644 tests/baselines/reference/classMemberWithMissingIdentifier2.js create mode 100644 tests/cases/compiler/classMemberWithMissingIdentifier.ts create mode 100644 tests/cases/compiler/classMemberWithMissingIdentifier2.ts diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 07da065c1ae..35ef6393748 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -4207,7 +4207,7 @@ module ts { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { // treat this as a property declaration with a missing name. let name = createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name, /*questionToken*/ undefined); @@ -4729,7 +4729,7 @@ module ts { case SyntaxKind.ImportKeyword: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { + if (decorators || modifiers) { // We reached this point because we encountered an AtToken and assumed a declaration would // follow. For recovery and error reporting purposes, return an incomplete declaration. let node = createMissingNode(SyntaxKind.MissingDeclaration, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected); diff --git a/tests/baselines/reference/classMemberWithMissingIdentifier.errors.txt b/tests/baselines/reference/classMemberWithMissingIdentifier.errors.txt new file mode 100644 index 00000000000..4bbc2d8167d --- /dev/null +++ b/tests/baselines/reference/classMemberWithMissingIdentifier.errors.txt @@ -0,0 +1,12 @@ +tests/cases/compiler/classMemberWithMissingIdentifier.ts(2,11): error TS1146: Declaration expected. +tests/cases/compiler/classMemberWithMissingIdentifier.ts(2,12): error TS1005: '=' expected. + + +==== tests/cases/compiler/classMemberWithMissingIdentifier.ts (2 errors) ==== + class C { + public {}; + +!!! error TS1146: Declaration expected. + ~ +!!! error TS1005: '=' expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/classMemberWithMissingIdentifier.js b/tests/baselines/reference/classMemberWithMissingIdentifier.js new file mode 100644 index 00000000000..cd1825d0da0 --- /dev/null +++ b/tests/baselines/reference/classMemberWithMissingIdentifier.js @@ -0,0 +1,12 @@ +//// [classMemberWithMissingIdentifier.ts] +class C { + public {}; +} + +//// [classMemberWithMissingIdentifier.js] +var C = (function () { + function C() { + this. = {}; + } + return C; +})(); diff --git a/tests/baselines/reference/classMemberWithMissingIdentifier2.errors.txt b/tests/baselines/reference/classMemberWithMissingIdentifier2.errors.txt new file mode 100644 index 00000000000..b21e062e3b0 --- /dev/null +++ b/tests/baselines/reference/classMemberWithMissingIdentifier2.errors.txt @@ -0,0 +1,30 @@ +tests/cases/compiler/classMemberWithMissingIdentifier2.ts(2,11): error TS1146: Declaration expected. +tests/cases/compiler/classMemberWithMissingIdentifier2.ts(2,12): error TS1005: '=' expected. +tests/cases/compiler/classMemberWithMissingIdentifier2.ts(2,14): error TS2304: Cannot find name 'name'. +tests/cases/compiler/classMemberWithMissingIdentifier2.ts(2,18): error TS1005: ']' expected. +tests/cases/compiler/classMemberWithMissingIdentifier2.ts(2,19): error TS2304: Cannot find name 'string'. +tests/cases/compiler/classMemberWithMissingIdentifier2.ts(2,25): error TS1005: ',' expected. +tests/cases/compiler/classMemberWithMissingIdentifier2.ts(2,26): error TS1136: Property assignment expected. +tests/cases/compiler/classMemberWithMissingIdentifier2.ts(2,27): error TS2304: Cannot find name 'VariableDeclaration'. + + +==== tests/cases/compiler/classMemberWithMissingIdentifier2.ts (8 errors) ==== + class C { + public {[name:string]:VariableDeclaration}; + +!!! error TS1146: Declaration expected. + ~ +!!! error TS1005: '=' expected. + ~~~~ +!!! error TS2304: Cannot find name 'name'. + ~ +!!! error TS1005: ']' expected. + ~~~~~~ +!!! error TS2304: Cannot find name 'string'. + ~ +!!! error TS1005: ',' expected. + ~ +!!! error TS1136: Property assignment expected. + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2304: Cannot find name 'VariableDeclaration'. + } \ No newline at end of file diff --git a/tests/baselines/reference/classMemberWithMissingIdentifier2.js b/tests/baselines/reference/classMemberWithMissingIdentifier2.js new file mode 100644 index 00000000000..e8494755b22 --- /dev/null +++ b/tests/baselines/reference/classMemberWithMissingIdentifier2.js @@ -0,0 +1,13 @@ +//// [classMemberWithMissingIdentifier2.ts] +class C { + public {[name:string]:VariableDeclaration}; +} + +//// [classMemberWithMissingIdentifier2.js] +var C = (function () { + function C() { + this. = (_a = {}, _a[name] = string, _a.VariableDeclaration = VariableDeclaration, _a); + var _a; + } + return C; +})(); diff --git a/tests/cases/compiler/classMemberWithMissingIdentifier.ts b/tests/cases/compiler/classMemberWithMissingIdentifier.ts new file mode 100644 index 00000000000..01ba223f4c4 --- /dev/null +++ b/tests/cases/compiler/classMemberWithMissingIdentifier.ts @@ -0,0 +1,3 @@ +class C { + public {}; +} \ No newline at end of file diff --git a/tests/cases/compiler/classMemberWithMissingIdentifier2.ts b/tests/cases/compiler/classMemberWithMissingIdentifier2.ts new file mode 100644 index 00000000000..e1618659797 --- /dev/null +++ b/tests/cases/compiler/classMemberWithMissingIdentifier2.ts @@ -0,0 +1,3 @@ +class C { + public {[name:string]:VariableDeclaration}; +} \ No newline at end of file From 5316d0d0df4ca62b31dc120700e3ad90b9d134ee Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 15 Jun 2015 16:29:34 -0700 Subject: [PATCH 094/309] Abstract keyword: Added parsing and some checks keyword `abstract` is parsed at the head of class declarations and as a modifier for class member functions/variables. The following checks have been implemented: * Objects whose type is an abstract class cannot be instantiated with `new`. * all overloads of a function must match w/r/t having the abstract keyword. * a member/class decl can't use the `abstract` keyword multiple times. * a member can't be both `abstract` and `static`. * a member can't be both `abstract` and `private`. * Accessibility modifiers can't follow `abstract` * Only classes and member functions can be declared abstract. * abstract methods don't need an implementation * abstract methods can only appear in abstract classes. TODO: * forbid abstract methods from having an implementation. * make sure, barring overriding, an inherited method is abstract iff it is abstract in the parent. * If a class has an abstract members, then it must be abstract. (eg: class B does not implement inherited member 'foo()') * prevent overriding a non-abstract method with an abstract method. * update "abstractness" flag when overriding abstract method with non-abstract method. * prevent calling an abstract method via super.() * make all overloads of an abstract method adjacent to eachother. * constructors can't be declared abstract -- give appropriate error. * figure out what to emit to the *.ts file -- probably nothing. * figure out what to emit to the *.d.ts file. * process abstract declarations. --- src/compiler/checker.ts | 58 +++++++++++++++++-- .../diagnosticInformationMap.generated.ts | 6 +- src/compiler/diagnosticMessages.json | 14 ++++- src/compiler/parser.ts | 7 +++ src/compiler/utilities.ts | 10 ++-- src/services/formatting/rules.ts | 4 +- src/services/services.ts | 2 + src/services/utilities.ts | 1 + 8 files changed, 86 insertions(+), 16 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 89d30e93f5d..d3211a8475f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1358,7 +1358,7 @@ module ts { return result; } - function signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string  { + function signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string { let writer = getSingleLineStringWriter(); getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); let result = writer.string(); @@ -7454,7 +7454,7 @@ module ts { var valueDecl = (expressionType.symbol ? expressionType.symbol.valueDeclaration : undefined); if (valueDecl && valueDecl.flags & NodeFlags.Abstract) { - error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declarationNameToString(valueDecl.name)); + error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0_, declarationNameToString(valueDecl.name)); } // TS 1.0 spec: 4.11 @@ -7543,6 +7543,11 @@ module ts { return links.resolvedSignature; } + /** + * Performs typechecking on the given node, which is a call/new expression. + * @param node The call expression to be checked. + * @returns On success, the expression's signature's return type. On failure, any. + */ function checkCallExpression(node: CallExpression): Type { // Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments); @@ -7553,6 +7558,11 @@ module ts { } if (node.kind === SyntaxKind.NewExpression) { let declaration = signature.declaration; + // let newedClass = declaration.parent; + // if(node.expression. & NodeFlags.Abstract) { + // error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declaration.name); + // } + if (declaration && declaration.kind !== SyntaxKind.Constructor && declaration.kind !== SyntaxKind.ConstructSignature && @@ -9123,6 +9133,9 @@ module ts { else if (deviation & (NodeFlags.Private | NodeFlags.Protected)) { error(o.name, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected); } + else if (deviation & NodeFlags.Abstract) { + error(o.name, Diagnostics.Overload_signatures_must_all_match_with_respect_to_modifier_0_, "abstract"); + } }); } } @@ -9139,7 +9152,7 @@ module ts { } } - let flagsToCheck: NodeFlags = NodeFlags.Export | NodeFlags.Ambient | NodeFlags.Private | NodeFlags.Protected; + let flagsToCheck: NodeFlags = NodeFlags.Export | NodeFlags.Ambient | NodeFlags.Private | NodeFlags.Protected | NodeFlags.Abstract; let someNodeFlags: NodeFlags = 0; let allNodeFlags = flagsToCheck; let someHaveQuestionToken = false; @@ -9157,6 +9170,9 @@ module ts { return; } + // Abstract methods can't have an implementation -- in particular, they don't need one. + if (node.flags & NodeFlags.Abstract) { return; } + let seen = false; let subsequentNode = forEachChild(node.parent, c => { if (seen) { @@ -12827,6 +12843,9 @@ module ts { else if (node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } + else if (flags & NodeFlags.Abstract) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract"); + } flags |= modifierToFlag(modifier.kind); break; @@ -12840,17 +12859,23 @@ module ts { else if (node.kind === SyntaxKind.Parameter) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } + else if (flags & NodeFlags.Abstract) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + } flags |= NodeFlags.Static; lastStatic = modifier; break; - - case SyntaxKind.ExportKeyword: + + case SyntaxKind.ExportKeyword: if (flags & NodeFlags.Export) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "export"); } else if (flags & NodeFlags.Ambient) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } + else if (flags & NodeFlags.Abstract) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract"); + } else if (node.parent.kind === SyntaxKind.ClassDeclaration) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } @@ -12874,7 +12899,28 @@ module ts { return grammarErrorOnNode(modifier, Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } flags |= NodeFlags.Ambient; - lastDeclare = modifier + lastDeclare = modifier; + break; + + case SyntaxKind.AbstractKeyword: + if (flags & NodeFlags.Abstract) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "abstract"); + } + if (node.kind !== SyntaxKind.ClassDeclaration) { + if (node.kind !== SyntaxKind.MethodDeclaration) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_can_only_appear_on_a_class_or_member_function_declaration, "abstract"); + } + if (!(node.parent.kind === SyntaxKind.ClassDeclaration && node.parent.flags & NodeFlags.Abstract)) { + return grammarErrorOnNode(modifier, Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class); + } + } + if (flags & NodeFlags.Static) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + } + if (flags & NodeFlags.Private) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract"); + } + flags |= NodeFlags.Abstract; break; } } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 4d638cf0713..47e1b8e2b39 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -186,6 +186,9 @@ module ts { A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: { code: 1228, category: DiagnosticCategory.Error, key: "A type predicate is only allowed in return type position for functions and methods." }, A_type_predicate_cannot_reference_a_rest_parameter: { code: 1229, category: DiagnosticCategory.Error, key: "A type predicate cannot reference a rest parameter." }, A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: { code: 1230, category: DiagnosticCategory.Error, key: "A type predicate cannot reference element '{0}' in a binding pattern." }, + _0_modifier_can_only_appear_on_a_class_or_member_function_declaration: { code: 1231, category: DiagnosticCategory.Error, key: "'{0}' modifier can only appear on a class or member function declaration." }, + _0_modifier_cannot_be_used_with_1_modifier: { code: 1232, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with '{1}' modifier." }, + Abstract_methods_can_only_appear_within_an_abstract_class: { code: 1233, category: DiagnosticCategory.Error, key: "Abstract methods can only appear within an abstract class." }, 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." }, @@ -379,7 +382,8 @@ module ts { Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, No_best_common_type_exists_among_yield_expressions: { code: 2504, category: DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, - Cannot_create_an_instance_of_the_abstract_class_0: { code: 2506, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'" }, + Cannot_create_an_instance_of_the_abstract_class_0_: { code: 2506, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, + Overload_signatures_must_all_match_with_respect_to_modifier_0_: { code: 2507, category: DiagnosticCategory.Error, key: "Overload sigantures must all match with respect to modifier '{0}'."}, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index ae146368fc3..6a7c5ef6581 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -731,8 +731,18 @@ "category": "Error", "code": 1230 }, - - + "'{0}' modifier can only appear on a class or member function declaration.": { + "category": "Error", + "code": 1231 + }, + "'{0}' modifier cannot be used with '{1}' modifier.": { + "category": "Error", + "code": 1232 + }, + "Abstract methods can only appear within an abstract class.": { + "category": "Error", + "code": 1233 + }, "Duplicate identifier '{0}'.": { "category": "Error", "code": 2300 diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 394bb0f401d..f0a5850220b 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1097,6 +1097,11 @@ module ts { } return token !== SyntaxKind.AsteriskToken && token !== SyntaxKind.OpenBraceToken && canFollowModifier(); } + if (token === SyntaxKind.AbstractKeyword) { + nextToken(); + // 'abstract' can precede class declarations and member function declarations. + return token === SyntaxKind.ClassKeyword || token === SyntaxKind.Identifier; + } if (token === SyntaxKind.DefaultKeyword) { return nextTokenIsClassOrFunction(); } @@ -3873,6 +3878,7 @@ module ts { case SyntaxKind.PrivateKeyword: case SyntaxKind.ProtectedKeyword: case SyntaxKind.StaticKeyword: + case SyntaxKind.AbstractKeyword: nextToken(); continue; default: @@ -4031,6 +4037,7 @@ module ts { case SyntaxKind.PrivateKeyword: case SyntaxKind.ProtectedKeyword: case SyntaxKind.PublicKeyword: + case SyntaxKind.AbstractKeyword: case SyntaxKind.StaticKeyword: if (getDeclarationFlags() & flags) { return parseDeclaration(); diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 9cb0cb02a3f..26237803b87 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1332,15 +1332,15 @@ module ts { export function isModifier(token: SyntaxKind): boolean { switch (token) { + case SyntaxKind.AbstractKeyword: + case SyntaxKind.ConstKeyword: + case SyntaxKind.DeclareKeyword: + case SyntaxKind.DefaultKeyword: + case SyntaxKind.ExportKeyword: case SyntaxKind.PublicKeyword: case SyntaxKind.PrivateKeyword: case SyntaxKind.ProtectedKeyword: case SyntaxKind.StaticKeyword: - case SyntaxKind.AbstractKeyword: - case SyntaxKind.ExportKeyword: - case SyntaxKind.DeclareKeyword: - case SyntaxKind.ConstKeyword: - case SyntaxKind.DefaultKeyword: return true; } return false; diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index 9cf6d8ff4bc..cdd6e4358e8 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -318,7 +318,7 @@ module ts.formatting { this.NoSpaceAfterModuleImport = new Rule(RuleDescriptor.create2(Shared.TokenRange.FromTokens([SyntaxKind.ModuleKeyword, SyntaxKind.RequireKeyword]), SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete)); // Add a space around certain TypeScript keywords - this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); + this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.AbstractKeyword, SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); this.SpaceBeforeCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.ExtendsKeyword, SyntaxKind.ImplementsKeyword])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { @@ -344,7 +344,7 @@ module ts.formatting { // decorators this.SpaceBeforeAt = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.AtToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); this.NoSpaceAfterAt = new Rule(RuleDescriptor.create3(SyntaxKind.AtToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete)); - this.SpaceAfterDecorator = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.Identifier, SyntaxKind.ExportKeyword, SyntaxKind.DefaultKeyword, SyntaxKind.ClassKeyword, SyntaxKind.StaticKeyword, SyntaxKind.PublicKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword, SyntaxKind.OpenBracketToken, SyntaxKind.AsteriskToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), RuleAction.Space)); + this.SpaceAfterDecorator = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.AbstractKeyword, SyntaxKind.Identifier, SyntaxKind.ExportKeyword, SyntaxKind.DefaultKeyword, SyntaxKind.ClassKeyword, SyntaxKind.StaticKeyword, SyntaxKind.PublicKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword, SyntaxKind.OpenBracketToken, SyntaxKind.AsteriskToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), RuleAction.Space)); this.NoSpaceBetweenFunctionKeywordAndStar = new Rule(RuleDescriptor.create1(SyntaxKind.FunctionKeyword, SyntaxKind.AsteriskToken), RuleOperation.create2(new RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), RuleAction.Delete)); this.SpaceAfterStarInGeneratorDeclaration = new Rule(RuleDescriptor.create3(SyntaxKind.AsteriskToken, Shared.TokenRange.FromTokens([SyntaxKind.Identifier, SyntaxKind.OpenParenToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), RuleAction.Space)); diff --git a/src/services/services.ts b/src/services/services.ts index 5f030bf320e..c8c0f332001 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1491,6 +1491,7 @@ module ts { export const exportedModifier = "export"; export const ambientModifier = "declare"; export const staticModifier = "static"; + export const abstractModifier = "abstract"; } export class ClassificationTypeNames { @@ -2786,6 +2787,7 @@ module ts { case SyntaxKind.ExportKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.DefaultKeyword: + case SyntaxKind.AbstractKeyword: } } } diff --git a/src/services/utilities.ts b/src/services/utilities.ts index da0a0aa96c1..548822ddee4 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -429,6 +429,7 @@ module ts { if (flags & NodeFlags.Protected) result.push(ScriptElementKindModifier.protectedMemberModifier); if (flags & NodeFlags.Public) result.push(ScriptElementKindModifier.publicMemberModifier); if (flags & NodeFlags.Static) result.push(ScriptElementKindModifier.staticModifier); + if (flags & NodeFlags.Abstract) result.push(ScriptElementKindModifier.abstractModifier); if (flags & NodeFlags.Export) result.push(ScriptElementKindModifier.exportedModifier); if (isInAmbientContext(node)) result.push(ScriptElementKindModifier.ambientModifier); From 19543221555d0d3742603e2aceb81b06cd3ab3f3 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 15 Jun 2015 17:10:53 -0700 Subject: [PATCH 095/309] Fixed some indentation issues --- src/compiler/checker.ts | 57 +++++++++++++++++++---------------------- 1 file changed, 27 insertions(+), 30 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 04e7c636354..272af29d6e2 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1978,7 +1978,7 @@ namespace ts { // If the binding pattern is empty, this variable declaration is not visible return false; } - // Otherwise fall through + // Otherwise fall through case SyntaxKind.ModuleDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: @@ -2172,8 +2172,8 @@ namespace ts { // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature, // or otherwise the type of the string index signature. type = getTypeOfPropertyOfType(parentType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) || - getIndexTypeOfType(parentType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) || + getIndexTypeOfType(parentType, IndexKind.String); if (!type) { error(name, Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(parentType), declarationNameToString(name)); return unknownType; @@ -3610,8 +3610,8 @@ namespace ts { let symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol; let type = symbol === unknownSymbol ? unknownType : symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) : - symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : - getTypeFromNonGenericTypeReference(node, symbol); + symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the // type reference in checkTypeReferenceOrExpressionWithTypeArguments. links.resolvedSymbol = symbol; @@ -5921,20 +5921,20 @@ namespace ts { if (container && container.parent && container.parent.kind === SyntaxKind.ClassDeclaration) { if (container.flags & NodeFlags.Static) { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor; } else { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor || - container.kind === SyntaxKind.PropertyDeclaration || - container.kind === SyntaxKind.PropertySignature || - container.kind === SyntaxKind.Constructor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor || + container.kind === SyntaxKind.PropertyDeclaration || + container.kind === SyntaxKind.PropertySignature || + container.kind === SyntaxKind.Constructor; } } } @@ -7442,11 +7442,12 @@ namespace ts { return resolveErrorCall(node); } + // If the expression is of abstract type, then it cannot be instantiated. var valueDecl = (expressionType.symbol ? expressionType.symbol.valueDeclaration : undefined); if (valueDecl && valueDecl.flags & NodeFlags.Abstract) { error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0_, declarationNameToString(valueDecl.name)); } - + // TS 1.0 spec: 4.11 // If ConstructExpr is of type Any, Args can be any argument // list and the result of the operation is of type Any. @@ -7548,11 +7549,7 @@ namespace ts { } if (node.kind === SyntaxKind.NewExpression) { let declaration = signature.declaration; - // let newedClass = declaration.parent; - // if(node.expression. & NodeFlags.Abstract) { - // error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declaration.name); - // } - + if (declaration && declaration.kind !== SyntaxKind.Constructor && declaration.kind !== SyntaxKind.ConstructSignature && @@ -8061,8 +8058,8 @@ namespace ts { let type = isTypeAny(sourceType) ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || - getIndexTypeOfType(sourceType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || + getIndexTypeOfType(sourceType, IndexKind.String); if (type) { checkDestructuringAssignment((p).initializer || name, type); } @@ -8257,7 +8254,7 @@ namespace ts { if (!checkForDisallowedESSymbolOperand(operator)) { return booleanType; } - // Fall through + // fall-through case SyntaxKind.EqualsEqualsToken: case SyntaxKind.ExclamationEqualsToken: case SyntaxKind.EqualsEqualsEqualsToken: @@ -8285,8 +8282,8 @@ namespace ts { function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean { let offendingSymbolOperand = someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? node.left : - someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : - undefined; + someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : + undefined; if (offendingSymbolOperand) { error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator)); return false; @@ -9476,7 +9473,7 @@ namespace ts { case SyntaxKind.MethodDeclaration: checkParameterTypeAnnotationsAsExpressions(node); - // fall-through + // fall-through case SyntaxKind.SetAccessor: case SyntaxKind.GetAccessor: @@ -11978,8 +11975,8 @@ namespace ts { (node.parent).moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } + // fall-through - // Intentional fall-through case SyntaxKind.NumericLiteral: // index access if (node.parent.kind == SyntaxKind.ElementAccessExpression && (node.parent).argumentExpression === node) { @@ -12145,7 +12142,7 @@ namespace ts { if (links.isNestedRedeclaration === undefined) { let container = getEnclosingBlockScopeContainer(symbol.valueDeclaration); links.isNestedRedeclaration = isStatementWithLocals(container) && - !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); + !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); } return links.isNestedRedeclaration; } From 864a28a586b58ca6e3650fe089c7b6634a3e1a4e Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 16 Jun 2015 10:02:21 -0700 Subject: [PATCH 096/309] forbid abstract methods from having an implementation --- src/compiler/checker.ts | 9 +++++++-- src/compiler/diagnosticInformationMap.generated.ts | 5 +++-- src/compiler/diagnosticMessages.json | 8 ++++++++ 3 files changed, 18 insertions(+), 4 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 272af29d6e2..4ffa0a81d95 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7445,7 +7445,7 @@ namespace ts { // If the expression is of abstract type, then it cannot be instantiated. var valueDecl = (expressionType.symbol ? expressionType.symbol.valueDeclaration : undefined); if (valueDecl && valueDecl.flags & NodeFlags.Abstract) { - error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0_, declarationNameToString(valueDecl.name)); + error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declarationNameToString(valueDecl.name)); } // TS 1.0 spec: 4.11 @@ -9111,7 +9111,7 @@ namespace ts { error(o.name, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected); } else if (deviation & NodeFlags.Abstract) { - error(o.name, Diagnostics.Overload_signatures_must_all_match_with_respect_to_modifier_0_, "abstract"); + error(o.name, Diagnostics.All_overload_signatures_must_match_with_respect_to_modifier_0, "abstract"); } }); } @@ -9229,6 +9229,11 @@ namespace ts { if (!bodyDeclaration) { bodyDeclaration = node; } + + // abstract functions cannot have an implementation + if(currentNodeFlags & NodeFlags.Abstract) { + error(node, Diagnostics.Abstract_member_functions_cannot_have_an_implementation) + } } else { hasOverloads = true; diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 6616556382f..a65eba493ad 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -192,6 +192,7 @@ namespace ts { _0_modifier_can_only_appear_on_a_class_or_member_function_declaration: { code: 1236, category: DiagnosticCategory.Error, key: "'{0}' modifier can only appear on a class or member function declaration." }, _0_modifier_cannot_be_used_with_1_modifier: { code: 1237, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with '{1}' modifier." }, Abstract_methods_can_only_appear_within_an_abstract_class: { code: 1238, category: DiagnosticCategory.Error, key: "Abstract methods can only appear within an abstract class." }, + Abstract_member_functions_cannot_have_an_implementation: { code: 1240, category: DiagnosticCategory.Error, key: "Abstract member functions cannot have an implementation." }, 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." }, @@ -385,8 +386,8 @@ namespace ts { Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, No_best_common_type_exists_among_yield_expressions: { code: 2504, category: DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, - Cannot_create_an_instance_of_the_abstract_class_0_: { code: 2506, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, - Overload_signatures_must_all_match_with_respect_to_modifier_0_: { code: 2507, category: DiagnosticCategory.Error, key: "Overload sigantures must all match with respect to modifier '{0}'."}, + Cannot_create_an_instance_of_the_abstract_class_0: { code: 2506, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'" }, + All_overload_signatures_must_match_with_respect_to_modifier_0: { code: 2507, category: DiagnosticCategory.Error, key: "All overload signatures must match with respect to modifier '{0}'." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 1b55a6dc214..c5291d2900d 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -755,6 +755,10 @@ "category": "Error", "code": 1238 }, + "Abstract member functions cannot have an implementation.": { + "category": "Error", + "code": 1240 + }, "Duplicate identifier '{0}'.": { "category": "Error", "code": 2300 @@ -1531,6 +1535,10 @@ "category": "Error", "code": 2506 }, + "All overload signatures must match with respect to modifier '{0}'.": { + "category": "Error", + "code": 2507 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 From f1c99f3397edcf01300f77e5f2d7b66a89cfb090 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Tue, 16 Jun 2015 13:25:46 -0700 Subject: [PATCH 097/309] Remove generatorParameter and asyncParameter contexts. --- src/compiler/checker.ts | 32 ++++- .../diagnosticInformationMap.generated.ts | 2 + src/compiler/diagnosticMessages.json | 9 +- src/compiler/parser.ts | 134 ++++++------------ src/compiler/types.ts | 14 +- .../FunctionDeclaration10_es6.errors.txt | 20 ++- .../reference/FunctionDeclaration10_es6.js | 4 +- .../FunctionDeclaration6_es6.errors.txt | 4 +- .../FunctionDeclaration7_es6.errors.txt | 4 +- .../asyncArrowFunction6_es6.errors.txt | 9 +- .../reference/asyncArrowFunction6_es6.js | 2 +- .../asyncArrowFunction7_es6.errors.txt | 9 +- .../reference/asyncArrowFunction7_es6.js | 2 +- .../asyncArrowFunction9_es6.errors.txt | 23 +++ .../reference/asyncArrowFunction9_es6.js | 6 +- .../reference/asyncArrowFunction9_es6.symbols | 8 -- .../reference/asyncArrowFunction9_es6.types | 10 -- .../asyncFunctionDeclaration10_es6.errors.txt | 26 ++++ .../asyncFunctionDeclaration10_es6.js | 7 +- .../asyncFunctionDeclaration10_es6.symbols | 8 -- .../asyncFunctionDeclaration10_es6.types | 9 -- .../asyncFunctionDeclaration6_es6.errors.txt | 9 +- .../asyncFunctionDeclaration6_es6.js | 2 +- .../asyncFunctionDeclaration7_es6.errors.txt | 9 +- .../asyncFunctionDeclaration7_es6.js | 2 +- 25 files changed, 186 insertions(+), 178 deletions(-) create mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.errors.txt delete mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.symbols delete mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt delete mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols delete mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.types diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 1ee1e1cd094..c39cb043025 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6083,6 +6083,18 @@ namespace ts { return undefined; } + function isInParameterInitializerBeforeContainingFunction(node: Node) { + while (node.parent && !isFunctionLike(node.parent)) { + if (node.parent.kind === SyntaxKind.Parameter && (node.parent).initializer === node) { + return true; + } + + node = node.parent; + } + + return false; + } + function getContextualReturnType(functionDecl: FunctionLikeDeclaration): Type { // If the containing function has a return type annotation, is a constructor, or is a get accessor whose // corresponding set accessor has a type annotation, return statements in the function are contextually typed @@ -8031,8 +8043,14 @@ namespace ts { function checkAwaitExpression(node: AwaitExpression): Type { // Grammar checking - if (!(node.parserContextFlags & ParserContextFlags.Await)) { - grammarErrorOnFirstToken(node, Diagnostics.await_expression_is_only_allowed_within_an_async_function); + if (produceDiagnostics) { + if (!(node.parserContextFlags & ParserContextFlags.Await)) { + grammarErrorOnFirstToken(node, Diagnostics.await_expression_is_only_allowed_within_an_async_function); + } + + if (isInParameterInitializerBeforeContainingFunction(node)) { + error(node, Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer); + } } let operandType = checkExpression(node.expression); @@ -8465,8 +8483,14 @@ namespace ts { function checkYieldExpression(node: YieldExpression): Type { // Grammar checking - if (!(node.parserContextFlags & ParserContextFlags.Yield) || isYieldExpressionInClass(node)) { - grammarErrorOnFirstToken(node, Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body); + if (produceDiagnostics) { + if (!(node.parserContextFlags & ParserContextFlags.Yield) || isYieldExpressionInClass(node)) { + grammarErrorOnFirstToken(node, Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body); + } + + if (isInParameterInitializerBeforeContainingFunction(node)) { + error(node, Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer); + } } if (node.expression) { diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 6118e62a1a7..08efa93781c 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -398,6 +398,8 @@ namespace ts { Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." }, Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." }, The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression." }, + yield_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2523, category: DiagnosticCategory.Error, key: "'yield' expressions cannot be used in a parameter initializer." }, + await_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2524, category: DiagnosticCategory.Error, key: "'await' expressions cannot be used in a parameter initializer." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 7e256bbe8ce..05f2690ae43 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1570,7 +1570,6 @@ "category": "Error", "code": 2505 }, - "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions.": { "category": "Error", "code": 2520 @@ -1583,6 +1582,14 @@ "category": "Error", "code": 2522 }, + "'yield' expressions cannot be used in a parameter initializer.": { + "category": "Error", + "code": 2523 + }, + "'await' expressions cannot be used in a parameter initializer.": { + "category": "Error", + "code": 2524 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 6059aec65ae..2bff3ee72de 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -661,10 +661,6 @@ namespace ts { setContextFlag(val, ParserContextFlags.Yield); } - function setGeneratorParameterContext(val: boolean) { - setContextFlag(val, ParserContextFlags.GeneratorParameter); - } - function setDecoratorContext(val: boolean) { setContextFlag(val, ParserContextFlags.Decorator); } @@ -672,11 +668,7 @@ namespace ts { function setAwaitContext(val: boolean) { setContextFlag(val, ParserContextFlags.Await); } - - function setAsyncParameterContext(val: boolean) { - setContextFlag(val, ParserContextFlags.AsyncParameter); - } - + function doOutsideOfContext(context: ParserContextFlags, func: () => T): T { // contextFlagsToClear will contain only the context flags that are // currently set that we need to temporarily clear @@ -767,10 +759,6 @@ namespace ts { return inContext(ParserContextFlags.StrictMode); } - function inGeneratorParameterContext() { - return inContext(ParserContextFlags.GeneratorParameter); - } - function inDisallowInContext() { return inContext(ParserContextFlags.DisallowIn); } @@ -782,15 +770,7 @@ namespace ts { function inAwaitContext() { return inContext(ParserContextFlags.Await); } - - function inAsyncParameterContext() { - return inContext(ParserContextFlags.AsyncParameter); - } - function inGeneratorParameterOrAsyncParameterContext() { - return inContext(ParserContextFlags.GeneratorParameter | ParserContextFlags.AsyncParameter); - } - function parseErrorAtCurrentToken(message: DiagnosticMessage, arg0?: any): void { let start = scanner.getTokenPos(); let length = scanner.getTextPos() - start; @@ -1083,24 +1063,16 @@ namespace ts { } function parseComputedPropertyName(): ComputedPropertyName { - // PropertyName[Yield,GeneratorParameter] : - // LiteralPropertyName - // [+GeneratorParameter] ComputedPropertyName - // [+AsyncParameter] ComputedPropertyName - // [~GeneratorParameter,~AsyncParameter] ComputedPropertyName[?Yield,?Await] - // - // ComputedPropertyName[Yield] : - // [ AssignmentExpression[In, ?Yield] ] - // + // PropertyName [Yield]: + // LiteralPropertyName + // ComputedPropertyName[?Yield] let node = createNode(SyntaxKind.ComputedPropertyName); parseExpected(SyntaxKind.OpenBracketToken); // We parse any expression (including a comma expression). But the grammar // says that only an assignment expression is allowed, so the grammar checker // will error if it sees a comma expression. - node.expression = inGeneratorParameterOrAsyncParameterContext() - ? doOutsideOfYieldAndAwaitContext(allowInAndParseExpression) - : allowInAnd(parseExpression); + node.expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseBracketToken); return finishNode(node); @@ -1991,8 +1963,8 @@ namespace ts { node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); setModifiers(node, parseModifiers()); - // FormalParameter[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 14.1 - // BindingElement[?Yield,?GeneratorParameter,?Await,?AsyncParameter] + // FormalParameter [Yield,Await]: + // BindingElement[?Yield,?Await] node.name = parseIdentifierOrPattern(); @@ -2024,18 +1996,7 @@ namespace ts { } function parseBindingElementInitializer(inParameter: boolean) { - // BindingElement[Yield,GeneratorParameter,Await,AsyncParameter] : - // [+GeneratorParameter] BindingPattern[?Yield,?Await,?AsyncParameter,GeneratorParameter] Initializer[In]opt - // [+AsyncParameter] BindingPattern[?Yield,?GeneratorParameter,?Await,AsyncParameter] Initializer[In]opt - // [~GeneratorParameter,~AsyncParameter] BindingPattern[?Yield,?Await] Initializer[In,?Yield,?Await]opt - // SingleNameBinding[Yield,GeneratorParameter,Await,AsyncParameter] : - // [+GeneratorParameter] BindingIdentifier[Yield, ?Await] Initializer[In]opt - // [+AsyncParameter] BindingIdentifier[Await, ?Yield] Initializer[In]opt - // [~GeneratorParameter,~AsyncParameter] BindingIdentifier[?Yield,?Await] Initializer[In,?Yield,?Await]opt - let parseInitializer = inParameter ? parseParameterInitializer : parseNonParameterInitializer; - return inGeneratorParameterOrAsyncParameterContext() - ? doOutsideOfYieldAndAwaitContext(parseInitializer) - : parseInitializer(); + return inParameter ? parseParameterInitializer() : parseNonParameterInitializer(); } function parseParameterInitializer() { @@ -2043,14 +2004,15 @@ namespace ts { } function fillSignature( - returnToken: SyntaxKind, - yieldAndGeneratorParameterContext: boolean, - awaitAndAsyncParameterContext: boolean, - requireCompleteParameterList: boolean, - signature: SignatureDeclaration): void { + returnToken: SyntaxKind, + yieldContext: boolean, + awaitContext: boolean, + requireCompleteParameterList: boolean, + signature: SignatureDeclaration): void { + let returnTokenRequired = returnToken === SyntaxKind.EqualsGreaterThanToken; signature.typeParameters = parseTypeParameters(); - signature.parameters = parseParameterList(yieldAndGeneratorParameterContext, awaitAndAsyncParameterContext, requireCompleteParameterList); + signature.parameters = parseParameterList(yieldContext, awaitContext, requireCompleteParameterList); if (returnTokenRequired) { parseExpected(returnToken); @@ -2061,44 +2023,31 @@ namespace ts { } } - // Note: after careful analysis of the grammar, it does not appear to be possible to - // have 'Yield' And 'GeneratorParameter' not in sync. i.e. any production calling - // this FormalParameters production either always sets both to true, or always sets - // both to false. As such we only have a single parameter to represent both. - function parseParameterList(yieldAndGeneratorParameterContext: boolean, awaitAndAsyncParameterContext: boolean, requireCompleteParameterList: boolean) { - // FormalParameters[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) - // ... + function parseParameterList(yieldContext: boolean, awaitContext: boolean, requireCompleteParameterList: boolean) { + // FormalParameters [Yield,Await]: (modified) + // [empty] + // FormalParameterList[?Yield,Await] // - // FormalParameter[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) - // BindingElement[?Yield,?GeneratorParameter,?Await,?AsyncParameter] + // FormalParameter[Yield,Await]: (modified) + // BindingElement[?Yield,Await] // - // BindingElement[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 13.2.3 - // SingleNameBinding[?Yield,?GeneratorParameter,?Await,?AsyncParameter] - // [+GeneratorParameter]BindingPattern[?Yield,?Await,?AsyncParameter,GeneratorParameter] Initializer[In]opt - // [+AsyncParameter]BindingPattern[?Yield,?Await,?GeneratorParameter,AsyncParameter] Initializer[In]opt - // [~GeneratorParameter,~AsyncParameter]BindingPattern[?Yield,?Await]Initializer[In,?Yield,?Await]opt + // BindingElement [Yield,Await]: (modified) + // SingleNameBinding[?Yield,?Await] + // BindingPattern[?Yield,?Await]Initializer [In, ?Yield,?Await] opt // - // SingleNameBinding[Yield,GeneratorParameter,Await,AsyncParameter] : (Modified) See 13.2.3 - // [+GeneratorParameter]BindingIdentifier[Yield]Initializer[In]opt - // [+AsyncParameter]BindingIdentifier[Await]Initializer[In]opt - // [~GeneratorParameter,~AsyncParameter]BindingIdentifier[?Yield,?Await]Initializer[In,?Yield,?Await]opt + // SingleNameBinding [Yield,Await]: + // BindingIdentifier[?Yield,?Await]Initializer [In, ?Yield,?Await] opt if (parseExpected(SyntaxKind.OpenParenToken)) { let savedYieldContext = inYieldContext(); - let savedGeneratorParameterContext = inGeneratorParameterContext(); let savedAwaitContext = inAwaitContext(); - let savedAsyncParameterContext = inAsyncParameterContext(); - setYieldContext(yieldAndGeneratorParameterContext); - setGeneratorParameterContext(yieldAndGeneratorParameterContext); - setAwaitContext(awaitAndAsyncParameterContext); - setAsyncParameterContext(awaitAndAsyncParameterContext); + setYieldContext(yieldContext); + setAwaitContext(awaitContext); let result = parseDelimitedList(ParsingContext.Parameters, parseParameter); setYieldContext(savedYieldContext); - setGeneratorParameterContext(savedGeneratorParameterContext); setAwaitContext(savedAwaitContext); - setAsyncParameterContext(savedAsyncParameterContext); if (!parseExpected(SyntaxKind.CloseParenToken) && requireCompleteParameterList) { // Caller insisted that we had to end with a ) We didn't. So just return @@ -2131,7 +2080,7 @@ namespace ts { if (kind === SyntaxKind.ConstructSignature) { parseExpected(SyntaxKind.NewKeyword); } - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList*/ false, node); + fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node); parseTypeMemberSemicolon(); return finishNode(node); } @@ -2220,8 +2169,8 @@ namespace ts { method.questionToken = questionToken; // Method signatues don't exist in expression contexts. So they have neither - // [Yield] nor [GeneratorParameter] - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList*/ false, method); + // [Yield] nor [Await] + fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, method); parseTypeMemberSemicolon(); return finishNode(method); } @@ -2360,7 +2309,7 @@ namespace ts { if (kind === SyntaxKind.ConstructorType) { parseExpected(SyntaxKind.NewKeyword); } - fillSignature(SyntaxKind.EqualsGreaterThanToken, /*yieldAndGeneratorParameterContext*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList*/ false, node); + fillSignature(SyntaxKind.EqualsGreaterThanToken, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node); return finishNode(node); } @@ -2912,7 +2861,7 @@ namespace ts { // a => (b => c) // And think that "(b =>" was actually a parenthesized arrow function with a missing // close paren. - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList*/ !allowAmbiguity, node); + fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ false, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ !allowAmbiguity, node); // If we couldn't get parameters, we definitely could not parse out an arrow function. if (!node.parameters) { @@ -3566,11 +3515,12 @@ namespace ts { return finishNode(node); } - // GeneratorExpression : function parseFunctionExpression(): FunctionExpression { - // function * BindingIdentifier[Yield]opt (FormalParameters[Yield, GeneratorParameter]) { GeneratorBody[Yield] } + // GeneratorExpression: + // function* BindingIdentifier [Yield][opt](FormalParameters[Yield]){ GeneratorBody } + // // FunctionExpression: - // function BindingIdentifieropt(FormalParameters) { FunctionBody } + // function BindingIdentifier[opt](FormalParameters){ FunctionBody } let saveDecoratorContext = inDecoratorContext(); if (saveDecoratorContext) { setDecoratorContext(false); @@ -3589,7 +3539,7 @@ namespace ts { isAsync ? doInAwaitContext(parseOptionalIdentifier) : parseOptionalIdentifier(); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList*/ false, node); + fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node); node.body = parseFunctionBlock(/*allowYield*/ isGenerator, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ false); if (saveDecoratorContext) { @@ -4303,7 +4253,7 @@ namespace ts { node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier(); let isGenerator = !!node.asteriskToken; let isAsync = isAsyncFunctionLike(node); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList*/ false, node); + fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node); node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, Diagnostics.or_expected); return finishNode(node); } @@ -4313,7 +4263,7 @@ namespace ts { node.decorators = decorators; setModifiers(node, modifiers); parseExpected(SyntaxKind.ConstructorKeyword); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList*/ false, node); + fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node); node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, /*isAsync*/ false, Diagnostics.or_expected); return finishNode(node); } @@ -4327,7 +4277,7 @@ namespace ts { method.questionToken = questionToken; let isGenerator = !!asteriskToken; let isAsync = isAsyncFunctionLike(method); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ isGenerator, /*awaitAndAsyncParameterContext*/ isAsync, /*requireCompleteParameterList*/ false, method); + fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, method); method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage); return finishNode(method); } @@ -4381,7 +4331,7 @@ namespace ts { node.decorators = decorators; setModifiers(node, modifiers); node.name = parsePropertyName(); - fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*awaitAndAsyncParameterContext*/ false, /*requireCompleteParameterList*/ false, node); + fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node); node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, /*isAsync*/ false); return finishNode(node); } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 9022295ccfb..e1aa071a7d9 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -376,18 +376,12 @@ namespace ts { // If this node was parsed in the 'yield' context created when parsing a generator. Yield = 1 << 2, - // If this node was parsed in the parameters of a generator. - GeneratorParameter = 1 << 3, - // If this node was parsed as part of a decorator Decorator = 1 << 4, // If this node was parsed in the 'await' context created when parsing an async function. Await = 1 << 5, - // If this node was parsed in the parameters of an async function. - AsyncParameter = 1 << 6, - // 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. @@ -398,14 +392,10 @@ namespace ts { JavaScriptFile = 1 << 8, // Context flags set directly by the parser. - ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | Decorator | ThisNodeHasError | Await | AsyncParameter, - - // Context flags passed as part of the modified ES6 grammar. - YieldAndGeneratorParameterFlags = Yield | GeneratorParameter, - AwaitAndAsyncParameterFlags = Await | AsyncParameter, + ParserGeneratedFlags = StrictMode | DisallowIn | Yield | Decorator | ThisNodeHasError | Await, // Exclude these flags when parsing a Type - TypeExcludesFlags = YieldAndGeneratorParameterFlags | AwaitAndAsyncParameterFlags, + TypeExcludesFlags = Yield | Await, // Context flags computed by aggregating child flags upwards. diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt index 35edf48564a..6efd10dce09 100644 --- a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt @@ -1,8 +1,20 @@ -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 6 or higher. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,16): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,26): error TS1005: ',' expected. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS1138: Parameter declaration expected. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS2304: Cannot find name 'yield'. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,34): error TS1005: ';' expected. -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (1 errors) ==== +==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (5 errors) ==== function * foo(a = yield => yield) { - ~ -!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher. + ~~~~~~~~~ +!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. + ~~ +!!! error TS1005: ',' expected. + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2304: Cannot find name 'yield'. + ~ +!!! error TS1005: ';' expected. } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.js b/tests/baselines/reference/FunctionDeclaration10_es6.js index 51694533964..ccff1ac1036 100644 --- a/tests/baselines/reference/FunctionDeclaration10_es6.js +++ b/tests/baselines/reference/FunctionDeclaration10_es6.js @@ -3,6 +3,6 @@ function * foo(a = yield => yield) { } //// [FunctionDeclaration10_es6.js] -function foo(a) { - if (a === void 0) { a = function (yield) { return yield; }; } +yield; +{ } diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt index 9f696e71084..eae7628f046 100644 --- a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2304: Cannot find name 'yield'. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2523: 'yield' expressions cannot be used in a parameter initializer. ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ==== @@ -7,5 +7,5 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,1 ~ !!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher. ~~~~~ -!!! error TS2304: Cannot find name 'yield'. +!!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } \ No newline at end of file diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt index 91fab36ed31..4a9e4bca6d3 100644 --- a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt @@ -1,6 +1,6 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS1220: Generators are only available when targeting ECMAScript 6 or higher. -tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2304: Cannot find name 'yield'. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2523: 'yield' expressions cannot be used in a parameter initializer. ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ==== @@ -12,6 +12,6 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,2 ~ !!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher. ~~~~~ -!!! error TS2304: Cannot find name 'yield'. +!!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt index c5a34f513b0..111e4ff46d0 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt @@ -1,9 +1,12 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,22): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,22): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,27): error TS1109: Expression expected. -==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts (1 errors) ==== +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts (2 errors) ==== var foo = async (a = await): Promise => { ~~~~~ -!!! error TS2304: Cannot find name 'await'. +!!! error TS2524: 'await' expressions cannot be used in a parameter initializer. + ~ +!!! error TS1109: Expression expected. } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js index 48035057fe0..5353903d10e 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.js +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -4,6 +4,6 @@ var foo = async (a = await): Promise => { } //// [asyncArrowFunction6_es6.js] -var foo = (a = await) => __awaiter(function* () { +var foo = (a = yield ) => __awaiter(function* () { }, this, void 0, Promise); diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt index 823d779c601..6376626d0e7 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt @@ -1,12 +1,15 @@ -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,24): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,29): error TS1109: Expression expected. -==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts (1 errors) ==== +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts (2 errors) ==== var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { ~~~~~ -!!! error TS2304: Cannot find name 'await'. +!!! error TS2524: 'await' expressions cannot be used in a parameter initializer. + ~ +!!! error TS1109: Expression expected. } } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js index 6f8cf6141a8..b3c5f536550 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.js +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -9,7 +9,7 @@ var bar = async (): Promise => { //// [asyncArrowFunction7_es6.js] var bar = () => __awaiter(function* () { // 'await' here is an identifier, and not an await expression. - var foo = (a = await) => __awaiter(function* () { + var foo = (a = yield ) => __awaiter(function* () { }, this, void 0, Promise); }, diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt new file mode 100644 index 00000000000..623095e8a5e --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt @@ -0,0 +1,23 @@ +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,11): error TS2304: Cannot find name 'async'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,18): error TS2304: Cannot find name 'a'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,37): error TS1005: ',' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,39): error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,46): error TS1005: '=' expected. +tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,53): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts (6 errors) ==== + var foo = async (a = await => await): Promise => { + ~~~~~ +!!! error TS2304: Cannot find name 'async'. + ~ +!!! error TS2304: Cannot find name 'a'. + ~ +!!! error TS1005: ',' expected. + ~~~~~~~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'. + ~ +!!! error TS1005: '=' expected. + ~~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.js b/tests/baselines/reference/asyncArrowFunction9_es6.js index 42511dd87f5..fb2f9d28a17 100644 --- a/tests/baselines/reference/asyncArrowFunction9_es6.js +++ b/tests/baselines/reference/asyncArrowFunction9_es6.js @@ -3,6 +3,6 @@ var foo = async (a = await => await): Promise => { } //// [asyncArrowFunction9_es6.js] -var foo = (a = await => await) => __awaiter(function* () { -}, -this, void 0, Promise); +var foo = async(a = await => await), Promise = ; +{ +} diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.symbols b/tests/baselines/reference/asyncArrowFunction9_es6.symbols deleted file mode 100644 index 9714b119e72..00000000000 --- a/tests/baselines/reference/asyncArrowFunction9_es6.symbols +++ /dev/null @@ -1,8 +0,0 @@ -=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts === -var foo = async (a = await => await): Promise => { ->foo : Symbol(foo, Decl(asyncArrowFunction9_es6.ts, 0, 3)) ->a : Symbol(a, Decl(asyncArrowFunction9_es6.ts, 0, 17)) ->await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) ->await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) -} diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.types b/tests/baselines/reference/asyncArrowFunction9_es6.types deleted file mode 100644 index 9f6244c4a0e..00000000000 --- a/tests/baselines/reference/asyncArrowFunction9_es6.types +++ /dev/null @@ -1,10 +0,0 @@ -=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts === -var foo = async (a = await => await): Promise => { ->foo : (a?: (await: any) => any) => Promise ->async (a = await => await): Promise => {} : (a?: (await: any) => any) => Promise ->a : (await: any) => any ->await => await : (await: any) => any ->await : any ->await : any ->Promise : Promise -} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt new file mode 100644 index 00000000000..15ceb3e60c7 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt @@ -0,0 +1,26 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,20): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,30): error TS1109: Expression expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS1138: Parameter declaration expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,38): error TS1005: ';' expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,39): error TS1128: Declaration or statement expected. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,53): error TS1109: Expression expected. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts (7 errors) ==== + async function foo(a = await => await): Promise { + ~~~~~~~~~ +!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. + ~~ +!!! error TS1109: Expression expected. + ~~~~~ +!!! error TS1138: Parameter declaration expected. + ~~~~~ +!!! error TS2304: Cannot find name 'await'. + ~ +!!! error TS1005: ';' expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~ +!!! error TS1109: Expression expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js index 7048ca2ffa4..141c0cbab55 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js @@ -3,8 +3,5 @@ async function foo(a = await => await): Promise { } //// [asyncFunctionDeclaration10_es6.js] -function foo(a = await => await) { - return __awaiter(function* () { - }, - this, void 0, Promise); -} +await; +Promise < void > {}; diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols deleted file mode 100644 index 3bf5baec3b1..00000000000 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols +++ /dev/null @@ -1,8 +0,0 @@ -=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts === -async function foo(a = await => await): Promise { ->foo : Symbol(foo, Decl(asyncFunctionDeclaration10_es6.ts, 0, 0)) ->a : Symbol(a, Decl(asyncFunctionDeclaration10_es6.ts, 0, 19)) ->await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) ->await : Symbol(await, Decl(asyncFunctionDeclaration10_es6.ts, 0, 22)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) -} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.types b/tests/baselines/reference/asyncFunctionDeclaration10_es6.types deleted file mode 100644 index 0018b994e00..00000000000 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.types +++ /dev/null @@ -1,9 +0,0 @@ -=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts === -async function foo(a = await => await): Promise { ->foo : (a?: (await: any) => any) => Promise ->a : (await: any) => any ->await => await : (await: any) => any ->await : any ->await : any ->Promise : Promise -} diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt index e89029e7c5f..ee8abb7bdad 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt @@ -1,8 +1,11 @@ -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts(1,24): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts(1,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts(1,29): error TS1109: Expression expected. -==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts (1 errors) ==== +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts (2 errors) ==== async function foo(a = await): Promise { ~~~~~ -!!! error TS2304: Cannot find name 'await'. +!!! error TS2524: 'await' expressions cannot be used in a parameter initializer. + ~ +!!! error TS1109: Expression expected. } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js index a74d55c35ca..3c1b16cea96 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js @@ -3,7 +3,7 @@ async function foo(a = await): Promise { } //// [asyncFunctionDeclaration6_es6.js] -function foo(a = await) { +function foo(a = yield ) { return __awaiter(function* () { }, this, void 0, Promise); diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt index b29fed652d8..91ba4508ba1 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt @@ -1,11 +1,14 @@ -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts(3,26): error TS2304: Cannot find name 'await'. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts(3,26): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts(3,31): error TS1109: Expression expected. -==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts (1 errors) ==== +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts (2 errors) ==== async function bar(): Promise { // 'await' here is an identifier, and not a yield expression. async function foo(a = await): Promise { ~~~~~ -!!! error TS2304: Cannot find name 'await'. +!!! error TS2524: 'await' expressions cannot be used in a parameter initializer. + ~ +!!! error TS1109: Expression expected. } } \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js index fcc2394a1d1..0b2f643e469 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js @@ -9,7 +9,7 @@ async function bar(): Promise { function bar() { return __awaiter(function* () { // 'await' here is an identifier, and not a yield expression. - function foo(a = await) { + function foo(a = yield ) { return __awaiter(function* () { }, this, void 0, Promise); From 2e16680f01ecb9fb5d9fe5bdd73ac57b2a1d0b67 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Tue, 16 Jun 2015 14:00:31 -0700 Subject: [PATCH 098/309] Re-number enum. --- src/compiler/types.ts | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index d6baa492bb6..db2eafe4e53 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -367,25 +367,25 @@ namespace ts { None = 0, // If this node was parsed in a context where 'in-expressions' are not allowed. - DisallowIn = 1 << 1, + DisallowIn = 1 << 0, // If this node was parsed in the 'yield' context created when parsing a generator. - Yield = 1 << 2, + Yield = 1 << 1, // If this node was parsed as part of a decorator - Decorator = 1 << 4, + Decorator = 1 << 2, // If this node was parsed in the 'await' context created when parsing an async function. - Await = 1 << 5, + Await = 1 << 3, // 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. - ThisNodeHasError = 1 << 7, + ThisNodeHasError = 1 << 4, // This node was parsed in a JavaScript file and can be processed differently. For example // its type can be specified usign a JSDoc comment. - JavaScriptFile = 1 << 8, + JavaScriptFile = 1 << 5, // Context flags set directly by the parser. ParserGeneratedFlags = DisallowIn | Yield | Decorator | ThisNodeHasError | Await, @@ -397,13 +397,10 @@ namespace ts { // 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 << 9, - - // Used to know if we've computed whether any children of this node are or contain an 'await' or 'yield' expression. - ThisNodeOrAnySubNodesHasAwaitOrYield = 1 << 10, + ThisNodeOrAnySubNodesHasError = 1 << 6, // Used to know if we've computed data from children and cached it in this node. - HasAggregatedChildData = 1 << 11 + HasAggregatedChildData = 1 << 7 } /* @internal */ From 41e39735e88301c38ca89e98e0cdfaa42d8301e0 Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Tue, 16 Jun 2015 17:06:00 -0700 Subject: [PATCH 099/309] Make resolveName ignore export specifiers without calling getSymbol --- src/compiler/checker.ts | 33 ++++++++++++++----- ...rtSpecifierAndExportedMemberDeclaration.js | 15 +++++++++ ...cifierAndExportedMemberDeclaration.symbols | 27 +++++++++++++++ ...pecifierAndExportedMemberDeclaration.types | 27 +++++++++++++++ ...cifierAndLocalMemberDeclaration.errors.txt | 18 ++++++++++ ...xportSpecifierAndLocalMemberDeclaration.js | 15 +++++++++ ...rtSpecifierReferencingOuterDeclaration1.js | 8 +++++ ...cifierReferencingOuterDeclaration1.symbols | 14 ++++++++ ...pecifierReferencingOuterDeclaration1.types | 14 ++++++++ ...rtSpecifierReferencingOuterDeclaration2.js | 11 +++++++ ...cifierReferencingOuterDeclaration2.symbols | 14 ++++++++ ...pecifierReferencingOuterDeclaration2.types | 14 ++++++++ ...ierReferencingOuterDeclaration3.errors.txt | 13 ++++++++ ...rtSpecifierReferencingOuterDeclaration3.js | 10 ++++++ ...ierReferencingOuterDeclaration4.errors.txt | 13 ++++++++ ...rtSpecifierReferencingOuterDeclaration4.js | 13 ++++++++ ...rtSpecifierAndExportedMemberDeclaration.ts | 12 +++++++ ...xportSpecifierAndLocalMemberDeclaration.ts | 12 +++++++ ...rtSpecifierReferencingOuterDeclaration1.ts | 5 +++ ...rtSpecifierReferencingOuterDeclaration2.ts | 7 ++++ ...rtSpecifierReferencingOuterDeclaration3.ts | 7 ++++ ...rtSpecifierReferencingOuterDeclaration4.ts | 9 +++++ 22 files changed, 303 insertions(+), 8 deletions(-) create mode 100644 tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.js create mode 100644 tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.symbols create mode 100644 tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.types create mode 100644 tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.errors.txt create mode 100644 tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.js create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.js create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.symbols create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.types create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.js create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.symbols create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.types create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.errors.txt create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.js create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.errors.txt create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.js create mode 100644 tests/cases/compiler/exportSpecifierAndExportedMemberDeclaration.ts create mode 100644 tests/cases/compiler/exportSpecifierAndLocalMemberDeclaration.ts create mode 100644 tests/cases/compiler/exportSpecifierReferencingOuterDeclaration1.ts create mode 100644 tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2.ts create mode 100644 tests/cases/compiler/exportSpecifierReferencingOuterDeclaration3.ts create mode 100644 tests/cases/compiler/exportSpecifierReferencingOuterDeclaration4.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8ee39ab18f3..d296ea5fa22 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -344,21 +344,38 @@ module ts { case SyntaxKind.SourceFile: if (!isExternalModule(location)) break; case SyntaxKind.ModuleDeclaration: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & SymbolFlags.ModuleMember)) { - if (result.flags & meaning || !(result.flags & SymbolFlags.Alias && getDeclarationOfAliasSymbol(result).kind === SyntaxKind.ExportSpecifier)) { - break loop; - } - result = undefined; - } - else if (location.kind === SyntaxKind.SourceFile || + let moduleExports = getSymbolOfNode(location).exports; + if (location.kind === SyntaxKind.SourceFile || (location.kind === SyntaxKind.ModuleDeclaration && (location).name.kind === SyntaxKind.StringLiteral)) { - result = getSymbolOfNode(location).exports["default"]; + + // It's an external module. Because of module/namespace merging, a module's exports are in scope, + // yet we never want to treat an export specifier as putting a member in scope. Therefore, + // if the name we find is purely an export specifier, it is not actually considered in scope. + // Two things to note about this: + // 1. We have to check this without calling getSymbol. The problem with calling getSymbol + // on an export specifier is that it might find the export specifier itself, and try to + // resolve it as an alias. This will cause the checker to consider the export specifier + // a circular alias reference when it might not be. + // 2. We check === SymbolFlags.Alias in order to check that the symbol is *purely* + // an alias. If we used &, we'd be throwing out symbols that have non alias aspects, + // which is not the desired behavior. + if (hasProperty(moduleExports, name) && + moduleExports[name].flags === SymbolFlags.Alias && + getDeclarationOfKind(moduleExports[name], SyntaxKind.ExportSpecifier)) { + break; + } + + result = moduleExports["default"]; let localSymbol = getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + + if (result = getSymbol(moduleExports, name, meaning & SymbolFlags.ModuleMember)) { + break loop; + } break; case SyntaxKind.EnumDeclaration: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & SymbolFlags.EnumMember)) { diff --git a/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.js b/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.js new file mode 100644 index 00000000000..3fc40121011 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.js @@ -0,0 +1,15 @@ +//// [exportSpecifierAndExportedMemberDeclaration.ts] +declare module "m2" { + export module X { + interface I { } + } + function Y(); + export { Y as X }; + function Z(): X.I; +} + +declare module "m2" { + function Z2(): X.I; +} + +//// [exportSpecifierAndExportedMemberDeclaration.js] diff --git a/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.symbols b/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.symbols new file mode 100644 index 00000000000..7e2de735c47 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/exportSpecifierAndExportedMemberDeclaration.ts === +declare module "m2" { + export module X { +>X : Symbol(X, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 0, 21), Decl(exportSpecifierAndExportedMemberDeclaration.ts, 5, 12)) + + interface I { } +>I : Symbol(I, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 1, 21)) + } + function Y(); +>Y : Symbol(Y, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 3, 5)) + + export { Y as X }; +>Y : Symbol(X, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 0, 21), Decl(exportSpecifierAndExportedMemberDeclaration.ts, 5, 12)) +>X : Symbol(X, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 0, 21), Decl(exportSpecifierAndExportedMemberDeclaration.ts, 5, 12)) + + function Z(): X.I; +>Z : Symbol(Z, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 5, 22)) +>X : Symbol(X, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 0, 21), Decl(exportSpecifierAndExportedMemberDeclaration.ts, 5, 12)) +>I : Symbol(X.I, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 1, 21)) +} + +declare module "m2" { + function Z2(): X.I; +>Z2 : Symbol(Z2, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 9, 21)) +>X : Symbol(X, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 0, 21), Decl(exportSpecifierAndExportedMemberDeclaration.ts, 5, 12)) +>I : Symbol(X.I, Decl(exportSpecifierAndExportedMemberDeclaration.ts, 1, 21)) +} diff --git a/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.types b/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.types new file mode 100644 index 00000000000..931552819c7 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierAndExportedMemberDeclaration.types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/exportSpecifierAndExportedMemberDeclaration.ts === +declare module "m2" { + export module X { +>X : () => any + + interface I { } +>I : I + } + function Y(); +>Y : () => any + + export { Y as X }; +>Y : () => any +>X : () => any + + function Z(): X.I; +>Z : () => X.I +>X : any +>I : X.I +} + +declare module "m2" { + function Z2(): X.I; +>Z2 : () => X.I +>X : any +>I : X.I +} diff --git a/tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.errors.txt b/tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.errors.txt new file mode 100644 index 00000000000..eb444919f2c --- /dev/null +++ b/tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.errors.txt @@ -0,0 +1,18 @@ +tests/cases/compiler/exportSpecifierAndLocalMemberDeclaration.ts(11,20): error TS2503: Cannot find namespace 'X'. + + +==== tests/cases/compiler/exportSpecifierAndLocalMemberDeclaration.ts (1 errors) ==== + declare module "m2" { + module X { + interface I { } + } + function Y(); + export { Y as X }; + function Z(): X.I; + } + + declare module "m2" { + function Z2(): X.I; + ~ +!!! error TS2503: Cannot find namespace 'X'. + } \ No newline at end of file diff --git a/tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.js b/tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.js new file mode 100644 index 00000000000..d99ff3627ed --- /dev/null +++ b/tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.js @@ -0,0 +1,15 @@ +//// [exportSpecifierAndLocalMemberDeclaration.ts] +declare module "m2" { + module X { + interface I { } + } + function Y(); + export { Y as X }; + function Z(): X.I; +} + +declare module "m2" { + function Z2(): X.I; +} + +//// [exportSpecifierAndLocalMemberDeclaration.js] diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.js b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.js new file mode 100644 index 00000000000..003956e2822 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.js @@ -0,0 +1,8 @@ +//// [exportSpecifierReferencingOuterDeclaration1.ts] +declare module X { export interface bar { } } +declare module "m" { + export { X }; + export function foo(): X.bar; +} + +//// [exportSpecifierReferencingOuterDeclaration1.js] diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.symbols b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.symbols new file mode 100644 index 00000000000..16abde86d32 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration1.ts === +declare module X { export interface bar { } } +>X : Symbol(X, Decl(exportSpecifierReferencingOuterDeclaration1.ts, 0, 0)) +>bar : Symbol(bar, Decl(exportSpecifierReferencingOuterDeclaration1.ts, 0, 18)) + +declare module "m" { + export { X }; +>X : Symbol(X, Decl(exportSpecifierReferencingOuterDeclaration1.ts, 2, 12)) + + export function foo(): X.bar; +>foo : Symbol(foo, Decl(exportSpecifierReferencingOuterDeclaration1.ts, 2, 17)) +>X : Symbol(X, Decl(exportSpecifierReferencingOuterDeclaration1.ts, 0, 0)) +>bar : Symbol(X.bar, Decl(exportSpecifierReferencingOuterDeclaration1.ts, 0, 18)) +} diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.types b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.types new file mode 100644 index 00000000000..be03554a1b0 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration1.ts === +declare module X { export interface bar { } } +>X : any +>bar : bar + +declare module "m" { + export { X }; +>X : any + + export function foo(): X.bar; +>foo : () => X.bar +>X : any +>bar : X.bar +} diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.js b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.js new file mode 100644 index 00000000000..e8e96784083 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.js @@ -0,0 +1,11 @@ +//// [tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2.ts] //// + +//// [exportSpecifierReferencingOuterDeclaration2_A.ts] +declare module X { export interface bar { } } + +//// [exportSpecifierReferencingOuterDeclaration2_B.ts] +export { X }; +export declare function foo(): X.bar; + +//// [exportSpecifierReferencingOuterDeclaration2_A.js] +//// [exportSpecifierReferencingOuterDeclaration2_B.js] diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.symbols b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.symbols new file mode 100644 index 00000000000..9a57645b1cb --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2_A.ts === +declare module X { export interface bar { } } +>X : Symbol(X, Decl(exportSpecifierReferencingOuterDeclaration2_A.ts, 0, 0)) +>bar : Symbol(bar, Decl(exportSpecifierReferencingOuterDeclaration2_A.ts, 0, 18)) + +=== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2_B.ts === +export { X }; +>X : Symbol(X, Decl(exportSpecifierReferencingOuterDeclaration2_B.ts, 0, 8)) + +export declare function foo(): X.bar; +>foo : Symbol(foo, Decl(exportSpecifierReferencingOuterDeclaration2_B.ts, 0, 13)) +>X : Symbol(X, Decl(exportSpecifierReferencingOuterDeclaration2_A.ts, 0, 0)) +>bar : Symbol(X.bar, Decl(exportSpecifierReferencingOuterDeclaration2_A.ts, 0, 18)) + diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.types b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.types new file mode 100644 index 00000000000..fa59948c116 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2_A.ts === +declare module X { export interface bar { } } +>X : any +>bar : bar + +=== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2_B.ts === +export { X }; +>X : any + +export declare function foo(): X.bar; +>foo : () => X.bar +>X : any +>bar : X.bar + diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.errors.txt b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.errors.txt new file mode 100644 index 00000000000..e144c48bea4 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.errors.txt @@ -0,0 +1,13 @@ +tests/cases/compiler/exportSpecifierReferencingOuterDeclaration3.ts(6,30): error TS2305: Module 'X' has no exported member 'bar'. + + +==== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration3.ts (1 errors) ==== + declare module X { export interface bar { } } + declare module "m" { + module X { export interface foo { } } + export { X }; + export function foo(): X.foo; + export function bar(): X.bar; // error + ~~~ +!!! error TS2305: Module 'X' has no exported member 'bar'. + } \ No newline at end of file diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.js b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.js new file mode 100644 index 00000000000..0f6fff977da --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.js @@ -0,0 +1,10 @@ +//// [exportSpecifierReferencingOuterDeclaration3.ts] +declare module X { export interface bar { } } +declare module "m" { + module X { export interface foo { } } + export { X }; + export function foo(): X.foo; + export function bar(): X.bar; // error +} + +//// [exportSpecifierReferencingOuterDeclaration3.js] diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.errors.txt b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.errors.txt new file mode 100644 index 00000000000..6ac67c70d17 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.errors.txt @@ -0,0 +1,13 @@ +tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2_B.ts(4,34): error TS2305: Module 'X' has no exported member 'bar'. + + +==== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2_A.ts (0 errors) ==== + declare module X { export interface bar { } } + +==== tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2_B.ts (1 errors) ==== + declare module X { export interface foo { } } + export { X }; + export declare function foo(): X.foo; + export declare function bar(): X.bar; // error + ~~~ +!!! error TS2305: Module 'X' has no exported member 'bar'. \ No newline at end of file diff --git a/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.js b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.js new file mode 100644 index 00000000000..4edb5f711a6 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/exportSpecifierReferencingOuterDeclaration4.ts] //// + +//// [exportSpecifierReferencingOuterDeclaration2_A.ts] +declare module X { export interface bar { } } + +//// [exportSpecifierReferencingOuterDeclaration2_B.ts] +declare module X { export interface foo { } } +export { X }; +export declare function foo(): X.foo; +export declare function bar(): X.bar; // error + +//// [exportSpecifierReferencingOuterDeclaration2_A.js] +//// [exportSpecifierReferencingOuterDeclaration2_B.js] diff --git a/tests/cases/compiler/exportSpecifierAndExportedMemberDeclaration.ts b/tests/cases/compiler/exportSpecifierAndExportedMemberDeclaration.ts new file mode 100644 index 00000000000..1c20ffb0437 --- /dev/null +++ b/tests/cases/compiler/exportSpecifierAndExportedMemberDeclaration.ts @@ -0,0 +1,12 @@ +declare module "m2" { + export module X { + interface I { } + } + function Y(); + export { Y as X }; + function Z(): X.I; +} + +declare module "m2" { + function Z2(): X.I; +} \ No newline at end of file diff --git a/tests/cases/compiler/exportSpecifierAndLocalMemberDeclaration.ts b/tests/cases/compiler/exportSpecifierAndLocalMemberDeclaration.ts new file mode 100644 index 00000000000..5f942a75a74 --- /dev/null +++ b/tests/cases/compiler/exportSpecifierAndLocalMemberDeclaration.ts @@ -0,0 +1,12 @@ +declare module "m2" { + module X { + interface I { } + } + function Y(); + export { Y as X }; + function Z(): X.I; +} + +declare module "m2" { + function Z2(): X.I; +} \ No newline at end of file diff --git a/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration1.ts b/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration1.ts new file mode 100644 index 00000000000..e3d0a9000ab --- /dev/null +++ b/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration1.ts @@ -0,0 +1,5 @@ +declare module X { export interface bar { } } +declare module "m" { + export { X }; + export function foo(): X.bar; +} \ No newline at end of file diff --git a/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2.ts b/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2.ts new file mode 100644 index 00000000000..683358a0e3b --- /dev/null +++ b/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration2.ts @@ -0,0 +1,7 @@ +// @module: commonjs +// @Filename: exportSpecifierReferencingOuterDeclaration2_A.ts +declare module X { export interface bar { } } + +// @Filename: exportSpecifierReferencingOuterDeclaration2_B.ts +export { X }; +export declare function foo(): X.bar; \ No newline at end of file diff --git a/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration3.ts b/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration3.ts new file mode 100644 index 00000000000..d4ddf3cc4a6 --- /dev/null +++ b/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration3.ts @@ -0,0 +1,7 @@ +declare module X { export interface bar { } } +declare module "m" { + module X { export interface foo { } } + export { X }; + export function foo(): X.foo; + export function bar(): X.bar; // error +} \ No newline at end of file diff --git a/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration4.ts b/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration4.ts new file mode 100644 index 00000000000..5beaf1de126 --- /dev/null +++ b/tests/cases/compiler/exportSpecifierReferencingOuterDeclaration4.ts @@ -0,0 +1,9 @@ +// @module: commonjs +// @Filename: exportSpecifierReferencingOuterDeclaration2_A.ts +declare module X { export interface bar { } } + +// @Filename: exportSpecifierReferencingOuterDeclaration2_B.ts +declare module X { export interface foo { } } +export { X }; +export declare function foo(): X.foo; +export declare function bar(): X.bar; // error \ No newline at end of file From a07f86240d7ca9af9e77bdd45caf3b0ad4396adf Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 17 Jun 2015 15:01:34 -0700 Subject: [PATCH 100/309] forbid calling abstract member foo() via super.foo() --- src/compiler/checker.ts | 14 ++++++++++++-- src/compiler/diagnosticInformationMap.generated.ts | 3 ++- src/compiler/diagnosticMessages.json | 6 +++++- 3 files changed, 19 insertions(+), 4 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 242793c8b6b..fac2ee3b4c5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6714,8 +6714,18 @@ namespace ts { // - In a static member function or static member accessor // where this references the constructor function object of a derived class, // a super property access is permitted and must specify a public static member function of the base class. - if (left.kind === SyntaxKind.SuperKeyword && getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { - error(right, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); + if (left.kind === SyntaxKind.SuperKeyword) { + if (getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { + error(right, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); + } + + // Abstract methods cannot be accessed through super property accesses. Eg: + // class A { abstract foo(); } + // class B extends A { bar() { super.foo();} } + // is illegal. + if (getDeclarationFlagsFromSymbol(prop) & NodeFlags.Abstract) { + error(right, Diagnostics.Abstract_member_function_0_on_type_1_cannot_be_called_via_super_expression, declarationNameToString(right), typeToString(type)); + } } else { checkClassPropertyAccess(node, left, type, prop); diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index ba617d9cf3b..d1cd9b4ba39 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -393,8 +393,9 @@ namespace ts { No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." }, Base_constructor_does_not_return_a_class_or_interface_type: { code: 2509, category: DiagnosticCategory.Error, key: "Base constructor does not return a class or interface type." }, Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, - Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'" }, + Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, All_overload_signatures_must_match_with_respect_to_modifier_0: { code: 2512, category: DiagnosticCategory.Error, key: "All overload signatures must match with respect to modifier '{0}'." }, + Abstract_member_function_0_on_type_1_cannot_be_called_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract member function '{0}' on type '{1}' cannot be called via super expression." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 91d1eafb998..ddfc885dcf6 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1559,7 +1559,7 @@ "category": "Error", "code": 2510 }, - "Cannot create an instance of the abstract class '{0}'": { + "Cannot create an instance of the abstract class '{0}'.": { "category": "Error", "code": 2511 }, @@ -1567,6 +1567,10 @@ "category": "Error", "code": 2512 }, + "Abstract member function '{0}' on type '{1}' cannot be called via super expression.": { + "category": "Error", + "code": 2513 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 From b25d855341b9c9f98071895a99a88aa1403c6558 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 17 Jun 2015 16:05:55 -0700 Subject: [PATCH 101/309] Removed unused getContainingParameter function --- src/compiler/utilities.ts | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 4aed1aaee58..5f062539e1c 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -640,19 +640,6 @@ namespace ts { } } } - - export function getContainingParameter(node: Node): ParameterDeclaration { - while (true) { - node = node.parent; - if (!node || isFunctionLike(node)) { - return undefined; - } - - if (node.kind === SyntaxKind.Parameter) { - return node; - } - } - } export function getThisContainer(node: Node, includeArrowFunctions: boolean): Node { while (true) { From 82eae194f1ea6aa4a7c85fd96d0cf98e898418a8 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 17 Jun 2015 16:10:17 -0700 Subject: [PATCH 102/309] Inlined checks for NodeFlags.Async in parser --- src/compiler/parser.ts | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 72fb6a8b3e5..98c9c56ae8c 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2695,13 +2695,15 @@ namespace ts { // Didn't appear to actually be a parenthesized arrow function. Just bail out. return undefined; } + + let isAsync = !!(arrowFunction.flags & NodeFlags.Async); // If we have an arrow, then try to parse the body. Even if not, try to parse if we // have an opening brace, just in case we're in an error state. var lastToken = token; arrowFunction.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, /*reportAtCurrentPosition*/false, Diagnostics._0_expected, "=>"); arrowFunction.body = (lastToken === SyntaxKind.EqualsGreaterThanToken || lastToken === SyntaxKind.OpenBraceToken) - ? parseArrowFunctionExpressionBody(/*isAsync*/ isAsyncFunctionLike(arrowFunction)) + ? parseArrowFunctionExpressionBody(isAsync) : parseIdentifier(); return finishNode(arrowFunction); @@ -2813,7 +2815,7 @@ namespace ts { function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): ArrowFunction { let node = createNode(SyntaxKind.ArrowFunction); setModifiers(node, parseModifiersForArrowFunction()); - let isAsync = isAsyncFunctionLike(node); + let isAsync = !!(node.flags & NodeFlags.Async); // Arrow functions are never generators. // @@ -3493,7 +3495,7 @@ namespace ts { node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); let isGenerator = !!node.asteriskToken; - let isAsync = isAsyncFunctionLike(node); + let isAsync = !!(node.flags & NodeFlags.Async); node.name = isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) : isGenerator ? doInYieldContext(parseOptionalIdentifier) : @@ -4217,7 +4219,7 @@ namespace ts { node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier(); let isGenerator = !!node.asteriskToken; - let isAsync = isAsyncFunctionLike(node); + let isAsync = !!(node.flags & NodeFlags.Async); fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node); node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, Diagnostics.or_expected); return finishNode(node); @@ -4241,7 +4243,7 @@ namespace ts { method.name = name; method.questionToken = questionToken; let isGenerator = !!asteriskToken; - let isAsync = isAsyncFunctionLike(method); + let isAsync = !!(method.flags & NodeFlags.Async); fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, method); method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage); return finishNode(method); From c74bb842ba266370384d31bc47caf6dee3210161 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 17 Jun 2015 16:11:14 -0700 Subject: [PATCH 103/309] Moved getContainingFunction call in checkIdentifier --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index cdacf47375f..500d0dec344 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5755,8 +5755,8 @@ namespace ts { // will be bound to non-arrow function that contain this arrow function. This results in inconsistent behavior. // To avoid that we will give an error to users if they use arguments objects in arrow function so that they // can explicitly bound arguments objects - let container = getContainingFunction(node); if (symbol === argumentsSymbol) { + let container = getContainingFunction(node); if (container.kind === SyntaxKind.ArrowFunction) { if (languageVersion < ScriptTarget.ES6) { error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); From b00a9579a8645cc96ff5717296a8bcda6d33f2d7 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 17 Jun 2015 16:16:55 -0700 Subject: [PATCH 104/309] Removed unneeded capture for lexical this --- src/compiler/checker.ts | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 500d0dec344..d0af755125c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5855,10 +5855,6 @@ namespace ts { // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES6); } - else if (node.parserContextFlags & ParserContextFlags.Await) { - // if 'this' is part of an async function, we will need to capture 'this' - needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES6); - } switch (container.kind) { case SyntaxKind.ModuleDeclaration: From 02f6622e43b03d269806b641524a60fed6593059 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 17 Jun 2015 16:28:32 -0700 Subject: [PATCH 105/309] Changed createPromiseType to return emptyObjectType --- src/compiler/checker.ts | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d0af755125c..c6d0b8aacbf 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7632,12 +7632,10 @@ namespace ts { if (globalPromiseType !== emptyObjectType) { // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type promisedType = getAwaitedType(promisedType); - if (promisedType !== unknownType) { - return createTypeReference(globalPromiseType, [promisedType]); - } + return createTypeReference(globalPromiseType, [promisedType]); } - return undefined; + return emptyObjectType; } function getReturnTypeFromBody(func: FunctionLikeDeclaration, contextualMapper?: TypeMapper): Type { @@ -7678,7 +7676,7 @@ namespace ts { if (isAsync) { // For an async function, the return type will not be void, but rather a Promise for void. let promiseType = createPromiseType(voidType); - if (!promiseType) { + if (promiseType === emptyObjectType) { error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); return unknownType; } @@ -7688,7 +7686,7 @@ namespace ts { else { return voidType; } - } + } } // When yield/return statements are contextually typed we allow the return type to be a union type. // Otherwise we require the yield/return expressions to have a best common supertype. @@ -7718,7 +7716,7 @@ namespace ts { // Promise/A+ compatible implementation will always assimilate any foreign promise, so the // return type of the body is awaited type of the body, wrapped in a native Promise type. let promiseType = createPromiseType(widenedType); - if (!promiseType) { + if (promiseType === emptyObjectType) { error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); return unknownType; } @@ -9556,7 +9554,7 @@ namespace ts { let promisedType = getPromisedType(type); if (promisedType === undefined) { // The type was not a PromiseLike, so it could not be unwrapped any further. - // As long as the type does not have a known callable "then" property, then it is + // As long as the type does not have a callable "then" property, then it is // safe to return the type; otherwise, an error will have been reported in // the call to checkNonThenableType and we will return unknownType. // @@ -9570,11 +9568,10 @@ namespace ts { // of a runtime problem. If the user wants to return this value from an async // function, they would need to wrap it in some other value. If they want it to // be treated as a promise, they can cast to . - if (checkNonThenableType(type, location, message)) { - break; + if (!checkNonThenableType(type, location, message)) { + type = unknownType; } - type = unknownType; break; } From 7443ecc6a57ab558a5d5affbeecec296f1640777 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 17 Jun 2015 16:30:25 -0700 Subject: [PATCH 106/309] Cleaned up diagnostics --- src/compiler/checker.ts | 9 ++------- src/compiler/diagnosticInformationMap.generated.ts | 1 + src/compiler/diagnosticMessages.json | 4 ++++ 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c6d0b8aacbf..6ede08a32a4 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9604,11 +9604,7 @@ namespace ts { // } // if (location) { - if (!message) { - message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; - } - - error(location, message); + error(location, Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, symbolToString(type.symbol)); } type = unknownType; @@ -9640,8 +9636,7 @@ namespace ts { let globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(); if (globalPromiseConstructorLikeType === emptyObjectType) { // If we couldn't resolve the global PromiseConstructorLike type we cannot verify - // compatibility with __awaiter, so we report an error. - error(node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + // compatibility with __awaiter. return unknownType; } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index e1b563bb3ea..17472e4ce85 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -54,6 +54,7 @@ namespace ts { Return_expression_in_async_function_does_not_have_a_valid_callable_then_member: { code: 1059, category: DiagnosticCategory.Error, key: "Return expression in async function does not have a valid callable 'then' member." }, Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member: { code: 1060, category: DiagnosticCategory.Error, key: "Expression body for async arrow function does not have a valid callable 'then' member." }, Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." }, + _0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: { code: 1062, category: DiagnosticCategory.Error, key: "{0} is referenced directly or indirectly in the fulfillment callback of its own 'then' method." }, An_export_assignment_cannot_be_used_in_a_namespace: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a namespace." }, Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." }, Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: DiagnosticCategory.Error, key: "Unexpected token. A constructor, method, accessor, or property was expected." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 4ccf40e8463..6ddf1709475 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -203,6 +203,10 @@ "category": "Error", "code": 1061 }, + "{0} is referenced directly or indirectly in the fulfillment callback of its own 'then' method.": { + "category": "Error", + "code": 1062 + }, "An export assignment cannot be used in a namespace.": { "category": "Error", "code": 1063 From 0fe60498d789bb9f4ea1ead3becde8c3861b088e Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 17 Jun 2015 17:11:42 -0700 Subject: [PATCH 107/309] Adding SyntaxKind.ClassExpression in a bunch of places --- src/compiler/binder.ts | 6 +-- src/compiler/checker.ts | 89 +++++++++++++-------------------------- src/compiler/utilities.ts | 33 +++++++-------- 3 files changed, 49 insertions(+), 79 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index eaad8593eee..e403ed994e5 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -630,7 +630,7 @@ namespace ts { function getStrictModeIdentifierMessage(node: Node) { // Provide specialized messages to help the user understand why we think they're in // strict mode. - if (getAncestor(node, SyntaxKind.ClassDeclaration) || getAncestor(node, SyntaxKind.ClassExpression)) { + if (getContainingClass(node)) { return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; } @@ -688,7 +688,7 @@ namespace ts { function getStrictModeEvalOrArgumentsMessage(node: Node) { // Provide specialized messages to help the user understand why we think they're in // strict mode. - if (getAncestor(node, SyntaxKind.ClassDeclaration) || getAncestor(node, SyntaxKind.ClassExpression)) { + if (getContainingClass(node)) { return Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; } @@ -1031,7 +1031,7 @@ namespace ts { // containing class. if (node.flags & NodeFlags.AccessibilityModifier && node.parent.kind === SyntaxKind.Constructor && - (node.parent.parent.kind === SyntaxKind.ClassDeclaration || node.parent.parent.kind === SyntaxKind.ClassExpression)) { + isClassLike(node.parent.parent)) { let classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes); diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index efc3e32166e..232a3db419a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -386,8 +386,8 @@ namespace ts { // local variables of the constructor. This effectively means that entities from outer scopes // by the same name as a constructor parameter or local variable are inaccessible // in initializer expressions for instance member variables. - if (location.parent.kind === SyntaxKind.ClassDeclaration && !(location.flags & NodeFlags.Static)) { - let ctor = findConstructorDeclaration(location.parent); + if (isClassLike(location.parent) && !(location.flags & NodeFlags.Static)) { + let ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & SymbolFlags.Value)) { // Remember the property node, it will be used later to report appropriate error @@ -397,6 +397,7 @@ namespace ts { } break; case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: case SyntaxKind.InterfaceDeclaration: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & SymbolFlags.Type)) { if (lastLocation && lastLocation.flags & NodeFlags.Static) { @@ -420,7 +421,7 @@ namespace ts { // case SyntaxKind.ComputedPropertyName: grandparent = location.parent.parent; - if (grandparent.kind === SyntaxKind.ClassDeclaration || grandparent.kind === SyntaxKind.InterfaceDeclaration) { + if (isClassLike(grandparent) || grandparent.kind === SyntaxKind.InterfaceDeclaration) { // A reference to this grandparent's type parameters would be an error if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & SymbolFlags.Type)) { error(errorLocation, Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); @@ -1009,7 +1010,7 @@ namespace ts { return false; } - function findConstructorDeclaration(node: ClassDeclaration): ConstructorDeclaration { + function findConstructorDeclaration(node: ClassLikeDeclaration): ConstructorDeclaration { let members = node.members; for (let member of members) { if (member.kind === SyntaxKind.Constructor && nodeIsPresent((member).body)) { @@ -2562,10 +2563,10 @@ namespace ts { if (!node) { return typeParameters; } - if (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.FunctionDeclaration || - node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.MethodDeclaration || - node.kind === SyntaxKind.ArrowFunction) { - let declarations = (node).typeParameters; + if (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression || + node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression || + node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.ArrowFunction) { + let declarations = (node).typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); } @@ -2575,8 +2576,8 @@ namespace ts { // The outer type parameters are those defined by enclosing generic classes, methods, or functions. function getOuterTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] { - var kind = symbol.flags & SymbolFlags.Class ? SyntaxKind.ClassDeclaration : SyntaxKind.InterfaceDeclaration; - return appendOuterTypeParameters(undefined, getDeclarationOfKind(symbol, kind)); + var declaration = symbol.flags & SymbolFlags.Class ? symbol.valueDeclaration : getDeclarationOfKind(symbol, SyntaxKind.InterfaceDeclaration); + return appendOuterTypeParameters(undefined, declaration); } // The local type parameters are the combined set of type parameters from all declarations of the class, @@ -2584,7 +2585,8 @@ namespace ts { function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol: Symbol): TypeParameter[] { let result: TypeParameter[]; for (let node of symbol.declarations) { - if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.TypeAliasDeclaration) { + if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.ClassDeclaration || + node.kind === SyntaxKind.ClassExpression || node.kind === SyntaxKind.TypeAliasDeclaration) { let declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -5884,9 +5886,9 @@ namespace ts { } function captureLexicalThis(node: Node, container: Node): void { - let classNode = container.parent && container.parent.kind === SyntaxKind.ClassDeclaration ? container.parent : undefined; getNodeLinks(node).flags |= NodeCheckFlags.LexicalThis; if (container.kind === SyntaxKind.PropertyDeclaration || container.kind === SyntaxKind.Constructor) { + let classNode = container.parent; getNodeLinks(classNode).flags |= NodeCheckFlags.CaptureThis; } else { @@ -5939,7 +5941,7 @@ namespace ts { captureLexicalThis(node, container); } - let classNode = container.parent && container.parent.kind === SyntaxKind.ClassDeclaration ? container.parent : undefined; + let classNode = isClassLike(container.parent) ? container.parent : undefined; if (classNode) { let symbol = getSymbolOfNode(classNode); return container.flags & NodeFlags.Static ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); @@ -5958,7 +5960,7 @@ namespace ts { function checkSuperExpression(node: Node): Type { let isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (node.parent).expression === node; - let classDeclaration = getAncestor(node, SyntaxKind.ClassDeclaration); + let classDeclaration = getContainingClass(node); let classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); let baseClassType = classType && getBaseTypes(classType)[0]; @@ -5993,7 +5995,7 @@ namespace ts { } // topmost container must be something that is directly nested in the class declaration - if (container && container.parent && container.parent.kind === SyntaxKind.ClassDeclaration) { + if (container && isClassLike(container.parent)) { if (container.flags & NodeFlags.Static) { canUseSuperExpression = container.kind === SyntaxKind.MethodDeclaration || @@ -6652,7 +6654,7 @@ namespace ts { } // Property is known to be private or protected at this point // Get the declaring and enclosing class instance types - let enclosingClassDeclaration = getAncestor(node, SyntaxKind.ClassDeclaration); + let enclosingClassDeclaration = getContainingClass(node); let enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; let declaringClass = getDeclaredTypeOfSymbol(prop.parent); // Private property is accessible if declaring and enclosing class are the same @@ -7426,7 +7428,7 @@ namespace ts { if (superType !== unknownType) { // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated // with the type arguments specified in the extends clause. - let baseTypeNode = getClassExtendsHeritageClauseElement(getAncestor(node, SyntaxKind.ClassDeclaration)); + let baseTypeNode = getClassExtendsHeritageClauseElement(getContainingClass(node)); let baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); return resolveCall(node, baseConstructors, candidatesOutArray); } @@ -8354,7 +8356,7 @@ namespace ts { if (isFunctionLike(parent) && current === (parent).body) { return false; } - else if (current.kind === SyntaxKind.ClassDeclaration || current.kind === SyntaxKind.ClassExpression) { + else if (isClassLike(current)) { return true; } @@ -9648,7 +9650,7 @@ namespace ts { } // bubble up and find containing type - let enclosingClass = getAncestor(node, SyntaxKind.ClassDeclaration); + let enclosingClass = getContainingClass(node); // if containing type was not found or it is ambient - exit (no codegen) if (!enclosingClass || isInAmbientContext(enclosingClass)) { return; @@ -10456,8 +10458,8 @@ namespace ts { checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, IndexKind.Number); }); - if (type.flags & TypeFlags.Class && type.symbol.valueDeclaration.kind === SyntaxKind.ClassDeclaration) { - let classDeclaration = type.symbol.valueDeclaration; + if (type.flags & TypeFlags.Class && isClassLike(type.symbol.valueDeclaration)) { + let classDeclaration = type.symbol.valueDeclaration; for (let member of classDeclaration.members) { // Only process instance properties with computed names here. // Static properties cannot be in conflict with indexers, @@ -11727,6 +11729,11 @@ namespace ts { case SyntaxKind.EnumDeclaration: copySymbols(getSymbolOfNode(location).exports, meaning & SymbolFlags.EnumMember); break; + case SyntaxKind.ClassExpression: + if ((location).name) { + copySymbol(location.symbol, meaning); + } + // Fall through case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: if (!(memberFlags & NodeFlags.Static)) { @@ -11766,42 +11773,6 @@ namespace ts { } } } - - if (isInsideWithStatementBody(location)) { - // We cannot answer semantic questions within a with block, do not proceed any further - return []; - } - - while (location) { - if (location.locals && !isGlobalSourceFile(location)) { - copySymbols(location.locals, meaning); - } - switch (location.kind) { - case SyntaxKind.SourceFile: - if (!isExternalModule(location)) break; - case SyntaxKind.ModuleDeclaration: - copySymbols(getSymbolOfNode(location).exports, meaning & SymbolFlags.ModuleMember); - break; - case SyntaxKind.EnumDeclaration: - copySymbols(getSymbolOfNode(location).exports, meaning & SymbolFlags.EnumMember); - break; - case SyntaxKind.ClassDeclaration: - case SyntaxKind.InterfaceDeclaration: - if (!(memberFlags & NodeFlags.Static)) { - copySymbols(getSymbolOfNode(location).members, meaning & SymbolFlags.Type); - } - break; - case SyntaxKind.FunctionExpression: - if ((location).name) { - copySymbol(location.symbol, meaning); - } - break; - } - memberFlags = location.flags; - location = location.parent; - } - copySymbols(globals, meaning); - return symbolsToArray(symbols); } function isTypeDeclarationName(name: Node): boolean { @@ -13213,7 +13184,7 @@ namespace ts { } } - if (node.parent.kind === SyntaxKind.ClassDeclaration) { + if (isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -13505,7 +13476,7 @@ namespace ts { } function checkGrammarProperty(node: PropertyDeclaration) { - if (node.parent.kind === SyntaxKind.ClassDeclaration) { + if (isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index e0fc5fc0269..7f9888c73d3 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -542,6 +542,7 @@ namespace ts { case SyntaxKind.ModuleDeclaration: case SyntaxKind.TypeAliasDeclaration: case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: // These are not allowed inside a generator now, but eventually they may be allowed // as local types. Regardless, any yield statements contained within them should be // skipped in this traversal. @@ -579,26 +580,15 @@ namespace ts { return true; } } - return false; } export function isAccessor(node: Node): boolean { - if (node) { - switch (node.kind) { - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - return true; - } - } - - return false; + return node && (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor); } export function isClassLike(node: Node): boolean { - if (node) { - return node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression; - } + return node && (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression); } export function isFunctionLike(node: Node): boolean { @@ -620,7 +610,6 @@ namespace ts { return true; } } - return false; } @@ -641,6 +630,15 @@ namespace ts { } } + export function getContainingClass(node: Node): ClassLikeDeclaration { + while (true) { + node = node.parent; + if (!node || isClassLike(node)) { + return node; + } + } + } + export function getThisContainer(node: Node, includeArrowFunctions: boolean): Node { while (true) { node = node.parent; @@ -653,7 +651,7 @@ namespace ts { // then the computed property is not a 'this' container. // A computed property name in a class needs to be a this container // so that we can error on it. - if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) { + if (isClassLike(node.parent.parent)) { return node; } // If this is a computed property, then the parent should not @@ -708,7 +706,7 @@ namespace ts { // then the computed property is not a 'super' container. // A computed property name in a class needs to be a super container // so that we can error on it. - if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) { + if (isClassLike(node.parent.parent)) { return node; } // If this is a computed property, then the parent should not @@ -1087,6 +1085,7 @@ namespace ts { case SyntaxKind.ArrowFunction: case SyntaxKind.BindingElement: case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: case SyntaxKind.Constructor: case SyntaxKind.EnumDeclaration: case SyntaxKind.EnumMember: @@ -1917,7 +1916,7 @@ namespace ts { export function isExpressionWithTypeArgumentsInClassExtendsClause(node: Node): boolean { return node.kind === SyntaxKind.ExpressionWithTypeArguments && (node.parent).token === SyntaxKind.ExtendsKeyword && - node.parent.parent.kind === SyntaxKind.ClassDeclaration; + isClassLike(node.parent.parent); } // Returns false if this heritage clause element's expression contains something unsupported From 76ec1f0fec17be2937367e6a41af7d78958b0f45 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Wed, 17 Jun 2015 21:28:49 -0700 Subject: [PATCH 108/309] Add a non-generic construct signature to Map, Set, and WeakMap --- src/lib/es6.d.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts index 625a4eca9e1..71df6d77436 100644 --- a/src/lib/es6.d.ts +++ b/src/lib/es6.d.ts @@ -694,6 +694,7 @@ interface Map { } interface MapConstructor { + new (): Map; new (): Map; new (iterable: Iterable<[K, V]>): Map; prototype: Map; @@ -710,6 +711,7 @@ interface WeakMap { } interface WeakMapConstructor { + new (): WeakMap; new (): WeakMap; new (iterable: Iterable<[K, V]>): WeakMap; prototype: WeakMap; @@ -731,6 +733,7 @@ interface Set { } interface SetConstructor { + new (): Set; new (): Set; new (iterable: Iterable): Set; prototype: Set; @@ -746,6 +749,7 @@ interface WeakSet { } interface WeakSetConstructor { + new (): WeakSet; new (): WeakSet; new (iterable: Iterable): WeakSet; prototype: WeakSet; From 7c50c7c45e0d06d1f19bcae97c963365c3e1c608 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Wed, 17 Jun 2015 23:22:23 -0700 Subject: [PATCH 109/309] Accept baselines --- tests/baselines/reference/for-of37.symbols | 2 +- tests/baselines/reference/for-of38.symbols | 2 +- tests/baselines/reference/for-of40.symbols | 2 +- tests/baselines/reference/for-of45.symbols | 2 +- tests/baselines/reference/for-of50.symbols | 2 +- .../reference/iterableArrayPattern30.symbols | 2 +- .../promiseVoidErrorCallback.symbols | 16 +- tests/baselines/reference/typedArrays.symbols | 324 +++++++++--------- 8 files changed, 176 insertions(+), 176 deletions(-) diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols index 739d9be0af0..11de20174a7 100644 --- a/tests/baselines/reference/for-of37.symbols +++ b/tests/baselines/reference/for-of37.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of37.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of37.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1887, 11)) for (var v of map) { >v : Symbol(v, Decl(for-of37.ts, 1, 8)) diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols index 9322fea69e6..20af2cb65fb 100644 --- a/tests/baselines/reference/for-of38.symbols +++ b/tests/baselines/reference/for-of38.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of38.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of38.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1887, 11)) for (var [k, v] of map) { >k : Symbol(k, Decl(for-of38.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols index 72bbf78884e..eb77e578510 100644 --- a/tests/baselines/reference/for-of40.symbols +++ b/tests/baselines/reference/for-of40.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of40.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of40.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1887, 11)) for (var [k = "", v = false] of map) { >k : Symbol(k, Decl(for-of40.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols index e1e7717269f..b9e5bbacbfa 100644 --- a/tests/baselines/reference/for-of45.symbols +++ b/tests/baselines/reference/for-of45.symbols @@ -5,7 +5,7 @@ var k: string, v: boolean; var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of45.ts, 1, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1887, 11)) for ([k = "", v = false] of map) { >k : Symbol(k, Decl(for-of45.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols index 571dd9dc389..f3bd38be1df 100644 --- a/tests/baselines/reference/for-of50.symbols +++ b/tests/baselines/reference/for-of50.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of50.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of50.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1887, 11)) for (const [k, v] of map) { >k : Symbol(k, Decl(for-of50.ts, 1, 12)) diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols index 715dd79c97a..38dacc59cc2 100644 --- a/tests/baselines/reference/iterableArrayPattern30.symbols +++ b/tests/baselines/reference/iterableArrayPattern30.symbols @@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]) >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11)) >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18)) >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21)) ->Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1887, 11)) diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols index 9a6e2ef47ba..d9e329885aa 100644 --- a/tests/baselines/reference/promiseVoidErrorCallback.symbols +++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols @@ -22,13 +22,13 @@ interface T3 { function f1(): Promise { >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4766, 1), Decl(lib.d.ts, 4851, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0)) return Promise.resolve({ __t1: "foo_t1" }); ->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4833, 39), Decl(lib.d.ts, 4840, 54)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 4766, 1), Decl(lib.d.ts, 4851, 11)) ->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4833, 39), Decl(lib.d.ts, 4840, 54)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4770, 1), Decl(lib.d.ts, 4855, 11)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4837, 39), Decl(lib.d.ts, 4844, 54)) >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28)) } @@ -47,12 +47,12 @@ function f2(x: T1): T2 { var x3 = f1() >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3)) ->f1() .then(f2, (e: Error) => { throw e;}) .then : Symbol(Promise.then, Decl(lib.d.ts, 4771, 22), Decl(lib.d.ts, 4778, 158)) ->f1() .then : Symbol(Promise.then, Decl(lib.d.ts, 4771, 22), Decl(lib.d.ts, 4778, 158)) +>f1() .then(f2, (e: Error) => { throw e;}) .then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158)) +>f1() .then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158)) >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) .then(f2, (e: Error) => { ->then : Symbol(Promise.then, Decl(lib.d.ts, 4771, 22), Decl(lib.d.ts, 4778, 158)) +>then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158)) >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1)) >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15)) >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) @@ -62,7 +62,7 @@ var x3 = f1() }) .then((x: T2) => { ->then : Symbol(Promise.then, Decl(lib.d.ts, 4771, 22), Decl(lib.d.ts, 4778, 158)) +>then : Symbol(Promise.then, Decl(lib.d.ts, 4775, 22), Decl(lib.d.ts, 4782, 158)) >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11)) >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1)) diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols index 4ea9d0283a9..a6b8cb52a86 100644 --- a/tests/baselines/reference/typedArrays.symbols +++ b/tests/baselines/reference/typedArrays.symbols @@ -8,39 +8,39 @@ function CreateTypedArrayTypes() { typedArrays[0] = Int8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2108, 42), Decl(lib.d.ts, 2398, 11)) typedArrays[1] = Uint8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2398, 44), Decl(lib.d.ts, 2688, 11)) typedArrays[2] = Int16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2978, 60), Decl(lib.d.ts, 3268, 11)) typedArrays[3] = Uint16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3268, 46), Decl(lib.d.ts, 3558, 11)) typedArrays[4] = Int32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3558, 48), Decl(lib.d.ts, 3848, 11)) typedArrays[5] = Uint32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3848, 46), Decl(lib.d.ts, 4138, 11)) typedArrays[6] = Float32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4138, 48), Decl(lib.d.ts, 4428, 11)) typedArrays[7] = Float64Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4428, 50), Decl(lib.d.ts, 4718, 11)) typedArrays[8] = Uint8ClampedArray; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2688, 46), Decl(lib.d.ts, 2978, 11)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) @@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2108, 42), Decl(lib.d.ts, 2398, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2398, 44), Decl(lib.d.ts, 2688, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2978, 60), Decl(lib.d.ts, 3268, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3268, 46), Decl(lib.d.ts, 3558, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3558, 48), Decl(lib.d.ts, 3848, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3848, 46), Decl(lib.d.ts, 4138, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4138, 48), Decl(lib.d.ts, 4428, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4428, 50), Decl(lib.d.ts, 4718, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2688, 46), Decl(lib.d.ts, 2978, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) return typedArrays; @@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2108, 42), Decl(lib.d.ts, 2398, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2398, 44), Decl(lib.d.ts, 2688, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2978, 60), Decl(lib.d.ts, 3268, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3268, 46), Decl(lib.d.ts, 3558, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3558, 48), Decl(lib.d.ts, 3848, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3848, 46), Decl(lib.d.ts, 4138, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4138, 48), Decl(lib.d.ts, 4428, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4428, 50), Decl(lib.d.ts, 4718, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2688, 46), Decl(lib.d.ts, 2978, 11)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) return typedArrays; @@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2388, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2108, 42), Decl(lib.d.ts, 2398, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2388, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2678, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2398, 44), Decl(lib.d.ts, 2688, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2678, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3258, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2978, 60), Decl(lib.d.ts, 3268, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3258, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3548, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3268, 46), Decl(lib.d.ts, 3558, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3548, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3838, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3558, 48), Decl(lib.d.ts, 3848, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3838, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4128, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3848, 46), Decl(lib.d.ts, 4138, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4128, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4418, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4138, 48), Decl(lib.d.ts, 4428, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4418, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4708, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4428, 50), Decl(lib.d.ts, 4718, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4708, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2968, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2688, 46), Decl(lib.d.ts, 2978, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2968, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) return typedArrays; @@ -242,65 +242,65 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2388, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2108, 42), Decl(lib.d.ts, 2398, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2388, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2678, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2398, 44), Decl(lib.d.ts, 2688, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2678, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3258, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2978, 60), Decl(lib.d.ts, 3268, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3258, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3548, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3268, 46), Decl(lib.d.ts, 3558, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3548, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3838, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3558, 48), Decl(lib.d.ts, 3848, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3838, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4128, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3848, 46), Decl(lib.d.ts, 4138, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4128, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4418, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4138, 48), Decl(lib.d.ts, 4428, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4418, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4708, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4428, 50), Decl(lib.d.ts, 4718, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4708, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2968, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2688, 46), Decl(lib.d.ts, 2978, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2968, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) return typedArrays; @@ -332,57 +332,57 @@ function CreateTypedArraysOf2() { typedArrays[0] = Int8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2378, 30)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11)) ->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2378, 30)) +>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2382, 30)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2108, 42), Decl(lib.d.ts, 2398, 11)) +>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2382, 30)) typedArrays[1] = Uint8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2668, 30)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11)) ->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2668, 30)) +>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2672, 30)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2398, 44), Decl(lib.d.ts, 2688, 11)) +>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2672, 30)) typedArrays[2] = Int16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3248, 30)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11)) ->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3248, 30)) +>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3252, 30)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2978, 60), Decl(lib.d.ts, 3268, 11)) +>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3252, 30)) typedArrays[3] = Uint16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3538, 30)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11)) ->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3538, 30)) +>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3542, 30)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3268, 46), Decl(lib.d.ts, 3558, 11)) +>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3542, 30)) typedArrays[4] = Int32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3828, 30)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11)) ->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3828, 30)) +>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3832, 30)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3558, 48), Decl(lib.d.ts, 3848, 11)) +>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3832, 30)) typedArrays[5] = Uint32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4118, 30)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11)) ->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4118, 30)) +>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4122, 30)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3848, 46), Decl(lib.d.ts, 4138, 11)) +>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4122, 30)) typedArrays[6] = Float32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4408, 30)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11)) ->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4408, 30)) +>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4412, 30)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4138, 48), Decl(lib.d.ts, 4428, 11)) +>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4412, 30)) typedArrays[7] = Float64Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4698, 30)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11)) ->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4698, 30)) +>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4702, 30)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4428, 50), Decl(lib.d.ts, 4718, 11)) +>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4702, 30)) typedArrays[8] = Uint8ClampedArray.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2958, 30)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11)) ->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2958, 30)) +>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2962, 30)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2688, 46), Decl(lib.d.ts, 2978, 11)) +>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2962, 30)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) @@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n typedArrays[0] = Int8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2388, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2108, 42), Decl(lib.d.ts, 2398, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2388, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[1] = Uint8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2678, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2398, 44), Decl(lib.d.ts, 2688, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2678, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[2] = Int16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3258, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2978, 60), Decl(lib.d.ts, 3268, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3258, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[3] = Uint16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3548, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3268, 46), Decl(lib.d.ts, 3558, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3548, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[4] = Int32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3838, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3558, 48), Decl(lib.d.ts, 3848, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3838, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[5] = Uint32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4128, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3848, 46), Decl(lib.d.ts, 4138, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4128, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[6] = Float32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4418, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4138, 48), Decl(lib.d.ts, 4428, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4418, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[7] = Float64Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4708, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4428, 50), Decl(lib.d.ts, 4718, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4708, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2968, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2688, 46), Decl(lib.d.ts, 2978, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2968, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) @@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v typedArrays[0] = Int8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2388, 38)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2108, 42), Decl(lib.d.ts, 2398, 11)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2388, 38)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2678, 39)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2398, 44), Decl(lib.d.ts, 2688, 11)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2678, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[2] = Int16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3258, 39)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2978, 60), Decl(lib.d.ts, 3268, 11)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3258, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3548, 40)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3268, 46), Decl(lib.d.ts, 3558, 11)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3548, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[4] = Int32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3838, 39)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3558, 48), Decl(lib.d.ts, 3848, 11)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3838, 39)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4128, 40)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3848, 46), Decl(lib.d.ts, 4138, 11)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4128, 40)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[6] = Float32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4418, 41)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4138, 48), Decl(lib.d.ts, 4428, 11)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4418, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[7] = Float64Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4708, 41)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4428, 50), Decl(lib.d.ts, 4718, 11)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4708, 41)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2968, 46)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2688, 46), Decl(lib.d.ts, 2978, 11)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2968, 46)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) From 752e0ba00384a8664d7f6cafec588e88c5f30226 Mon Sep 17 00:00:00 2001 From: Tingan Ho Date: Thu, 18 Jun 2015 23:04:05 +0800 Subject: [PATCH 110/309] Fixes type predicate crash bug --- src/compiler/checker.ts | 1 + .../expressions/typeGuards/typeGuardFunctionErrors.ts | 10 ++++++++++ 2 files changed, 11 insertions(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index efc3e32166e..0861cd96a01 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5761,6 +5761,7 @@ namespace ts { let signature = getResolvedSignature(expr); if (signature.typePredicate && + expr.arguments[signature.typePredicate.parameterIndex] && getSymbolAtLocation(expr.arguments[signature.typePredicate.parameterIndex]) === symbol) { if (!assumeTrue) { diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts index e157b2afe36..688099280c5 100644 --- a/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts +++ b/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts @@ -23,6 +23,10 @@ function hasMissingIsKeyword(): x { return true; } +function hasMissingParameter(): x is A { + return true; +} + function hasMissingTypeInTypeGuardType(x): x is { return true; } @@ -132,4 +136,10 @@ function b6([a, b, p1], p2, p3): p1 is A { function b7({a, b, c: {p1}}, p2, p3): p1 is A { return true; +} + +// Should not crash the compiler +var x: A; +if (hasMissingParameter()) { + x.propA; } \ No newline at end of file From 84bb38415f2e0f47c8197ac6491abace54c58742 Mon Sep 17 00:00:00 2001 From: Tingan Ho Date: Thu, 18 Jun 2015 23:23:47 +0800 Subject: [PATCH 111/309] Accepts baselines --- .../typeGuardFunctionErrors.errors.txt | 69 +++++++++++-------- .../reference/typeGuardFunctionErrors.js | 18 +++++ 2 files changed, 59 insertions(+), 28 deletions(-) diff --git a/tests/baselines/reference/typeGuardFunctionErrors.errors.txt b/tests/baselines/reference/typeGuardFunctionErrors.errors.txt index 1542bbe0fee..499a51035f2 100644 --- a/tests/baselines/reference/typeGuardFunctionErrors.errors.txt +++ b/tests/baselines/reference/typeGuardFunctionErrors.errors.txt @@ -1,42 +1,43 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(15,12): error TS2322: Type 'string' is not assignable to type 'boolean'. tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(22,33): error TS2304: Cannot find name 'x'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(26,10): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(27,5): error TS1131: Property or signature expected. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(28,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(30,38): error TS1225: Cannot find parameter 'x'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(34,51): error TS2322: Type 'B' is not assignable to type 'A'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(26,33): error TS1225: Cannot find parameter 'x'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(30,10): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(31,5): error TS1131: Property or signature expected. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(32,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(34,38): error TS1225: Cannot find parameter 'x'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(38,51): error TS2322: Type 'B' is not assignable to type 'A'. Property 'propA' is missing in type 'B'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(38,56): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(42,56): error TS2322: Type 'T[]' is not assignable to type 'string'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(56,7): error TS2339: Property 'propB' does not exist on type 'A'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(61,7): error TS2339: Property 'propB' does not exist on type 'A'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(66,7): error TS2339: Property 'propB' does not exist on type 'A'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(71,46): error TS2345: Argument of type '(p1: any) => boolean' is not assignable to parameter of type '(p1: any) => boolean'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(42,56): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(46,56): error TS2322: Type 'T[]' is not assignable to type 'string'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(60,7): error TS2339: Property 'propB' does not exist on type 'A'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(65,7): error TS2339: Property 'propB' does not exist on type 'A'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(70,7): error TS2339: Property 'propB' does not exist on type 'A'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(75,46): error TS2345: Argument of type '(p1: any) => boolean' is not assignable to parameter of type '(p1: any) => boolean'. Type predicate 'p1 is C' is not assignable to 'p1 is B'. Type 'C' is not assignable to type 'B'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(75,1): error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(79,1): error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'. Signature '(p1: any, p2: any): boolean' must have a type predicate. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(81,1): error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(85,1): error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'. Type predicate 'p2 is A' is not assignable to 'p1 is A'. Parameter 'p2' is not in the same position as parameter 'p1'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(87,1): error TS2322: Type '(p1: any, p2: any, p3: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(92,9): error TS1228: A type predicate is only allowed in return type position for functions and methods. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(93,16): error TS1228: A type predicate is only allowed in return type position for functions and methods. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(94,20): error TS1228: A type predicate is only allowed in return type position for functions and methods. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(100,25): error TS1228: A type predicate is only allowed in return type position for functions and methods. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(101,16): error TS2409: Return type of constructor signature must be assignable to the instance type of the class -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(103,20): error TS1228: A type predicate is only allowed in return type position for functions and methods. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(106,20): error TS1228: A type predicate is only allowed in return type position for functions and methods. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(107,16): error TS2408: Setters cannot return a value. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(112,18): error TS1228: A type predicate is only allowed in return type position for functions and methods. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(116,22): error TS1228: A type predicate is only allowed in return type position for functions and methods. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(120,20): error TS1229: A type predicate cannot reference a rest parameter. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(125,34): error TS1230: A type predicate cannot reference element 'p1' in a binding pattern. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(91,1): error TS2322: Type '(p1: any, p2: any, p3: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(96,9): error TS1228: A type predicate is only allowed in return type position for functions and methods. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(97,16): error TS1228: A type predicate is only allowed in return type position for functions and methods. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(98,20): error TS1228: A type predicate is only allowed in return type position for functions and methods. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(104,25): error TS1228: A type predicate is only allowed in return type position for functions and methods. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(105,16): error TS2409: Return type of constructor signature must be assignable to the instance type of the class +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(107,20): error TS1228: A type predicate is only allowed in return type position for functions and methods. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(110,20): error TS1228: A type predicate is only allowed in return type position for functions and methods. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(111,16): error TS2408: Setters cannot return a value. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(116,18): error TS1228: A type predicate is only allowed in return type position for functions and methods. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(120,22): error TS1228: A type predicate is only allowed in return type position for functions and methods. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(124,20): error TS1229: A type predicate cannot reference a rest parameter. tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(129,34): error TS1230: A type predicate cannot reference element 'p1' in a binding pattern. -tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(133,39): error TS1230: A type predicate cannot reference element 'p1' in a binding pattern. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(133,34): error TS1230: A type predicate cannot reference element 'p1' in a binding pattern. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(137,39): error TS1230: A type predicate cannot reference element 'p1' in a binding pattern. -==== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts (30 errors) ==== +==== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts (31 errors) ==== class A { propA: number; @@ -66,6 +67,12 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(133,39 return true; } + function hasMissingParameter(): x is A { + ~ +!!! error TS1225: Cannot find parameter 'x'. + return true; + } + function hasMissingTypeInTypeGuardType(x): x is { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2391: Function implementation is missing or not immediately following the declaration. @@ -237,4 +244,10 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(133,39 ~~ !!! error TS1230: A type predicate cannot reference element 'p1' in a binding pattern. return true; + } + + // Should not crash the compiler + var x: A; + if (hasMissingParameter()) { + x.propA; } \ No newline at end of file diff --git a/tests/baselines/reference/typeGuardFunctionErrors.js b/tests/baselines/reference/typeGuardFunctionErrors.js index 5b0979ac576..4923f544345 100644 --- a/tests/baselines/reference/typeGuardFunctionErrors.js +++ b/tests/baselines/reference/typeGuardFunctionErrors.js @@ -24,6 +24,10 @@ function hasMissingIsKeyword(): x { return true; } +function hasMissingParameter(): x is A { + return true; +} + function hasMissingTypeInTypeGuardType(x): x is { return true; } @@ -133,6 +137,12 @@ function b6([a, b, p1], p2, p3): p1 is A { function b7({a, b, c: {p1}}, p2, p3): p1 is A { return true; +} + +// Should not crash the compiler +var x: A; +if (hasMissingParameter()) { + x.propA; } //// [typeGuardFunctionErrors.js] @@ -167,6 +177,9 @@ function hasTypeGuardTypeInsideTypeGuardType(x) { function hasMissingIsKeyword() { return true; } +function hasMissingParameter() { + return true; +} return true; function hasNonMatchingParameter(y) { return true; @@ -260,3 +273,8 @@ function b7(_a, p2, p3) { var a = _a.a, b = _a.b, p1 = _a.c.p1; return true; } +// Should not crash the compiler +var x; +if (hasMissingParameter()) { + x.propA; +} From 958a423142dad45c4e9f51e461d383f51cbe8ed5 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 18 Jun 2015 08:56:48 -0700 Subject: [PATCH 112/309] Make classification cancellable. --- src/services/services.ts | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/services/services.ts b/src/services/services.ts index bab5b7707ef..188e711ed9f 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -5986,6 +5986,26 @@ namespace ts { return convertClassifications(getEncodedSemanticClassifications(fileName, span)); } + function checkForClassificationCancellation(kind: SyntaxKind) { + // We don't want to actually call back into our host on every node to find out if we've + // been canceled. That would be an enormous amount of chattyness, along with the all + // the overhead of marshalling the data to/from the host. So instead we pick a few + // reasonable node kinds to bother checking on. These node kinds represent high level + // constructs that we would expect to see commonly, but just at a far less frequent + // interval. + // + // For example, in checker.ts (around 750k) we only have around 600 of these constructs. + // That means we're calling back into the host around every 1.2k of the file we process. + // Lib.d.ts has similar numbers. + switch (kind) { + case SyntaxKind.ModuleDeclaration: + case SyntaxKind.ClassDeclaration: + case SyntaxKind.InterfaceDeclaration: + case SyntaxKind.FunctionDeclaration: + cancellationToken.throwIfCancellationRequested(); + } + } + function getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications { synchronizeHostData(); @@ -6053,7 +6073,10 @@ namespace ts { function processNode(node: Node) { // Only walk into nodes that intersect the requested span. if (node && textSpanIntersectsWith(span, node.getFullStart(), node.getFullWidth())) { - if (node.kind === SyntaxKind.Identifier && !nodeIsMissing(node)) { + let kind = node.kind; + checkForClassificationCancellation(kind); + + if (kind === SyntaxKind.Identifier && !nodeIsMissing(node)) { let identifier = node; // Only bother calling into the typechecker if this is an identifier that @@ -6405,6 +6428,8 @@ namespace ts { // Ignore nodes that don't intersect the original span to classify. if (textSpanIntersectsWith(span, element.getFullStart(), element.getFullWidth())) { + checkForClassificationCancellation(element.kind); + let children = element.getChildren(sourceFile); for (let child of children) { if (isToken(child)) { From a264be5afaa8ac6f27f827303b789618a1dd068f Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 18 Jun 2015 10:25:23 -0700 Subject: [PATCH 113/309] Actually check types in checkClassExpression --- src/compiler/checker.ts | 21 ++++++++------------- src/compiler/utilities.ts | 15 ++++++++++++++- 2 files changed, 22 insertions(+), 14 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 232a3db419a..76bc4e9a94e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1402,15 +1402,8 @@ namespace ts { * for the name of the symbol if it is available to match how the user inputted the name. */ function appendSymbolNameOnly(symbol: Symbol, writer: SymbolWriter): void { - if (symbol.declarations && symbol.declarations.length > 0) { - let declaration = symbol.declarations[0]; - if (declaration.name) { - writer.writeSymbol(declarationNameToString(declaration.name), symbol); - return; - } - } - - writer.writeSymbol(symbol.name, symbol); + let name = symbol.declarations && symbol.declarations.length > 0 ? declarationToString(symbol.declarations[0]) : symbol.name; + writer.writeSymbol(name, symbol); } /** @@ -10565,9 +10558,8 @@ namespace ts { } function checkClassExpression(node: ClassExpression): Type { - grammarErrorOnNode(node, Diagnostics.class_expressions_are_not_currently_supported); - forEach(node.members, checkSourceElement); - return unknownType; + checkClassLikeDeclaration(node); + return getTypeOfSymbol(getSymbolOfNode(node)); } function checkClassDeclaration(node: ClassDeclaration) { @@ -10575,7 +10567,10 @@ namespace ts { if (!node.name && !(node.flags & NodeFlags.Default)) { grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } + checkClassLikeDeclaration(node); + } + function checkClassLikeDeclaration(node: ClassLikeDeclaration) { checkGrammarClassDeclarationHeritageClauses(node); checkDecorators(node); if (node.name) { @@ -12921,7 +12916,7 @@ namespace ts { } } - function checkGrammarClassDeclarationHeritageClauses(node: ClassDeclaration) { + function checkGrammarClassDeclarationHeritageClauses(node: ClassLikeDeclaration) { let seenExtendsClause = false; let seenImplementsClause = false; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 7f9888c73d3..f50f280d861 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -247,6 +247,19 @@ namespace ts { declaration.parent.kind === SyntaxKind.CatchClause; } + export function declarationToString(declaration: Declaration) { + if (!declaration.name) { + switch (declaration.kind) { + case SyntaxKind.ClassExpression: + return "(Anonymous class)"; + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + return "(Anonymous function)"; + } + } + return declarationNameToString(declaration.name); + } + // Return display name of an identifier // Computed property names will just be emitted as "[]", where is the source // text of the expression in the computed property. @@ -1234,7 +1247,7 @@ namespace ts { return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined; } - export function getClassImplementsHeritageClauseElements(node: ClassDeclaration) { + export function getClassImplementsHeritageClauseElements(node: ClassLikeDeclaration) { let heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword); return heritageClause ? heritageClause.types : undefined; } From 2891a1d1b7b032fe92a5c8d45f6b27588e60e070 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 18 Jun 2015 11:31:03 -0700 Subject: [PATCH 114/309] Cleaned up async return type check --- src/compiler/checker.ts | 86 +++++------- .../diagnosticInformationMap.generated.ts | 1 + src/compiler/diagnosticMessages.json | 4 + src/compiler/emitter.ts | 73 +++++----- .../reference/asyncArrowFunction1_es6.js | 5 +- .../reference/asyncArrowFunction6_es6.js | 5 +- .../reference/asyncArrowFunction7_es6.js | 10 +- .../reference/asyncArrowFunction8_es6.js | 5 +- ...asyncArrowFunctionCapturesArguments_es6.js | 3 +- .../asyncArrowFunctionCapturesThis_es6.js | 3 +- tests/baselines/reference/asyncAwait_es6.js | 119 ++++++++++++++++ .../reference/asyncAwait_es6.symbols | 118 ++++++++++++++++ .../baselines/reference/asyncAwait_es6.types | 129 ++++++++++++++++++ .../asyncFunctionDeclaration11_es6.js | 5 +- .../asyncFunctionDeclaration13_es6.js | 5 +- .../asyncFunctionDeclaration14_es6.js | 5 +- .../asyncFunctionDeclaration1_es6.js | 5 +- .../asyncFunctionDeclaration6_es6.js | 5 +- .../asyncFunctionDeclaration7_es6.js | 10 +- .../asyncFunctionDeclaration9_es6.js | 5 +- .../reference/awaitBinaryExpression1_es6.js | 5 +- .../reference/awaitBinaryExpression2_es6.js | 5 +- .../reference/awaitBinaryExpression3_es6.js | 5 +- .../reference/awaitBinaryExpression4_es6.js | 5 +- .../reference/awaitBinaryExpression5_es6.js | 5 +- .../reference/awaitCallExpression1_es6.js | 5 +- .../reference/awaitCallExpression2_es6.js | 5 +- .../reference/awaitCallExpression3_es6.js | 5 +- .../reference/awaitCallExpression4_es6.js | 5 +- .../reference/awaitCallExpression5_es6.js | 5 +- .../reference/awaitCallExpression6_es6.js | 5 +- .../reference/awaitCallExpression7_es6.js | 5 +- .../reference/awaitCallExpression8_es6.js | 5 +- .../conformance/async/es6/asyncAwait_es6.ts | 40 ++++++ 34 files changed, 534 insertions(+), 172 deletions(-) create mode 100644 tests/baselines/reference/asyncAwait_es6.js create mode 100644 tests/baselines/reference/asyncAwait_es6.symbols create mode 100644 tests/baselines/reference/asyncAwait_es6.types create mode 100644 tests/cases/conformance/async/es6/asyncAwait_es6.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6ede08a32a4..70ca1172ccb 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -824,7 +824,7 @@ namespace ts { } // Resolves a qualified name and any involved aliases - function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, location?: Node): Symbol { + function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags): Symbol { if (nodeIsMissing(name)) { return undefined; } @@ -833,7 +833,7 @@ namespace ts { if (name.kind === SyntaxKind.Identifier) { let message = meaning === SymbolFlags.Namespace ? Diagnostics.Cannot_find_namespace_0 : Diagnostics.Cannot_find_name_0; - symbol = resolveName(location || name, (name).text, meaning, message, name); + symbol = resolveName(name, (name).text, meaning, message, name); if (!symbol) { return undefined; } @@ -842,7 +842,7 @@ namespace ts { let left = name.kind === SyntaxKind.QualifiedName ? (name).left : (name).expression; let right = name.kind === SyntaxKind.QualifiedName ? (name).right : (name).name; - let namespace = resolveEntityName(left, SymbolFlags.Namespace, location); + let namespace = resolveEntityName(left, SymbolFlags.Namespace); if (!namespace || namespace === unknownSymbol || nodeIsMissing(right)) { return undefined; } @@ -8839,7 +8839,6 @@ namespace ts { } if (produceDiagnostics) { - checkCollisionWithAwaiterVariablesInGeneratedCode(node, node.name); checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { @@ -9632,7 +9631,7 @@ namespace ts { * a `resolve` function as one of its arguments and results in an object with a * callable `then` signature. */ - function checkAsyncFunctionReturnType(node: SignatureDeclaration): Type { + function checkAsyncFunctionReturnType(node: FunctionLikeDeclaration): Type { let globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(); if (globalPromiseConstructorLikeType === emptyObjectType) { // If we couldn't resolve the global PromiseConstructorLike type we cannot verify @@ -9640,10 +9639,10 @@ namespace ts { return unknownType; } - // The return type of an async function will be the type of the instance. For this - // to be a type compatible with our async function emit, we must also check that - // the type of the declaration (e.g. the static side or "constructor" type of the - // promise) is a compatible `PromiseConstructorLike`. + // As part of our emit for an async function, we will need to emit the entity name of + // the return type annotation as an expression. To meet the necessary runtime semantics + // for __awaiter, we must also check that the type of the declaration (e.g. the static + // side or "constructor" of the promise type) is compatible `PromiseConstructorLike`. // // An example might be (from lib.es6.d.ts): // @@ -9666,36 +9665,33 @@ namespace ts { // // When we get the type of the `Promise` symbol here, we get the type of the static // side of the `Promise` class, which would be `{ new (...): Promise }`. - let returnType = getTypeFromTypeNode(node.type); - let entityName = getEntityNameFromTypeNode(node.type); - let resolvedName = entityName ? resolveEntityName(entityName, SymbolFlags.Value, node) : undefined; - if (!resolvedName || !returnType.symbol) { - error(node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); - return unknownType; - } - - if (getMergedSymbol(resolvedName) !== getMergedSymbol(returnType.symbol)) { - // If we were unable to resolve the return type as a value, report an error. - let identifier = getFirstIdentifier(entityName); - error(resolvedName.valueDeclaration, Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, - identifier.text, - identifier.text); - return unknownType; - } - - // When we emit the async function, we need to ensure we emit any imports that might - // otherwise have been elided if the return type were only ever referenced in a type - // position. As such, we check the entity name as an expression. - let declaredType = checkExpression(entityName); - - if (!isTypeAssignableTo(declaredType, globalPromiseConstructorLikeType)) { - // If the declared type of the return type is not assignable to a PromiseConstructorLike, report an error. - error(node, ts.Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); - return unknownType; + + let promiseType = getTypeFromTypeNode(node.type); + let promiseConstructor = getMergedSymbol(promiseType.symbol); + if (!promiseConstructor || !symbolIsValue(promiseConstructor)) { + error(node, Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType)); + return unknownType } + // Validate the promise constructor type. + let promiseConstructorType = getTypeOfSymbol(promiseConstructor); + if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, node, Diagnostics.Type_0_is_not_a_valid_async_function_return_type)) { + return unknownType; + } + + // Verify there is no local declaration that could collide with the promise constructor. + let promiseName = getEntityNameFromTypeNode(node.type); + let root = getFirstIdentifier(promiseName); + let rootSymbol = getSymbol(node.locals, root.text, SymbolFlags.Value); + if (rootSymbol) { + error(rootSymbol.valueDeclaration, Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, + root.text, + getFullyQualifiedName(promiseConstructor)); + return unknownType; + } + // Get and return the awaited type of the return type. - return getAwaitedType(returnType, node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return getAwaitedType(promiseType, node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); } /** Check a decorator */ @@ -10093,22 +10089,6 @@ namespace ts { } } } - - function checkCollisionWithAwaiterVariablesInGeneratedCode(node: Node, name: DeclarationName): void { - if (!name || name.kind !== SyntaxKind.Identifier || isTypeNode(name)) { - return; - } - - let identifier = name; - let container = getContainingFunction(name); - if (container && isAsyncFunctionLike(container) && node.kind !== SyntaxKind.Identifier) { - let promiseConstructorName = getEntityNameFromTypeNode(container.type); - let firstIdentifier = promiseConstructorName ? getFirstIdentifier(promiseConstructorName) : undefined; - if (firstIdentifier && firstIdentifier.text === identifier.text) { - error(node, Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, identifier.text, getTextOfNode(promiseConstructorName)); - } - } - } // Check that a parameter initializer contains no references to parameters declared to the right of itself function checkParameterInitializer(node: VariableLikeDeclaration): void { @@ -10954,7 +10934,6 @@ namespace ts { checkTypeNameIsReserved(node.name, Diagnostics.Class_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); - checkCollisionWithAwaiterVariablesInGeneratedCode(node, node.name); } checkTypeParameters(node.typeParameters); checkExportsOnMergedDeclarations(node); @@ -11398,7 +11377,6 @@ namespace ts { checkTypeNameIsReserved(node.name, Diagnostics.Enum_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); - checkCollisionWithAwaiterVariablesInGeneratedCode(node, node.name); checkExportsOnMergedDeclarations(node); computeEnumMemberValues(node); diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 17472e4ce85..6cd9a803aa4 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -48,6 +48,7 @@ namespace ts { A_set_accessor_parameter_cannot_have_an_initializer: { code: 1052, category: DiagnosticCategory.Error, key: "A 'set' accessor parameter cannot have an initializer." }, A_set_accessor_cannot_have_rest_parameter: { code: 1053, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have rest parameter." }, A_get_accessor_cannot_have_parameters: { code: 1054, category: DiagnosticCategory.Error, key: "A 'get' accessor cannot have parameters." }, + Type_0_is_not_a_valid_async_function_return_type: { code: 1055, category: DiagnosticCategory.Error, key: "Type '{0}' is not a valid async function return type." }, Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." }, An_async_function_or_method_must_have_a_valid_awaitable_return_type: { code: 1057, category: DiagnosticCategory.Error, key: "An async function or method must have a valid awaitable return type." }, Operand_for_await_does_not_have_a_valid_callable_then_member: { code: 1058, category: DiagnosticCategory.Error, key: "Operand for 'await' does not have a valid callable 'then' member." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 6ddf1709475..4ad7408d70d 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -179,6 +179,10 @@ "category": "Error", "code": 1054 }, + "Type '{0}' is not a valid async function return type.": { + "category": "Error", + "code": 1055 + }, "Accessors are only available when targeting ECMAScript 5 and higher.": { "category": "Error", "code": 1056 diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index d0903ccfdf2..d537380dc5d 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -49,10 +49,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { };`; const awaiterHelper = ` -var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, PromiseConstructor) { - PromiseConstructor || (PromiseConstructor = Promise); +var __awaiter = (this && this.__awaiter) || function (args, generator) { + var PromiseConstructor = args[1] || Promise; return new PromiseConstructor(function (resolve, reject) { - generator = generator.call(thisArg, args); + generator = generator.call(args[0], args[2]); function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); } function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } } function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } } @@ -3359,6 +3359,7 @@ var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, function emitAsyncFunctionBodyForES6(node: FunctionLikeDeclaration) { let promiseConstructor = getEntityNameFromTypeNode(node.type); let isArrowFunction = node.kind === SyntaxKind.ArrowFunction; + let hasLexicalArguments = (resolver.getNodeCheckFlags(node) & NodeCheckFlags.CaptureArguments) !== 0; let args: string; // An async function is emit as an outer function that calls an inner @@ -3373,7 +3374,7 @@ var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, // let a = async (b) => { await b; } // // // output - // let a = (b) => __awaiter(function* (b) { + // let a = (b) => __awaiter([this], function* (b) { // yield b; // }, this); // @@ -3383,9 +3384,9 @@ var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, // let a = async (b) => { await arguments[0]; } // // // output - // let a = (b) => __awaiter(function* (arguments) { + // let a = (b) => __awaiter([this, arguments], function* (arguments) { // yield arguments[0]; - // }, this, arguments); + // }); // // The emit for an async function expression without a lexical `arguments` binding // might be: @@ -3397,7 +3398,7 @@ var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, // // // output // let a = function (b) { - // return __awaiter(function* () { + // return __awaiter([this], function* () { // yield b; // }, this); // } @@ -3412,9 +3413,24 @@ var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, // // // output // let a = function (b) { - // return __awaiter(function* (arguments) { + // return __awaiter([this, arguments], function* (arguments) { // yield arguments[0]; - // }, this, arguments); + // }); + // } + // + // The emit for an async function expression with a lexical `arguments` binding + // and a return type annotation might be: + // + // // input + // let a = async function (b): MyPromise { + // await arguments[0]; + // } + // + // // output + // let a = function (b) { + // return __awaiter([this, arguments, MyPromise], function* (arguments) { + // yield arguments[0]; + // }); // } // @@ -3427,42 +3443,27 @@ var __awaiter = (this && this.__awaiter) || function (generator, thisArg, args, write("return"); } + write(" __awaiter([this"); + if (promiseConstructor || hasLexicalArguments) { + write(", "); + if (promiseConstructor) { + emitNodeWithoutSourceMap(promiseConstructor); + } + if (hasLexicalArguments) { + write(", arguments"); + } + } // Emit the call to __awaiter. - let hasLexicalArguments = (resolver.getNodeCheckFlags(node) & NodeCheckFlags.CaptureArguments) !== 0; if (hasLexicalArguments) { - write(" __awaiter(function* (arguments)"); + write("], function* (arguments)"); } else { - write(" __awaiter(function* ()"); + write("], function* ()"); } // Emit the signature and body for the inner generator function. emitFunctionBody(node); - - // Emit the current `this` binding. - write(","); - writeLine(); - write("this"); - - // Optionally emit the lexical arguments. - if (hasLexicalArguments) { - write(", arguments"); - } - - // If the function has an explicit type annotation for a promise, emit the - // constructor. - if (promiseConstructor) { - // If we did not have lexical arguments, supply undefined (void 0) for - // the `arguments` parameter. - if (!hasLexicalArguments) { - write(", void 0"); - } - - write(", "); - emitNodeWithoutSourceMap(promiseConstructor); - } - write(")"); // If this is not an async arrow, emit the closing brace of the outer function body. diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js index 257b147dbc7..2c2f1091b15 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.js +++ b/tests/baselines/reference/asyncArrowFunction1_es6.js @@ -4,6 +4,5 @@ var foo = async (): Promise => { }; //// [asyncArrowFunction1_es6.js] -var foo = () => __awaiter(function* () { -}, -this, void 0, Promise); +var foo = () => __awaiter([this, Promise], function* () { +}); diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js index 5353903d10e..0a39441edf7 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.js +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -4,6 +4,5 @@ var foo = async (a = await): Promise => { } //// [asyncArrowFunction6_es6.js] -var foo = (a = yield ) => __awaiter(function* () { -}, -this, void 0, Promise); +var foo = (a = yield ) => __awaiter([this, Promise], function* () { +}); diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js index b3c5f536550..bb17963bfd3 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.js +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -7,10 +7,8 @@ var bar = async (): Promise => { } //// [asyncArrowFunction7_es6.js] -var bar = () => __awaiter(function* () { +var bar = () => __awaiter([this, Promise], function* () { // 'await' here is an identifier, and not an await expression. - var foo = (a = yield ) => __awaiter(function* () { - }, - this, void 0, Promise); -}, -this, void 0, Promise); + var foo = (a = yield ) => __awaiter([this, Promise], function* () { + }); +}); diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js index e4383a16220..2ec23259510 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es6.js +++ b/tests/baselines/reference/asyncArrowFunction8_es6.js @@ -5,7 +5,6 @@ var foo = async (): Promise => { } //// [asyncArrowFunction8_es6.js] -var foo = () => __awaiter(function* () { +var foo = () => __awaiter([this, Promise], function* () { var v = { [yield ]: foo }; -}, -this, void 0, Promise); +}); diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js index 888c935cc3f..8cac736ea1b 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js @@ -11,7 +11,6 @@ class C { class C { method() { function other() { } - var fn = () => __awaiter(function* (arguments) { return yield other.apply(this, arguments); }, - this, arguments); + var fn = () => __awaiter([this, , arguments], function* (arguments) { return yield other.apply(this, arguments); }); } } diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js index 67279d7f1be..b13815ffcbf 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js +++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js @@ -9,7 +9,6 @@ class C { //// [asyncArrowFunctionCapturesThis_es6.js] class C { method() { - var fn = () => __awaiter(function* () { return yield this; }, - this); + var fn = () => __awaiter([this], function* () { return yield this; }); } } diff --git a/tests/baselines/reference/asyncAwait_es6.js b/tests/baselines/reference/asyncAwait_es6.js new file mode 100644 index 00000000000..2c0ffaf478a --- /dev/null +++ b/tests/baselines/reference/asyncAwait_es6.js @@ -0,0 +1,119 @@ +//// [asyncAwait_es6.ts] +type MyPromise = Promise; +declare var MyPromise: typeof Promise; +declare var p: Promise; +declare var mp: MyPromise; + +async function f0() { } +async function f1(): Promise { } +async function f3(): MyPromise { } + +let f4 = async function() { } +let f5 = async function(): Promise { } +let f6 = async function(): MyPromise { } + +let f7 = async () => { }; +let f8 = async (): Promise => { }; +let f9 = async (): MyPromise => { }; +let f10 = async () => p; +let f11 = async () => mp; +let f12 = async (): Promise => mp; +let f13 = async (): MyPromise => p; + +let o = { + async m1() { }, + async m2(): Promise { }, + async m3(): MyPromise { } +}; + +class C { + async m1() { } + async m2(): Promise { } + async m3(): MyPromise { } + static async m4() { } + static async m5(): Promise { } + static async m6(): MyPromise { } +} + +module M { + export async function f1() { } +} + +//// [asyncAwait_es6.js] +var __awaiter = (this && this.__awaiter) || function (args, generator) { + var PromiseConstructor = args[1] || Promise; + return new PromiseConstructor(function (resolve, reject) { + generator = generator.call(args[0], args[2]); + function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); } + function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } } + function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } } + function step(verb, value) { + var result = generator[verb](value); + result.done ? resolve(result.value) : cast(result.value).then(onfulfill, onreject); + } + step("next", void 0); + }); +}; +function f0() { + return __awaiter([this], function* () { }); +} +function f1() { + return __awaiter([this, Promise], function* () { }); +} +function f3() { + return __awaiter([this, MyPromise], function* () { }); +} +let f4 = function () { + return __awaiter([this], function* () { }); +}; +let f5 = function () { + return __awaiter([this, Promise], function* () { }); +}; +let f6 = function () { + return __awaiter([this, MyPromise], function* () { }); +}; +let f7 = () => __awaiter([this], function* () { }); +let f8 = () => __awaiter([this, Promise], function* () { }); +let f9 = () => __awaiter([this, MyPromise], function* () { }); +let f10 = () => __awaiter([this], function* () { return p; }); +let f11 = () => __awaiter([this], function* () { return mp; }); +let f12 = () => __awaiter([this, Promise], function* () { return mp; }); +let f13 = () => __awaiter([this, MyPromise], function* () { return p; }); +let o = { + m1() { + return __awaiter([this], function* () { }); + }, + m2() { + return __awaiter([this, Promise], function* () { }); + }, + m3() { + return __awaiter([this, MyPromise], function* () { }); + } +}; +class C { + m1() { + return __awaiter([this], function* () { }); + } + m2() { + return __awaiter([this, Promise], function* () { }); + } + m3() { + return __awaiter([this, MyPromise], function* () { }); + } + static m4() { + return __awaiter([this], function* () { }); + } + static m5() { + return __awaiter([this, Promise], function* () { }); + } + static m6() { + return __awaiter([this, MyPromise], function* () { }); + } +} +var M; +(function (M) { + function f1() { + return __awaiter([this], function* () { }); + } + M.f1 = f1; +})(M || (M = {})); diff --git a/tests/baselines/reference/asyncAwait_es6.symbols b/tests/baselines/reference/asyncAwait_es6.symbols new file mode 100644 index 00000000000..6cd18e254ba --- /dev/null +++ b/tests/baselines/reference/asyncAwait_es6.symbols @@ -0,0 +1,118 @@ +=== tests/cases/conformance/async/es6/asyncAwait_es6.ts === +type MyPromise = Promise; +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) +>T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) +>T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15)) + +declare var MyPromise: typeof Promise; +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) + +declare var mp: MyPromise; +>mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) + +async function f0() { } +>f0 : Symbol(f0, Decl(asyncAwait_es6.ts, 3, 34)) + +async function f1(): Promise { } +>f1 : Symbol(f1, Decl(asyncAwait_es6.ts, 5, 23)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) + +async function f3(): MyPromise { } +>f3 : Symbol(f3, Decl(asyncAwait_es6.ts, 6, 38)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) + +let f4 = async function() { } +>f4 : Symbol(f4, Decl(asyncAwait_es6.ts, 9, 3)) + +let f5 = async function(): Promise { } +>f5 : Symbol(f5, Decl(asyncAwait_es6.ts, 10, 3)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) + +let f6 = async function(): MyPromise { } +>f6 : Symbol(f6, Decl(asyncAwait_es6.ts, 11, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) + +let f7 = async () => { }; +>f7 : Symbol(f7, Decl(asyncAwait_es6.ts, 13, 3)) + +let f8 = async (): Promise => { }; +>f8 : Symbol(f8, Decl(asyncAwait_es6.ts, 14, 3)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) + +let f9 = async (): MyPromise => { }; +>f9 : Symbol(f9, Decl(asyncAwait_es6.ts, 15, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) + +let f10 = async () => p; +>f10 : Symbol(f10, Decl(asyncAwait_es6.ts, 16, 3)) +>p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11)) + +let f11 = async () => mp; +>f11 : Symbol(f11, Decl(asyncAwait_es6.ts, 17, 3)) +>mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11)) + +let f12 = async (): Promise => mp; +>f12 : Symbol(f12, Decl(asyncAwait_es6.ts, 18, 3)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) +>mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11)) + +let f13 = async (): MyPromise => p; +>f13 : Symbol(f13, Decl(asyncAwait_es6.ts, 19, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) +>p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11)) + +let o = { +>o : Symbol(o, Decl(asyncAwait_es6.ts, 21, 3)) + + async m1() { }, +>m1 : Symbol(m1, Decl(asyncAwait_es6.ts, 21, 9)) + + async m2(): Promise { }, +>m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 22, 16)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) + + async m3(): MyPromise { } +>m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 23, 31)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) + +}; + +class C { +>C : Symbol(C, Decl(asyncAwait_es6.ts, 25, 2)) + + async m1() { } +>m1 : Symbol(m1, Decl(asyncAwait_es6.ts, 27, 9)) + + async m2(): Promise { } +>m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 28, 15)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) + + async m3(): MyPromise { } +>m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 29, 30)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) + + static async m4() { } +>m4 : Symbol(C.m4, Decl(asyncAwait_es6.ts, 30, 32)) + + static async m5(): Promise { } +>m5 : Symbol(C.m5, Decl(asyncAwait_es6.ts, 31, 22)) +>Promise : Symbol(Promise, Decl(lib.d.ts, 4768, 1), Decl(lib.d.ts, 4854, 11)) + + static async m6(): MyPromise { } +>m6 : Symbol(C.m6, Decl(asyncAwait_es6.ts, 32, 37)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) +} + +module M { +>M : Symbol(M, Decl(asyncAwait_es6.ts, 34, 1)) + + export async function f1() { } +>f1 : Symbol(f1, Decl(asyncAwait_es6.ts, 36, 10)) +} diff --git a/tests/baselines/reference/asyncAwait_es6.types b/tests/baselines/reference/asyncAwait_es6.types new file mode 100644 index 00000000000..5f0cd2cc35a --- /dev/null +++ b/tests/baselines/reference/asyncAwait_es6.types @@ -0,0 +1,129 @@ +=== tests/cases/conformance/async/es6/asyncAwait_es6.ts === +type MyPromise = Promise; +>MyPromise : Promise +>T : T +>Promise : Promise +>T : T + +declare var MyPromise: typeof Promise; +>MyPromise : PromiseConstructor +>Promise : PromiseConstructor + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare var mp: MyPromise; +>mp : Promise +>MyPromise : Promise + +async function f0() { } +>f0 : () => Promise + +async function f1(): Promise { } +>f1 : () => Promise +>Promise : Promise + +async function f3(): MyPromise { } +>f3 : () => Promise +>MyPromise : Promise + +let f4 = async function() { } +>f4 : () => Promise +>async function() { } : () => Promise + +let f5 = async function(): Promise { } +>f5 : () => Promise +>async function(): Promise { } : () => Promise +>Promise : Promise + +let f6 = async function(): MyPromise { } +>f6 : () => Promise +>async function(): MyPromise { } : () => Promise +>MyPromise : Promise + +let f7 = async () => { }; +>f7 : () => Promise +>async () => { } : () => Promise + +let f8 = async (): Promise => { }; +>f8 : () => Promise +>async (): Promise => { } : () => Promise +>Promise : Promise + +let f9 = async (): MyPromise => { }; +>f9 : () => Promise +>async (): MyPromise => { } : () => Promise +>MyPromise : Promise + +let f10 = async () => p; +>f10 : () => Promise +>async () => p : () => Promise +>p : Promise + +let f11 = async () => mp; +>f11 : () => Promise +>async () => mp : () => Promise +>mp : Promise + +let f12 = async (): Promise => mp; +>f12 : () => Promise +>async (): Promise => mp : () => Promise +>Promise : Promise +>mp : Promise + +let f13 = async (): MyPromise => p; +>f13 : () => Promise +>async (): MyPromise => p : () => Promise +>MyPromise : Promise +>p : Promise + +let o = { +>o : { m1(): Promise; m2(): Promise; m3(): Promise; } +>{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): Promise; } + + async m1() { }, +>m1 : () => Promise + + async m2(): Promise { }, +>m2 : () => Promise +>Promise : Promise + + async m3(): MyPromise { } +>m3 : () => Promise +>MyPromise : Promise + +}; + +class C { +>C : C + + async m1() { } +>m1 : () => Promise + + async m2(): Promise { } +>m2 : () => Promise +>Promise : Promise + + async m3(): MyPromise { } +>m3 : () => Promise +>MyPromise : Promise + + static async m4() { } +>m4 : () => Promise + + static async m5(): Promise { } +>m5 : () => Promise +>Promise : Promise + + static async m6(): MyPromise { } +>m6 : () => Promise +>MyPromise : Promise +} + +module M { +>M : typeof M + + export async function f1() { } +>f1 : () => Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js index dbf2d489a92..7cc10548371 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js @@ -4,7 +4,6 @@ async function await(): Promise { //// [asyncFunctionDeclaration11_es6.js] function await() { - return __awaiter(function* () { - }, - this, void 0, Promise); + return __awaiter([this, Promise], function* () { + }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js index 35f6af6b2ff..f17b5c894f8 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js @@ -7,9 +7,8 @@ async function foo(): Promise { //// [asyncFunctionDeclaration13_es6.js] function foo() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { // Legal to use 'await' in a type context. var v; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js index 3610cabbdec..7fee3f4802a 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js @@ -5,8 +5,7 @@ async function foo(): Promise { //// [asyncFunctionDeclaration14_es6.js] function foo() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { return; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js index e3e1fb65096..3e587858021 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js @@ -4,7 +4,6 @@ async function foo(): Promise { //// [asyncFunctionDeclaration1_es6.js] function foo() { - return __awaiter(function* () { - }, - this, void 0, Promise); + return __awaiter([this, Promise], function* () { + }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js index 3c1b16cea96..33645996cd8 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js @@ -4,7 +4,6 @@ async function foo(a = await): Promise { //// [asyncFunctionDeclaration6_es6.js] function foo(a = yield ) { - return __awaiter(function* () { - }, - this, void 0, Promise); + return __awaiter([this, Promise], function* () { + }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js index 0b2f643e469..667250e45db 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js @@ -7,13 +7,11 @@ async function bar(): Promise { //// [asyncFunctionDeclaration7_es6.js] function bar() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { // 'await' here is an identifier, and not a yield expression. function foo(a = yield ) { - return __awaiter(function* () { - }, - this, void 0, Promise); + return __awaiter([this, Promise], function* () { + }); } - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js index 7f23510f942..dab1b75076e 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js @@ -5,8 +5,7 @@ async function foo(): Promise { //// [asyncFunctionDeclaration9_es6.js] function foo() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { var v = { [yield ]: foo }; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.js b/tests/baselines/reference/awaitBinaryExpression1_es6.js index 0531f7643fc..11b630355d4 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.js @@ -9,10 +9,9 @@ async function func(): Promise { //// [awaitBinaryExpression1_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = (yield p) || a; "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.js b/tests/baselines/reference/awaitBinaryExpression2_es6.js index 36545440f1f..e8f610ae10a 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.js @@ -9,10 +9,9 @@ async function func(): Promise { //// [awaitBinaryExpression2_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = (yield p) && a; "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.js b/tests/baselines/reference/awaitBinaryExpression3_es6.js index bfe95956ebc..770bf75d5a1 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.js @@ -9,10 +9,9 @@ async function func(): Promise { //// [awaitBinaryExpression3_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = (yield p) + a; "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.js b/tests/baselines/reference/awaitBinaryExpression4_es6.js index fa2dd17143e..f756d6604bb 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.js @@ -9,10 +9,9 @@ async function func(): Promise { //// [awaitBinaryExpression4_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = yield p, a; "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.js b/tests/baselines/reference/awaitBinaryExpression5_es6.js index 615320e8ebb..c66cfbbd57a 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.js @@ -10,11 +10,10 @@ async function func(): Promise { //// [awaitBinaryExpression5_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var o; o.a = yield p; "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitCallExpression1_es6.js b/tests/baselines/reference/awaitCallExpression1_es6.js index 9e329e14ad2..db4e0c96abf 100644 --- a/tests/baselines/reference/awaitCallExpression1_es6.js +++ b/tests/baselines/reference/awaitCallExpression1_es6.js @@ -13,10 +13,9 @@ async function func(): Promise { //// [awaitCallExpression1_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = fn(a, a, a); "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitCallExpression2_es6.js b/tests/baselines/reference/awaitCallExpression2_es6.js index 4f8e088b55d..47b1e062ae5 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.js +++ b/tests/baselines/reference/awaitCallExpression2_es6.js @@ -13,10 +13,9 @@ async function func(): Promise { //// [awaitCallExpression2_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = fn(yield p, a, a); "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitCallExpression3_es6.js b/tests/baselines/reference/awaitCallExpression3_es6.js index 54b5d8411d7..e7a09f9b9b8 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.js +++ b/tests/baselines/reference/awaitCallExpression3_es6.js @@ -13,10 +13,9 @@ async function func(): Promise { //// [awaitCallExpression3_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = fn(a, yield p, a); "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitCallExpression4_es6.js b/tests/baselines/reference/awaitCallExpression4_es6.js index 9e32395df83..59449e4f6a1 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.js +++ b/tests/baselines/reference/awaitCallExpression4_es6.js @@ -13,10 +13,9 @@ async function func(): Promise { //// [awaitCallExpression4_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = (yield pfn)(a, a, a); "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitCallExpression5_es6.js b/tests/baselines/reference/awaitCallExpression5_es6.js index 76ccf06b105..c5e28deee89 100644 --- a/tests/baselines/reference/awaitCallExpression5_es6.js +++ b/tests/baselines/reference/awaitCallExpression5_es6.js @@ -13,10 +13,9 @@ async function func(): Promise { //// [awaitCallExpression5_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = o.fn(a, a, a); "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitCallExpression6_es6.js b/tests/baselines/reference/awaitCallExpression6_es6.js index 90b96a06ad7..62fde8c799c 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.js +++ b/tests/baselines/reference/awaitCallExpression6_es6.js @@ -13,10 +13,9 @@ async function func(): Promise { //// [awaitCallExpression6_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = o.fn(yield p, a, a); "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitCallExpression7_es6.js b/tests/baselines/reference/awaitCallExpression7_es6.js index e9a2edb8a91..f717d76c51d 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.js +++ b/tests/baselines/reference/awaitCallExpression7_es6.js @@ -13,10 +13,9 @@ async function func(): Promise { //// [awaitCallExpression7_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = o.fn(a, yield p, a); "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/baselines/reference/awaitCallExpression8_es6.js b/tests/baselines/reference/awaitCallExpression8_es6.js index e172dde417d..e6e2cee172b 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.js +++ b/tests/baselines/reference/awaitCallExpression8_es6.js @@ -13,10 +13,9 @@ async function func(): Promise { //// [awaitCallExpression8_es6.js] function func() { - return __awaiter(function* () { + return __awaiter([this, Promise], function* () { "before"; var b = (yield po).fn(a, a, a); "after"; - }, - this, void 0, Promise); + }); } diff --git a/tests/cases/conformance/async/es6/asyncAwait_es6.ts b/tests/cases/conformance/async/es6/asyncAwait_es6.ts new file mode 100644 index 00000000000..8e72197a98d --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncAwait_es6.ts @@ -0,0 +1,40 @@ +// @target: ES6 +type MyPromise = Promise; +declare var MyPromise: typeof Promise; +declare var p: Promise; +declare var mp: MyPromise; + +async function f0() { } +async function f1(): Promise { } +async function f3(): MyPromise { } + +let f4 = async function() { } +let f5 = async function(): Promise { } +let f6 = async function(): MyPromise { } + +let f7 = async () => { }; +let f8 = async (): Promise => { }; +let f9 = async (): MyPromise => { }; +let f10 = async () => p; +let f11 = async () => mp; +let f12 = async (): Promise => mp; +let f13 = async (): MyPromise => p; + +let o = { + async m1() { }, + async m2(): Promise { }, + async m3(): MyPromise { } +}; + +class C { + async m1() { } + async m2(): Promise { } + async m3(): MyPromise { } + static async m4() { } + static async m5(): Promise { } + static async m6(): MyPromise { } +} + +module M { + export async function f1() { } +} \ No newline at end of file From 5ca3955473e5242c18e09b178dd69dc0bfb3dfd9 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 12:19:07 -0700 Subject: [PATCH 115/309] check for inheriting abstract member functions --- src/compiler/checker.ts | 120 ++++++++++++------ .../diagnosticInformationMap.generated.ts | 2 + src/compiler/diagnosticMessages.json | 8 ++ 3 files changed, 88 insertions(+), 42 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index fac2ee3b4c5..2f7a66ad78c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1978,7 +1978,7 @@ namespace ts { // If the binding pattern is empty, this variable declaration is not visible return false; } - // Otherwise fall through + // Otherwise fall through case SyntaxKind.ModuleDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: @@ -2172,8 +2172,8 @@ namespace ts { // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature, // or otherwise the type of the string index signature. type = getTypeOfPropertyOfType(parentType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) || - getIndexTypeOfType(parentType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) || + getIndexTypeOfType(parentType, IndexKind.String); if (!type) { error(name, Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(parentType), declarationNameToString(name)); return unknownType; @@ -3686,8 +3686,8 @@ namespace ts { let symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol; let type = symbol === unknownSymbol ? unknownType : symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) : - symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : - getTypeFromNonGenericTypeReference(node, symbol); + symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the // type reference in checkTypeReferenceOrExpressionWithTypeArguments. links.resolvedSymbol = symbol; @@ -4561,7 +4561,24 @@ namespace ts { let requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectLiteral); for (let targetProp of properties) { let sourceProp = getPropertyOfType(source, targetProp.name); - if (sourceProp !== targetProp) { + + if (sourceProp === targetProp) { // source inherits targetProp and doesn't redeclare/override it. + + if (source.flags & TypeFlags.Class && target.flags & TypeFlags.Class) { + + let targetPropFlags = getDeclarationFlagsFromSymbol(targetProp); + let sourceDecl = getDeclarationOfKind(source.symbol, SyntaxKind.ClassDeclaration); + + // if target is a class and it has an abstract method, then source, inheriting that method, must be declared abstract. + if (targetPropFlags & NodeFlags.Abstract && !(sourceDecl.flags & NodeFlags.Abstract)) { + if (reportErrors) { + reportError(Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2, + typeToString(source), typeToString(target), symbolToString(targetProp)); + } + return Ternary.False; + } + } + } else { // sourceProp !== targetProp -- ie: source and target have distinct declarations with the same name if (!sourceProp) { if (!(targetProp.flags & SymbolFlags.Optional) || requireOptionalProperties) { if (reportErrors) { @@ -4571,24 +4588,24 @@ namespace ts { } } else if (!(targetProp.flags & SymbolFlags.Prototype)) { - let sourceFlags = getDeclarationFlagsFromSymbol(sourceProp); - let targetFlags = getDeclarationFlagsFromSymbol(targetProp); - if (sourceFlags & NodeFlags.Private || targetFlags & NodeFlags.Private) { + let sourcePropFlags = getDeclarationFlagsFromSymbol(sourceProp); + let targetPropFlags = getDeclarationFlagsFromSymbol(targetProp); + if (sourcePropFlags & NodeFlags.Private || targetPropFlags & NodeFlags.Private) { if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) { if (reportErrors) { - if (sourceFlags & NodeFlags.Private && targetFlags & NodeFlags.Private) { + if (sourcePropFlags & NodeFlags.Private && targetPropFlags & NodeFlags.Private) { reportError(Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp)); } else { reportError(Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), - typeToString(sourceFlags & NodeFlags.Private ? source : target), - typeToString(sourceFlags & NodeFlags.Private ? target : source)); + typeToString(sourcePropFlags & NodeFlags.Private ? source : target), + typeToString(sourcePropFlags & NodeFlags.Private ? target : source)); } } return Ternary.False; } } - else if (targetFlags & NodeFlags.Protected) { + else if (targetPropFlags & NodeFlags.Protected) { let sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & SymbolFlags.Class; let sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined; let targetClass = getDeclaredTypeOfSymbol(targetProp.parent); @@ -4600,7 +4617,7 @@ namespace ts { return Ternary.False; } } - else if (sourceFlags & NodeFlags.Protected) { + else if (sourcePropFlags & NodeFlags.Protected) { if (reportErrors) { reportError(Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); @@ -5993,20 +6010,20 @@ namespace ts { if (container && container.parent && container.parent.kind === SyntaxKind.ClassDeclaration) { if (container.flags & NodeFlags.Static) { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor; } else { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor || - container.kind === SyntaxKind.PropertyDeclaration || - container.kind === SyntaxKind.PropertySignature || - container.kind === SyntaxKind.Constructor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor || + container.kind === SyntaxKind.PropertyDeclaration || + container.kind === SyntaxKind.PropertySignature || + container.kind === SyntaxKind.Constructor; } } } @@ -6637,7 +6654,7 @@ namespace ts { return s.valueDeclaration ? s.valueDeclaration.kind : SyntaxKind.PropertyDeclaration; } - function getDeclarationFlagsFromSymbol(s: Symbol) { + function getDeclarationFlagsFromSymbol(s: Symbol): NodeFlags { return s.valueDeclaration ? getCombinedNodeFlags(s.valueDeclaration) : s.flags & SymbolFlags.Prototype ? NodeFlags.Public | NodeFlags.Static : 0; } @@ -8101,8 +8118,8 @@ namespace ts { let type = isTypeAny(sourceType) ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || - getIndexTypeOfType(sourceType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || + getIndexTypeOfType(sourceType, IndexKind.String); if (type) { checkDestructuringAssignment((p).initializer || name, type); } @@ -8290,7 +8307,7 @@ namespace ts { if (!checkForDisallowedESSymbolOperand(operator)) { return booleanType; } - // fall-through + // fall-through case SyntaxKind.EqualsEqualsToken: case SyntaxKind.ExclamationEqualsToken: case SyntaxKind.EqualsEqualsEqualsToken: @@ -8318,8 +8335,8 @@ namespace ts { function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean { let offendingSymbolOperand = someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? node.left : - someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : - undefined; + someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : + undefined; if (offendingSymbolOperand) { error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator)); return false; @@ -9258,7 +9275,7 @@ namespace ts { } // abstract functions cannot have an implementation - if(currentNodeFlags & NodeFlags.Abstract) { + if (currentNodeFlags & NodeFlags.Abstract) { error(node, Diagnostics.Abstract_member_functions_cannot_have_an_implementation) } } @@ -9505,7 +9522,7 @@ namespace ts { case SyntaxKind.MethodDeclaration: checkParameterTypeAnnotationsAsExpressions(node); - // fall-through + // fall-through case SyntaxKind.SetAccessor: case SyntaxKind.GetAccessor: @@ -10627,6 +10644,9 @@ namespace ts { checkTypeAssignableTo(type, baseType, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); + + + if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class)) { // When the static base type is a "class-like" constructor function (but not actually a class), we verify // that all instantiated base constructor signatures return the same type. @@ -10662,6 +10682,11 @@ namespace ts { } forEach(node.members, checkSourceElement); + + // Classes containing abstract members must be marked abstract + if (!(node.flags & NodeFlags.Abstract) && forEach(node.members, (element: ClassElement) => element.flags & NodeFlags.Abstract)) { + error(node, Diagnostics.Classes_containing_abstract_functions_must_be_marked_abstract); + } if (produceDiagnostics) { checkIndexConstraints(type); checkTypeForDuplicateIndexSignatures(node); @@ -10700,8 +10725,19 @@ namespace ts { } let derived = getTargetSymbol(getPropertyOfObjectType(type, base.name)); - if (derived) { - let baseDeclarationFlags = getDeclarationFlagsFromSymbol(base); + let baseDeclarationFlags = getDeclarationFlagsFromSymbol(base); + + if (!derived) { // derived class inherits base without override/redeclaration + let derivedClassDecl = getDeclarationOfKind(type.symbol, SyntaxKind.ClassDeclaration); + Debug.assert(derivedClassDecl !== undefined); + + // It is an error to inherit an abstract member without implementing it or being declared abstract. + if ((baseDeclarationFlags & NodeFlags.Abstract) && !(derivedClassDecl.flags & NodeFlags.Abstract)) { + error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2, + typeToString(type), typeToString(baseType), symbolToString(baseProperty)); + } + + } else { // derived !== undefined -- derived overrides base let derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived); if ((baseDeclarationFlags & NodeFlags.Private) || (derivedDeclarationFlags & NodeFlags.Private)) { // either base or derived property is private - not override, skip it @@ -11990,7 +12026,7 @@ namespace ts { (node.parent).moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } - // fall-through + // fall-through case SyntaxKind.NumericLiteral: // index access @@ -12163,7 +12199,7 @@ namespace ts { if (links.isNestedRedeclaration === undefined) { let container = getEnclosingBlockScopeContainer(symbol.valueDeclaration); links.isNestedRedeclaration = isStatementWithLocals(container) && - !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); + !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); } return links.isNestedRedeclaration; } @@ -12414,11 +12450,11 @@ namespace ts { // // For rules on serializing type annotations, see `serializeTypeNode`. switch (node.kind) { - case SyntaxKind.ClassDeclaration: return "Function"; - case SyntaxKind.PropertyDeclaration: return serializeTypeNode((node).type); - case SyntaxKind.Parameter: return serializeTypeNode((node).type); - case SyntaxKind.GetAccessor: return serializeTypeNode((node).type); - case SyntaxKind.SetAccessor: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node)); + case SyntaxKind.ClassDeclaration: return "Function"; + case SyntaxKind.PropertyDeclaration: return serializeTypeNode((node).type); + case SyntaxKind.Parameter: return serializeTypeNode((node).type); + case SyntaxKind.GetAccessor: return serializeTypeNode((node).type); + case SyntaxKind.SetAccessor: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node)); } if (isFunctionLike(node)) { return "Function"; diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index d1cd9b4ba39..a29aed6615f 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -396,6 +396,8 @@ namespace ts { Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, All_overload_signatures_must_match_with_respect_to_modifier_0: { code: 2512, category: DiagnosticCategory.Error, key: "All overload signatures must match with respect to modifier '{0}'." }, Abstract_member_function_0_on_type_1_cannot_be_called_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract member function '{0}' on type '{1}' cannot be called via super expression." }, + Classes_containing_abstract_functions_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract functions must be marked abstract." }, + Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index ddfc885dcf6..859565c181a 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1571,6 +1571,14 @@ "category": "Error", "code": 2513 }, + "Classes containing abstract functions must be marked abstract.": { + "category": "Error", + "code": 2514 + }, + "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'." : { + "category": "Error", + "code": 2515 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 From 91e3a5cce2906474f6e6af2d34df145ddc0c9bb8 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 12:27:48 -0700 Subject: [PATCH 116/309] updated baselines --- .../reference/augmentedTypesClass2.errors.txt | 8 ++--- .../augmentedTypesInterface.errors.txt | 8 ++--- .../classAndInterfaceWithSameName.errors.txt | 16 +++++----- .../reference/clinterfaces.errors.txt | 32 +++++++++---------- .../baselines/reference/declInput.errors.txt | 8 ++--- ...ifiersAcrossContainerBoundaries.errors.txt | 8 ++--- ...IdentifiersAcrossFileBoundaries.errors.txt | 16 +++++----- .../interfaceDeclaration2.errors.txt | 8 ++--- .../reference/mergedClassInterface.errors.txt | 16 +++++----- .../reference/nameCollisions.errors.txt | 16 +++++----- ...tringsArrayTypeDefinedInES5Mode.errors.txt | 5 ++- ...ingsArrayTypeRedefinedInES6Mode.errors.txt | 5 ++- 12 files changed, 72 insertions(+), 74 deletions(-) diff --git a/tests/baselines/reference/augmentedTypesClass2.errors.txt b/tests/baselines/reference/augmentedTypesClass2.errors.txt index 9d0b7b25c34..da963c59d94 100644 --- a/tests/baselines/reference/augmentedTypesClass2.errors.txt +++ b/tests/baselines/reference/augmentedTypesClass2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/augmentedTypesClass2.ts(4,7): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/augmentedTypesClass2.ts(10,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesClass2.ts(4,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesClass2.ts(10,11): error TS2511: Only an ambient class can be merged with an interface. tests/cases/compiler/augmentedTypesClass2.ts(16,7): error TS2300: Duplicate identifier 'c33'. tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate identifier 'c33'. @@ -10,7 +10,7 @@ tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate iden // class then interface class c11 { // error ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. foo() { return 1; } @@ -18,7 +18,7 @@ tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate iden interface c11 { // error ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. bar(): void; } diff --git a/tests/baselines/reference/augmentedTypesInterface.errors.txt b/tests/baselines/reference/augmentedTypesInterface.errors.txt index 8ee7dc4e1e8..44c47e70ab3 100644 --- a/tests/baselines/reference/augmentedTypesInterface.errors.txt +++ b/tests/baselines/reference/augmentedTypesInterface.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/augmentedTypesInterface.ts(12,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/augmentedTypesInterface.ts(16,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesInterface.ts(12,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesInterface.ts(16,7): error TS2511: Only an ambient class can be merged with an interface. tests/cases/compiler/augmentedTypesInterface.ts(23,11): error TS2300: Duplicate identifier 'i3'. tests/cases/compiler/augmentedTypesInterface.ts(26,6): error TS2300: Duplicate identifier 'i3'. @@ -18,13 +18,13 @@ tests/cases/compiler/augmentedTypesInterface.ts(26,6): error TS2300: Duplicate i // interface then class interface i2 { // error ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. foo(): void; } class i2 { // error ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. bar() { return 1; } diff --git a/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt b/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt index 170ff29226b..b2b59c29009 100644 --- a/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt +++ b/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt @@ -1,29 +1,29 @@ -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,7): error TS2511: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,11): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,11): error TS2511: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,15): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(5,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(5,11): error TS2511: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(6,9): error TS2300: Duplicate identifier 'bar'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(9,15): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(9,15): error TS2511: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(10,9): error TS2300: Duplicate identifier 'bar'. ==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts (8 errors) ==== class C { foo: string; } ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. ~~~ !!! error TS2300: Duplicate identifier 'foo'. interface C { foo: string; } // error ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. ~~~ !!! error TS2300: Duplicate identifier 'foo'. module M { class D { ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. bar: string; ~~~ !!! error TS2300: Duplicate identifier 'bar'. @@ -31,7 +31,7 @@ tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName. interface D { // error ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. bar: string; ~~~ !!! error TS2300: Duplicate identifier 'bar'. diff --git a/tests/baselines/reference/clinterfaces.errors.txt b/tests/baselines/reference/clinterfaces.errors.txt index 1d5ecd136f0..8d48f29aed7 100644 --- a/tests/baselines/reference/clinterfaces.errors.txt +++ b/tests/baselines/reference/clinterfaces.errors.txt @@ -1,50 +1,50 @@ -tests/cases/compiler/clinterfaces.ts(2,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(3,15): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(4,15): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(5,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(8,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(12,7): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(16,7): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(20,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(2,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(3,15): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(4,15): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(5,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(8,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(12,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(16,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(20,11): error TS2511: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/clinterfaces.ts (8 errors) ==== module M { class C { } ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface C { } ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface D { } ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. class D { } ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. } interface Foo { ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. a: string; } class Foo{ ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. b: number; } class Bar{ ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. b: number; } interface Bar { ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. a: string; } diff --git a/tests/baselines/reference/declInput.errors.txt b/tests/baselines/reference/declInput.errors.txt index 4e12c802bee..76257de6ea9 100644 --- a/tests/baselines/reference/declInput.errors.txt +++ b/tests/baselines/reference/declInput.errors.txt @@ -1,17 +1,17 @@ -tests/cases/compiler/declInput.ts(1,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/declInput.ts(5,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/declInput.ts(1,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/declInput.ts(5,7): error TS2511: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/declInput.ts (2 errors) ==== interface bar { ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. } class bar { ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. public f() { return ''; } public g() { return {a: null, b: undefined, c: void 4 }; } public h(x = 4, y = null, z = '') { x++; } diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt index f8b5c559515..67ee1d9cc37 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(2,22): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(5,18): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(2,22): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(5,18): error TS2511: Only an ambient class can be merged with an interface. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(9,21): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(12,18): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(37,12): error TS2300: Duplicate identifier 'x'. @@ -10,12 +10,12 @@ tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(41,16): er module M { export interface I { } ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. } module M { export class I { } // error ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. } module M { diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt index dcb2440aa26..c98e0e9a8c6 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt @@ -1,10 +1,10 @@ -tests/cases/compiler/file1.ts(2,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/file1.ts(3,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/file1.ts(2,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/file1.ts(3,7): error TS2511: Only an ambient class can be merged with an interface. tests/cases/compiler/file1.ts(4,7): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/file1.ts(5,10): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/file1.ts(9,12): error TS2300: Duplicate identifier 'x'. -tests/cases/compiler/file2.ts(1,7): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/file2.ts(2,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/file2.ts(1,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/file2.ts(2,11): error TS2511: Only an ambient class can be merged with an interface. tests/cases/compiler/file2.ts(3,10): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/file2.ts(4,7): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/file2.ts(7,8): error TS2433: A namespace declaration cannot be in a different file from a class or function with which it is merged @@ -15,10 +15,10 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. interface I { } ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. class C1 { } ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. class C2 { } ~~ !!! error TS2300: Duplicate identifier 'C2'. @@ -42,10 +42,10 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. ==== tests/cases/compiler/file2.ts (6 errors) ==== class I { } // error -- cannot merge interface with non-ambient class ~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface C1 { } // error -- cannot merge interface with non-ambient class ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. function C2() { } // error -- cannot merge function with non-ambient class ~~ !!! error TS2300: Duplicate identifier 'C2'. diff --git a/tests/baselines/reference/interfaceDeclaration2.errors.txt b/tests/baselines/reference/interfaceDeclaration2.errors.txt index 2789657a202..1d5807b9b1b 100644 --- a/tests/baselines/reference/interfaceDeclaration2.errors.txt +++ b/tests/baselines/reference/interfaceDeclaration2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/interfaceDeclaration2.ts(4,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/interfaceDeclaration2.ts(4,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2511: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/interfaceDeclaration2.ts (2 errors) ==== @@ -8,10 +8,10 @@ tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2506: Only an ambien interface I2 { } ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. class I2 { } ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface I3 { } function I3() { } diff --git a/tests/baselines/reference/mergedClassInterface.errors.txt b/tests/baselines/reference/mergedClassInterface.errors.txt index 6177b5fa871..37bd595c0b7 100644 --- a/tests/baselines/reference/mergedClassInterface.errors.txt +++ b/tests/baselines/reference/mergedClassInterface.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/classes/classDeclarations/file1.ts(11,7): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/file1.ts(13,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/file1.ts(15,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(11,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(13,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(15,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2511: Only an ambient class can be merged with an interface. ==== tests/cases/conformance/classes/classDeclarations/file1.ts (4 errors) ==== @@ -17,19 +17,19 @@ tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2506: class C3 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface C3 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface C4 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. class C4 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface C5 { x1: number; diff --git a/tests/baselines/reference/nameCollisions.errors.txt b/tests/baselines/reference/nameCollisions.errors.txt index bc7ec752573..2aba1c43f86 100644 --- a/tests/baselines/reference/nameCollisions.errors.txt +++ b/tests/baselines/reference/nameCollisions.errors.txt @@ -11,10 +11,10 @@ tests/cases/compiler/nameCollisions.ts(33,11): error TS2300: Duplicate identifie tests/cases/compiler/nameCollisions.ts(34,14): error TS2300: Duplicate identifier 'C'. tests/cases/compiler/nameCollisions.ts(36,14): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/nameCollisions.ts(37,11): error TS2300: Duplicate identifier 'C2'. -tests/cases/compiler/nameCollisions.ts(42,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/nameCollisions.ts(43,15): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/nameCollisions.ts(45,15): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/nameCollisions.ts(46,11): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(42,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(43,15): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(45,15): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(46,11): error TS2511: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/nameCollisions.ts (17 errors) ==== @@ -87,15 +87,15 @@ tests/cases/compiler/nameCollisions.ts(46,11): error TS2506: Only an ambient cla class cli { } ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface cli { } // error ~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. interface cli2 { } ~~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. class cli2 { } // error ~~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. } \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt index aabebad0552..a51eb18d98e 100644 --- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt @@ -1,5 +1,4 @@ -lib.d.ts(521,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(2,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(2,7): error TS2511: Only an ambient class can be merged with an interface. tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. @@ -8,7 +7,7 @@ tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2 class TemplateStringsArray { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. } function f(x: TemplateStringsArray, y: number, z: number) { diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt index 8b1c5fbe0e2..d41c3d0cdbf 100644 --- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt @@ -1,5 +1,4 @@ -lib.d.ts(521,11): error TS2506: Only an ambient class can be merged with an interface. -tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(2,7): error TS2506: Only an ambient class can be merged with an interface. +tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(2,7): error TS2511: Only an ambient class can be merged with an interface. tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. @@ -8,7 +7,7 @@ tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error T class TemplateStringsArray { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2506: Only an ambient class can be merged with an interface. +!!! error TS2511: Only an ambient class can be merged with an interface. } function f(x: TemplateStringsArray, y: number, z: number) { From 851c7e4bf9d2fb270a209a8a6defd3c5c9846932 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 12:35:06 -0700 Subject: [PATCH 117/309] fixed comment, spacing --- src/compiler/binder.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index f1d8b141a10..07279e93b55 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -176,7 +176,7 @@ namespace ts { /** * Declares a Symbol for the node and adds it to symbols. Reports errors for conflicting identifier names. * @param symbolTable - The symbol table which node will be added to. - * @param parent - If node is in a class, parent denotes the parent declaration. + * @param parent - node's parent declaration. * @param node - The declaration to be added to the symbol table * @param includes - The SymbolFlags that node has in addition to its declaration type (eg: export, ambient, etc.) * @param excludes - The flags which node cannot be declared alongside in a symbol table. Used to report forbidden declarations. @@ -211,11 +211,11 @@ namespace ts { symbol = hasProperty(symbolTable, name) ? symbolTable[name] : (symbolTable[name] = createSymbol(SymbolFlags.None, name)); - + if (name && (includes & SymbolFlags.Classifiable)) { - classifiableNames[name] = name; + classifiableNames[name] = name; } - + if (symbol.flags & excludes) { if (node.name) { node.name.parent = node; From 23603a39b82abd9ce33a83f54345981c3471f370 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 18 Jun 2015 13:54:08 -0700 Subject: [PATCH 118/309] Defer checking of class expression bodies --- src/compiler/checker.ts | 67 ++++++++++++------- .../diagnosticInformationMap.generated.ts | 2 - src/compiler/diagnosticMessages.json | 9 --- src/compiler/utilities.ts | 13 ---- 4 files changed, 42 insertions(+), 49 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 76bc4e9a94e..4891bff8630 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -409,6 +409,13 @@ namespace ts { } break loop; } + if (location.kind === SyntaxKind.ClassExpression && meaning & SymbolFlags.Class) { + let className = (location).name; + if (className && name === className.text) { + result = location.symbol; + break loop; + } + } break; // It is not legal to reference a class's own type parameters from a computed property name that @@ -455,15 +462,6 @@ namespace ts { } } break; - case SyntaxKind.ClassExpression: - if (meaning & SymbolFlags.Class) { - let className = (location).name; - if (className && name === className.text) { - result = location.symbol; - break loop; - } - } - break; case SyntaxKind.Decorator: // Decorators are resolved at the class declaration. Resolving at the parameter // or member would result in looking up locals in the method. @@ -1397,13 +1395,30 @@ namespace ts { // This is for caching the result of getSymbolDisplayBuilder. Do not access directly. let _displayBuilder: SymbolDisplayBuilder; function getSymbolDisplayBuilder(): SymbolDisplayBuilder { + + function getNameOfSymbol(symbol: Symbol): string { + if (symbol.declarations && symbol.declarations.length) { + let declaration = symbol.declarations[0]; + if (declaration.name) { + return declarationNameToString(declaration.name); + } + switch (declaration.kind) { + case SyntaxKind.ClassExpression: + return "(Anonymous class)"; + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + return "(Anonymous function)"; + } + } + return symbol.name; + } + /** * Writes only the name of the symbol out to the writer. Uses the original source text * for the name of the symbol if it is available to match how the user inputted the name. */ function appendSymbolNameOnly(symbol: Symbol, writer: SymbolWriter): void { - let name = symbol.declarations && symbol.declarations.length > 0 ? declarationToString(symbol.declarations[0]) : symbol.name; - writer.writeSymbol(name, symbol); + writer.writeSymbol(getNameOfSymbol(symbol), symbol); } /** @@ -7851,7 +7866,7 @@ namespace ts { if (node.type) { checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, /*headMessage*/ undefined); } - checkFunctionExpressionBodies(node.body); + checkFunctionAndClassExpressionBodies(node.body); } } } @@ -9567,7 +9582,7 @@ namespace ts { forEach(node.statements, checkSourceElement); if (isFunctionBlock(node) || node.kind === SyntaxKind.ModuleBlock) { - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); } } @@ -10563,11 +10578,11 @@ namespace ts { } function checkClassDeclaration(node: ClassDeclaration) { - // Grammar checking if (!node.name && !(node.flags & NodeFlags.Default)) { grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } checkClassLikeDeclaration(node); + forEach(node.members, checkSourceElement); } function checkClassLikeDeclaration(node: ClassLikeDeclaration) { @@ -10638,7 +10653,6 @@ namespace ts { }); } - forEach(node.members, checkSourceElement); if (produceDiagnostics) { checkIndexConstraints(type); checkTypeForDuplicateIndexSignatures(node); @@ -11511,8 +11525,8 @@ namespace ts { } } - // Function expression bodies are checked after all statements in the enclosing body. This is to ensure - // constructs like the following are permitted: + // Function and class expression bodies are checked after all statements in the enclosing body. This is + // to ensure constructs like the following are permitted: // let foo = function () { // let s = foo(); // return "hello"; @@ -11520,17 +11534,20 @@ namespace ts { // Here, performing a full type check of the body of the function expression whilst in the process of // determining the type of foo would cause foo to be given type any because of the recursive reference. // Delaying the type check of the body ensures foo has been assigned a type. - function checkFunctionExpressionBodies(node: Node): void { + function checkFunctionAndClassExpressionBodies(node: Node): void { switch (node.kind) { case SyntaxKind.FunctionExpression: case SyntaxKind.ArrowFunction: - forEach((node).parameters, checkFunctionExpressionBodies); + forEach((node).parameters, checkFunctionAndClassExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; + case SyntaxKind.ClassExpression: + forEach((node).members, checkSourceElement); + break; case SyntaxKind.MethodDeclaration: case SyntaxKind.MethodSignature: - forEach(node.decorators, checkFunctionExpressionBodies); - forEach((node).parameters, checkFunctionExpressionBodies); + forEach(node.decorators, checkFunctionAndClassExpressionBodies); + forEach((node).parameters, checkFunctionAndClassExpressionBodies); if (isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } @@ -11539,10 +11556,10 @@ namespace ts { case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: case SyntaxKind.FunctionDeclaration: - forEach((node).parameters, checkFunctionExpressionBodies); + forEach((node).parameters, checkFunctionAndClassExpressionBodies); break; case SyntaxKind.WithStatement: - checkFunctionExpressionBodies((node).expression); + checkFunctionAndClassExpressionBodies((node).expression); break; case SyntaxKind.Decorator: case SyntaxKind.Parameter: @@ -11599,7 +11616,7 @@ namespace ts { case SyntaxKind.EnumMember: case SyntaxKind.ExportAssignment: case SyntaxKind.SourceFile: - forEachChild(node, checkFunctionExpressionBodies); + forEachChild(node, checkFunctionAndClassExpressionBodies); break; } } @@ -11631,7 +11648,7 @@ namespace ts { potentialThisCollisions.length = 0; forEach(node.statements, checkSourceElement); - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); if (isExternalModule(node)) { checkExternalModuleExports(node); diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 09b009711fe..bfe103757c5 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -567,7 +567,5 @@ namespace ts { enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." }, type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." }, decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, - Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, - class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." }, }; } \ No newline at end of file diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index fee46a84c1e..3e4ef26507f 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2259,14 +2259,5 @@ "'decorators' can only be used in a .ts file.": { "category": "Error", "code": 8017 - }, - - "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.": { - "category": "Error", - "code": 9002 - }, - "'class' expressions are not currently supported.": { - "category": "Error", - "code": 9003 } } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index f50f280d861..c820c588689 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -247,19 +247,6 @@ namespace ts { declaration.parent.kind === SyntaxKind.CatchClause; } - export function declarationToString(declaration: Declaration) { - if (!declaration.name) { - switch (declaration.kind) { - case SyntaxKind.ClassExpression: - return "(Anonymous class)"; - case SyntaxKind.FunctionExpression: - case SyntaxKind.ArrowFunction: - return "(Anonymous function)"; - } - } - return declarationNameToString(declaration.name); - } - // Return display name of an identifier // Computed property names will just be emitted as "[]", where is the source // text of the expression in the computed property. From b518dc1e5b3126390d14a34236748c6ba6778502 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 18 Jun 2015 13:56:21 -0700 Subject: [PATCH 119/309] Accepting new baselines --- .../anonymousClassExpression1.errors.txt | 9 ----- .../anonymousClassExpression1.symbols | 6 +++ .../reference/anonymousClassExpression1.types | 10 +++++ .../reference/classExpression.errors.txt | 24 ----------- .../reference/classExpression.symbols | 23 +++++++++++ .../baselines/reference/classExpression.types | 27 +++++++++++++ .../reference/classExpression1.errors.txt | 7 ---- .../reference/classExpression1.symbols | 5 +++ .../reference/classExpression1.types | 6 +++ .../reference/classExpression2.errors.txt | 8 ---- tests/baselines/reference/classExpression2.js | 5 +++ .../reference/classExpression2.symbols | 9 +++++ .../reference/classExpression2.types | 10 +++++ .../reference/classExpressionES61.errors.txt | 7 ---- .../reference/classExpressionES61.symbols | 5 +++ .../reference/classExpressionES61.types | 6 +++ .../reference/classExpressionES62.errors.txt | 8 ---- .../reference/classExpressionES62.symbols | 9 +++++ .../reference/classExpressionES62.types | 10 +++++ .../reference/classExpressionTest2.errors.txt | 21 ---------- .../reference/classExpressionTest2.symbols | 36 +++++++++++++++++ .../reference/classExpressionTest2.types | 40 +++++++++++++++++++ ...solutionOfNamespaceOfSameName01.errors.txt | 14 ------- ...hResolutionOfNamespaceOfSameName01.symbols | 18 +++++++++ ...ithResolutionOfNamespaceOfSameName01.types | 19 +++++++++ ...ExpressionWithStaticProperties1.errors.txt | 7 ---- ...assExpressionWithStaticProperties1.symbols | 7 ++++ ...classExpressionWithStaticProperties1.types | 10 +++++ ...ExpressionWithStaticProperties2.errors.txt | 7 ---- ...assExpressionWithStaticProperties2.symbols | 7 ++++ ...classExpressionWithStaticProperties2.types | 9 +++++ ...ressionWithStaticPropertiesES61.errors.txt | 7 ---- ...ExpressionWithStaticPropertiesES61.symbols | 7 ++++ ...ssExpressionWithStaticPropertiesES61.types | 10 +++++ ...ressionWithStaticPropertiesES62.errors.txt | 7 ---- ...ExpressionWithStaticPropertiesES62.symbols | 7 ++++ ...ssExpressionWithStaticPropertiesES62.types | 9 +++++ .../exportAssignNonIdentifier.errors.txt | 5 +-- .../reference/generatorTypeCheck55.errors.txt | 11 +++-- .../reference/generatorTypeCheck56.errors.txt | 5 +-- .../strictModeReservedWord.errors.txt | 6 +-- .../reference/strictModeReservedWord.js | 5 +++ 42 files changed, 327 insertions(+), 141 deletions(-) delete mode 100644 tests/baselines/reference/anonymousClassExpression1.errors.txt create mode 100644 tests/baselines/reference/anonymousClassExpression1.symbols create mode 100644 tests/baselines/reference/anonymousClassExpression1.types delete mode 100644 tests/baselines/reference/classExpression.errors.txt create mode 100644 tests/baselines/reference/classExpression.symbols create mode 100644 tests/baselines/reference/classExpression.types delete mode 100644 tests/baselines/reference/classExpression1.errors.txt create mode 100644 tests/baselines/reference/classExpression1.symbols create mode 100644 tests/baselines/reference/classExpression1.types delete mode 100644 tests/baselines/reference/classExpression2.errors.txt create mode 100644 tests/baselines/reference/classExpression2.symbols create mode 100644 tests/baselines/reference/classExpression2.types delete mode 100644 tests/baselines/reference/classExpressionES61.errors.txt create mode 100644 tests/baselines/reference/classExpressionES61.symbols create mode 100644 tests/baselines/reference/classExpressionES61.types delete mode 100644 tests/baselines/reference/classExpressionES62.errors.txt create mode 100644 tests/baselines/reference/classExpressionES62.symbols create mode 100644 tests/baselines/reference/classExpressionES62.types delete mode 100644 tests/baselines/reference/classExpressionTest2.errors.txt create mode 100644 tests/baselines/reference/classExpressionTest2.symbols create mode 100644 tests/baselines/reference/classExpressionTest2.types delete mode 100644 tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.errors.txt create mode 100644 tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols create mode 100644 tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.types delete mode 100644 tests/baselines/reference/classExpressionWithStaticProperties1.errors.txt create mode 100644 tests/baselines/reference/classExpressionWithStaticProperties1.symbols create mode 100644 tests/baselines/reference/classExpressionWithStaticProperties1.types delete mode 100644 tests/baselines/reference/classExpressionWithStaticProperties2.errors.txt create mode 100644 tests/baselines/reference/classExpressionWithStaticProperties2.symbols create mode 100644 tests/baselines/reference/classExpressionWithStaticProperties2.types delete mode 100644 tests/baselines/reference/classExpressionWithStaticPropertiesES61.errors.txt create mode 100644 tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols create mode 100644 tests/baselines/reference/classExpressionWithStaticPropertiesES61.types delete mode 100644 tests/baselines/reference/classExpressionWithStaticPropertiesES62.errors.txt create mode 100644 tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols create mode 100644 tests/baselines/reference/classExpressionWithStaticPropertiesES62.types diff --git a/tests/baselines/reference/anonymousClassExpression1.errors.txt b/tests/baselines/reference/anonymousClassExpression1.errors.txt deleted file mode 100644 index db4c5b4ce3d..00000000000 --- a/tests/baselines/reference/anonymousClassExpression1.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/compiler/anonymousClassExpression1.ts(2,19): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/compiler/anonymousClassExpression1.ts (1 errors) ==== - function f() { - return typeof class {} === "function"; - ~~~~~ -!!! error TS9003: 'class' expressions are not currently supported. - } \ No newline at end of file diff --git a/tests/baselines/reference/anonymousClassExpression1.symbols b/tests/baselines/reference/anonymousClassExpression1.symbols new file mode 100644 index 00000000000..114bfc96097 --- /dev/null +++ b/tests/baselines/reference/anonymousClassExpression1.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/anonymousClassExpression1.ts === +function f() { +>f : Symbol(f, Decl(anonymousClassExpression1.ts, 0, 0)) + + return typeof class {} === "function"; +} diff --git a/tests/baselines/reference/anonymousClassExpression1.types b/tests/baselines/reference/anonymousClassExpression1.types new file mode 100644 index 00000000000..1e38399f01e --- /dev/null +++ b/tests/baselines/reference/anonymousClassExpression1.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/anonymousClassExpression1.ts === +function f() { +>f : () => boolean + + return typeof class {} === "function"; +>typeof class {} === "function" : boolean +>typeof class {} : string +>class {} : typeof (Anonymous class) +>"function" : string +} diff --git a/tests/baselines/reference/classExpression.errors.txt b/tests/baselines/reference/classExpression.errors.txt deleted file mode 100644 index c8266d0e879..00000000000 --- a/tests/baselines/reference/classExpression.errors.txt +++ /dev/null @@ -1,24 +0,0 @@ -tests/cases/conformance/classes/classExpression.ts(1,15): error TS9003: 'class' expressions are not currently supported. -tests/cases/conformance/classes/classExpression.ts(5,16): error TS9003: 'class' expressions are not currently supported. -tests/cases/conformance/classes/classExpression.ts(10,19): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/conformance/classes/classExpression.ts (3 errors) ==== - var x = class C { - ~ -!!! error TS9003: 'class' expressions are not currently supported. - } - - var y = { - foo: class C2 { - ~~ -!!! error TS9003: 'class' expressions are not currently supported. - } - } - - module M { - var z = class C4 { - ~~ -!!! error TS9003: 'class' expressions are not currently supported. - } - } \ No newline at end of file diff --git a/tests/baselines/reference/classExpression.symbols b/tests/baselines/reference/classExpression.symbols new file mode 100644 index 00000000000..f4d44236499 --- /dev/null +++ b/tests/baselines/reference/classExpression.symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/classes/classExpression.ts === +var x = class C { +>x : Symbol(x, Decl(classExpression.ts, 0, 3)) +>C : Symbol(C, Decl(classExpression.ts, 0, 7)) +} + +var y = { +>y : Symbol(y, Decl(classExpression.ts, 3, 3)) + + foo: class C2 { +>foo : Symbol(foo, Decl(classExpression.ts, 3, 9)) +>C2 : Symbol(C2, Decl(classExpression.ts, 4, 8)) + } +} + +module M { +>M : Symbol(M, Decl(classExpression.ts, 6, 1)) + + var z = class C4 { +>z : Symbol(z, Decl(classExpression.ts, 9, 7)) +>C4 : Symbol(C4, Decl(classExpression.ts, 9, 11)) + } +} diff --git a/tests/baselines/reference/classExpression.types b/tests/baselines/reference/classExpression.types new file mode 100644 index 00000000000..1c55ce89544 --- /dev/null +++ b/tests/baselines/reference/classExpression.types @@ -0,0 +1,27 @@ +=== tests/cases/conformance/classes/classExpression.ts === +var x = class C { +>x : typeof C +>class C {} : typeof C +>C : typeof C +} + +var y = { +>y : { foo: typeof C2; } +>{ foo: class C2 { }} : { foo: typeof C2; } + + foo: class C2 { +>foo : typeof C2 +>class C2 { } : typeof C2 +>C2 : typeof C2 + } +} + +module M { +>M : typeof M + + var z = class C4 { +>z : typeof C4 +>class C4 { } : typeof C4 +>C4 : typeof C4 + } +} diff --git a/tests/baselines/reference/classExpression1.errors.txt b/tests/baselines/reference/classExpression1.errors.txt deleted file mode 100644 index 9d7d14d8571..00000000000 --- a/tests/baselines/reference/classExpression1.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/conformance/classes/classExpressions/classExpression1.ts(1,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/conformance/classes/classExpressions/classExpression1.ts (1 errors) ==== - var v = class C {}; - ~ -!!! error TS9003: 'class' expressions are not currently supported. \ No newline at end of file diff --git a/tests/baselines/reference/classExpression1.symbols b/tests/baselines/reference/classExpression1.symbols new file mode 100644 index 00000000000..8d3bad269b4 --- /dev/null +++ b/tests/baselines/reference/classExpression1.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/classes/classExpressions/classExpression1.ts === +var v = class C {}; +>v : Symbol(v, Decl(classExpression1.ts, 0, 3)) +>C : Symbol(C, Decl(classExpression1.ts, 0, 7)) + diff --git a/tests/baselines/reference/classExpression1.types b/tests/baselines/reference/classExpression1.types new file mode 100644 index 00000000000..4bea3183118 --- /dev/null +++ b/tests/baselines/reference/classExpression1.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/classes/classExpressions/classExpression1.ts === +var v = class C {}; +>v : typeof C +>class C {} : typeof C +>C : typeof C + diff --git a/tests/baselines/reference/classExpression2.errors.txt b/tests/baselines/reference/classExpression2.errors.txt deleted file mode 100644 index e2f3ccd77cd..00000000000 --- a/tests/baselines/reference/classExpression2.errors.txt +++ /dev/null @@ -1,8 +0,0 @@ -tests/cases/conformance/classes/classExpressions/classExpression2.ts(2,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/conformance/classes/classExpressions/classExpression2.ts (1 errors) ==== - class D { } - var v = class C extends D {}; - ~ -!!! error TS9003: 'class' expressions are not currently supported. \ No newline at end of file diff --git a/tests/baselines/reference/classExpression2.js b/tests/baselines/reference/classExpression2.js index 4220b88fb11..f74bb8bd5e2 100644 --- a/tests/baselines/reference/classExpression2.js +++ b/tests/baselines/reference/classExpression2.js @@ -3,6 +3,11 @@ class D { } var v = class C extends D {}; //// [classExpression2.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; var D = (function () { function D() { } diff --git a/tests/baselines/reference/classExpression2.symbols b/tests/baselines/reference/classExpression2.symbols new file mode 100644 index 00000000000..11c78a2cad2 --- /dev/null +++ b/tests/baselines/reference/classExpression2.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/classes/classExpressions/classExpression2.ts === +class D { } +>D : Symbol(D, Decl(classExpression2.ts, 0, 0)) + +var v = class C extends D {}; +>v : Symbol(v, Decl(classExpression2.ts, 1, 3)) +>C : Symbol(C, Decl(classExpression2.ts, 1, 7)) +>D : Symbol(D, Decl(classExpression2.ts, 0, 0)) + diff --git a/tests/baselines/reference/classExpression2.types b/tests/baselines/reference/classExpression2.types new file mode 100644 index 00000000000..4dd6595fb49 --- /dev/null +++ b/tests/baselines/reference/classExpression2.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/classes/classExpressions/classExpression2.ts === +class D { } +>D : D + +var v = class C extends D {}; +>v : typeof C +>class C extends D {} : typeof C +>C : typeof C +>D : D + diff --git a/tests/baselines/reference/classExpressionES61.errors.txt b/tests/baselines/reference/classExpressionES61.errors.txt deleted file mode 100644 index abaa5ab893c..00000000000 --- a/tests/baselines/reference/classExpressionES61.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/conformance/es6/classExpressions/classExpressionES61.ts(1,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/conformance/es6/classExpressions/classExpressionES61.ts (1 errors) ==== - var v = class C {}; - ~ -!!! error TS9003: 'class' expressions are not currently supported. \ No newline at end of file diff --git a/tests/baselines/reference/classExpressionES61.symbols b/tests/baselines/reference/classExpressionES61.symbols new file mode 100644 index 00000000000..1f49229fbc7 --- /dev/null +++ b/tests/baselines/reference/classExpressionES61.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/classExpressions/classExpressionES61.ts === +var v = class C {}; +>v : Symbol(v, Decl(classExpressionES61.ts, 0, 3)) +>C : Symbol(C, Decl(classExpressionES61.ts, 0, 7)) + diff --git a/tests/baselines/reference/classExpressionES61.types b/tests/baselines/reference/classExpressionES61.types new file mode 100644 index 00000000000..e04570308e8 --- /dev/null +++ b/tests/baselines/reference/classExpressionES61.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/classExpressions/classExpressionES61.ts === +var v = class C {}; +>v : typeof C +>class C {} : typeof C +>C : typeof C + diff --git a/tests/baselines/reference/classExpressionES62.errors.txt b/tests/baselines/reference/classExpressionES62.errors.txt deleted file mode 100644 index 1e28367a17e..00000000000 --- a/tests/baselines/reference/classExpressionES62.errors.txt +++ /dev/null @@ -1,8 +0,0 @@ -tests/cases/conformance/es6/classExpressions/classExpressionES62.ts(2,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/conformance/es6/classExpressions/classExpressionES62.ts (1 errors) ==== - class D { } - var v = class C extends D {}; - ~ -!!! error TS9003: 'class' expressions are not currently supported. \ No newline at end of file diff --git a/tests/baselines/reference/classExpressionES62.symbols b/tests/baselines/reference/classExpressionES62.symbols new file mode 100644 index 00000000000..18e1a48ca30 --- /dev/null +++ b/tests/baselines/reference/classExpressionES62.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/es6/classExpressions/classExpressionES62.ts === +class D { } +>D : Symbol(D, Decl(classExpressionES62.ts, 0, 0)) + +var v = class C extends D {}; +>v : Symbol(v, Decl(classExpressionES62.ts, 1, 3)) +>C : Symbol(C, Decl(classExpressionES62.ts, 1, 7)) +>D : Symbol(D, Decl(classExpressionES62.ts, 0, 0)) + diff --git a/tests/baselines/reference/classExpressionES62.types b/tests/baselines/reference/classExpressionES62.types new file mode 100644 index 00000000000..8bb4e1a39ff --- /dev/null +++ b/tests/baselines/reference/classExpressionES62.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/classExpressions/classExpressionES62.ts === +class D { } +>D : D + +var v = class C extends D {}; +>v : typeof C +>class C extends D {} : typeof C +>C : typeof C +>D : D + diff --git a/tests/baselines/reference/classExpressionTest2.errors.txt b/tests/baselines/reference/classExpressionTest2.errors.txt deleted file mode 100644 index 424eb590611..00000000000 --- a/tests/baselines/reference/classExpressionTest2.errors.txt +++ /dev/null @@ -1,21 +0,0 @@ -tests/cases/compiler/classExpressionTest2.ts(2,19): error TS9003: 'class' expressions are not currently supported. -tests/cases/compiler/classExpressionTest2.ts(5,20): error TS2304: Cannot find name 'X'. - - -==== tests/cases/compiler/classExpressionTest2.ts (2 errors) ==== - function M() { - var m = class C { - ~ -!!! error TS9003: 'class' expressions are not currently supported. - f() { - var t: T; - var x: X; - ~ -!!! error TS2304: Cannot find name 'X'. - return { t, x }; - } - } - - var v = new m(); - return v.f(); - } \ No newline at end of file diff --git a/tests/baselines/reference/classExpressionTest2.symbols b/tests/baselines/reference/classExpressionTest2.symbols new file mode 100644 index 00000000000..62143cf0b9f --- /dev/null +++ b/tests/baselines/reference/classExpressionTest2.symbols @@ -0,0 +1,36 @@ +=== tests/cases/compiler/classExpressionTest2.ts === +function M() { +>M : Symbol(M, Decl(classExpressionTest2.ts, 0, 0)) + + var m = class C { +>m : Symbol(m, Decl(classExpressionTest2.ts, 1, 7)) +>C : Symbol(C, Decl(classExpressionTest2.ts, 1, 11)) +>X : Symbol(X, Decl(classExpressionTest2.ts, 1, 20)) + + f() { +>f : Symbol(C.f, Decl(classExpressionTest2.ts, 1, 24)) +>T : Symbol(T, Decl(classExpressionTest2.ts, 2, 10)) + + var t: T; +>t : Symbol(t, Decl(classExpressionTest2.ts, 3, 15)) +>T : Symbol(T, Decl(classExpressionTest2.ts, 2, 10)) + + var x: X; +>x : Symbol(x, Decl(classExpressionTest2.ts, 4, 15)) +>X : Symbol(X, Decl(classExpressionTest2.ts, 1, 20)) + + return { t, x }; +>t : Symbol(t, Decl(classExpressionTest2.ts, 5, 20)) +>x : Symbol(x, Decl(classExpressionTest2.ts, 5, 23)) + } + } + + var v = new m(); +>v : Symbol(v, Decl(classExpressionTest2.ts, 9, 7)) +>m : Symbol(m, Decl(classExpressionTest2.ts, 1, 7)) + + return v.f(); +>v.f : Symbol(C.f, Decl(classExpressionTest2.ts, 1, 24)) +>v : Symbol(v, Decl(classExpressionTest2.ts, 9, 7)) +>f : Symbol(C.f, Decl(classExpressionTest2.ts, 1, 24)) +} diff --git a/tests/baselines/reference/classExpressionTest2.types b/tests/baselines/reference/classExpressionTest2.types new file mode 100644 index 00000000000..5586b451d3a --- /dev/null +++ b/tests/baselines/reference/classExpressionTest2.types @@ -0,0 +1,40 @@ +=== tests/cases/compiler/classExpressionTest2.ts === +function M() { +>M : () => { t: string; x: number; } + + var m = class C { +>m : typeof C +>class C { f() { var t: T; var x: X; return { t, x }; } } : typeof C +>C : typeof C +>X : X + + f() { +>f : () => { t: T; x: X; } +>T : T + + var t: T; +>t : T +>T : T + + var x: X; +>x : X +>X : X + + return { t, x }; +>{ t, x } : { t: T; x: X; } +>t : T +>x : X + } + } + + var v = new m(); +>v : +>new m() : +>m : typeof C + + return v.f(); +>v.f() : { t: string; x: number; } +>v.f : () => { t: T; x: number; } +>v : +>f : () => { t: T; x: number; } +} diff --git a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.errors.txt b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.errors.txt deleted file mode 100644 index 8edc1d8f74b..00000000000 --- a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.errors.txt +++ /dev/null @@ -1,14 +0,0 @@ -tests/cases/compiler/classExpressionWithResolutionOfNamespaceOfSameName01.ts(6,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/compiler/classExpressionWithResolutionOfNamespaceOfSameName01.ts (1 errors) ==== - namespace C { - export interface type { - } - } - - var x = class C { - ~ -!!! error TS9003: 'class' expressions are not currently supported. - prop: C.type; - } \ No newline at end of file diff --git a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols new file mode 100644 index 00000000000..fcd4f0388db --- /dev/null +++ b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/classExpressionWithResolutionOfNamespaceOfSameName01.ts === +namespace C { +>C : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 0, 0)) + + export interface type { +>type : Symbol(type, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 0, 13)) + } +} + +var x = class C { +>x : Symbol(x, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 3)) +>C : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 7)) + + prop: C.type; +>prop : Symbol(C.prop, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 5, 17)) +>C : Symbol(C, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 0, 0)) +>type : Symbol(C.type, Decl(classExpressionWithResolutionOfNamespaceOfSameName01.ts, 0, 13)) +} diff --git a/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.types b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.types new file mode 100644 index 00000000000..643cf65d2e0 --- /dev/null +++ b/tests/baselines/reference/classExpressionWithResolutionOfNamespaceOfSameName01.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/classExpressionWithResolutionOfNamespaceOfSameName01.ts === +namespace C { +>C : any + + export interface type { +>type : type + } +} + +var x = class C { +>x : typeof C +>class C { prop: C.type;} : typeof C +>C : typeof C + + prop: C.type; +>prop : C.type +>C : any +>type : C.type +} diff --git a/tests/baselines/reference/classExpressionWithStaticProperties1.errors.txt b/tests/baselines/reference/classExpressionWithStaticProperties1.errors.txt deleted file mode 100644 index 28e42dd33f1..00000000000 --- a/tests/baselines/reference/classExpressionWithStaticProperties1.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/compiler/classExpressionWithStaticProperties1.ts(1,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/compiler/classExpressionWithStaticProperties1.ts (1 errors) ==== - var v = class C { static a = 1; static b = 2 }; - ~ -!!! error TS9003: 'class' expressions are not currently supported. \ No newline at end of file diff --git a/tests/baselines/reference/classExpressionWithStaticProperties1.symbols b/tests/baselines/reference/classExpressionWithStaticProperties1.symbols new file mode 100644 index 00000000000..d4c811daebe --- /dev/null +++ b/tests/baselines/reference/classExpressionWithStaticProperties1.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/classExpressionWithStaticProperties1.ts === +var v = class C { static a = 1; static b = 2 }; +>v : Symbol(v, Decl(classExpressionWithStaticProperties1.ts, 0, 3)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties1.ts, 0, 7)) +>a : Symbol(C.a, Decl(classExpressionWithStaticProperties1.ts, 0, 17)) +>b : Symbol(C.b, Decl(classExpressionWithStaticProperties1.ts, 0, 31)) + diff --git a/tests/baselines/reference/classExpressionWithStaticProperties1.types b/tests/baselines/reference/classExpressionWithStaticProperties1.types new file mode 100644 index 00000000000..b014f78abf7 --- /dev/null +++ b/tests/baselines/reference/classExpressionWithStaticProperties1.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/classExpressionWithStaticProperties1.ts === +var v = class C { static a = 1; static b = 2 }; +>v : typeof C +>class C { static a = 1; static b = 2 } : typeof C +>C : typeof C +>a : number +>1 : number +>b : number +>2 : number + diff --git a/tests/baselines/reference/classExpressionWithStaticProperties2.errors.txt b/tests/baselines/reference/classExpressionWithStaticProperties2.errors.txt deleted file mode 100644 index 9a915f70193..00000000000 --- a/tests/baselines/reference/classExpressionWithStaticProperties2.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/compiler/classExpressionWithStaticProperties2.ts(1,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/compiler/classExpressionWithStaticProperties2.ts (1 errors) ==== - var v = class C { static a = 1; static b }; - ~ -!!! error TS9003: 'class' expressions are not currently supported. \ No newline at end of file diff --git a/tests/baselines/reference/classExpressionWithStaticProperties2.symbols b/tests/baselines/reference/classExpressionWithStaticProperties2.symbols new file mode 100644 index 00000000000..480123a1c3b --- /dev/null +++ b/tests/baselines/reference/classExpressionWithStaticProperties2.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/classExpressionWithStaticProperties2.ts === +var v = class C { static a = 1; static b }; +>v : Symbol(v, Decl(classExpressionWithStaticProperties2.ts, 0, 3)) +>C : Symbol(C, Decl(classExpressionWithStaticProperties2.ts, 0, 7)) +>a : Symbol(C.a, Decl(classExpressionWithStaticProperties2.ts, 0, 17)) +>b : Symbol(C.b, Decl(classExpressionWithStaticProperties2.ts, 0, 31)) + diff --git a/tests/baselines/reference/classExpressionWithStaticProperties2.types b/tests/baselines/reference/classExpressionWithStaticProperties2.types new file mode 100644 index 00000000000..9bfd6732350 --- /dev/null +++ b/tests/baselines/reference/classExpressionWithStaticProperties2.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/classExpressionWithStaticProperties2.ts === +var v = class C { static a = 1; static b }; +>v : typeof C +>class C { static a = 1; static b } : typeof C +>C : typeof C +>a : number +>1 : number +>b : any + diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.errors.txt b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.errors.txt deleted file mode 100644 index bc015a3d8f0..00000000000 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts(1,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts (1 errors) ==== - var v = class C { static a = 1; static b = 2 }; - ~ -!!! error TS9003: 'class' expressions are not currently supported. \ No newline at end of file diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols new file mode 100644 index 00000000000..c5f53e19bff --- /dev/null +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts === +var v = class C { static a = 1; static b = 2 }; +>v : Symbol(v, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 3)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 7)) +>a : Symbol(C.a, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 17)) +>b : Symbol(C.b, Decl(classExpressionWithStaticPropertiesES61.ts, 0, 31)) + diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES61.types b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.types new file mode 100644 index 00000000000..02c385b7525 --- /dev/null +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES61.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts === +var v = class C { static a = 1; static b = 2 }; +>v : typeof C +>class C { static a = 1; static b = 2 } : typeof C +>C : typeof C +>a : number +>1 : number +>b : number +>2 : number + diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.errors.txt b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.errors.txt deleted file mode 100644 index bed4b2c01aa..00000000000 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts(1,15): error TS9003: 'class' expressions are not currently supported. - - -==== tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts (1 errors) ==== - var v = class C { static a = 1; static b }; - ~ -!!! error TS9003: 'class' expressions are not currently supported. \ No newline at end of file diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols new file mode 100644 index 00000000000..be57a289f53 --- /dev/null +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts === +var v = class C { static a = 1; static b }; +>v : Symbol(v, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 3)) +>C : Symbol(C, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 7)) +>a : Symbol(C.a, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 17)) +>b : Symbol(C.b, Decl(classExpressionWithStaticPropertiesES62.ts, 0, 31)) + diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES62.types b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.types new file mode 100644 index 00000000000..e8ded1422f1 --- /dev/null +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES62.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts === +var v = class C { static a = 1; static b }; +>v : typeof C +>class C { static a = 1; static b } : typeof C +>C : typeof C +>a : number +>1 : number +>b : any + diff --git a/tests/baselines/reference/exportAssignNonIdentifier.errors.txt b/tests/baselines/reference/exportAssignNonIdentifier.errors.txt index 09e86ec12c4..c3d58c9b36f 100644 --- a/tests/baselines/reference/exportAssignNonIdentifier.errors.txt +++ b/tests/baselines/reference/exportAssignNonIdentifier.errors.txt @@ -1,5 +1,4 @@ tests/cases/conformance/externalModules/foo1.ts(2,1): error TS1148: Cannot compile modules unless the '--module' flag is provided. -tests/cases/conformance/externalModules/foo3.ts(1,16): error TS9003: 'class' expressions are not currently supported. tests/cases/conformance/externalModules/foo6.ts(1,14): error TS1109: Expression expected. @@ -12,10 +11,8 @@ tests/cases/conformance/externalModules/foo6.ts(1,14): error TS1109: Expression ==== tests/cases/conformance/externalModules/foo2.ts (0 errors) ==== export = "sausages"; // Ok -==== tests/cases/conformance/externalModules/foo3.ts (1 errors) ==== +==== tests/cases/conformance/externalModules/foo3.ts (0 errors) ==== export = class Foo3 {}; // Error, not an expression - ~~~~ -!!! error TS9003: 'class' expressions are not currently supported. ==== tests/cases/conformance/externalModules/foo4.ts (0 errors) ==== export = true; // Ok diff --git a/tests/baselines/reference/generatorTypeCheck55.errors.txt b/tests/baselines/reference/generatorTypeCheck55.errors.txt index 0846d1c28ad..854c1801efd 100644 --- a/tests/baselines/reference/generatorTypeCheck55.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck55.errors.txt @@ -1,9 +1,12 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts(2,19): error TS9003: 'class' expressions are not currently supported. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts(2,29): error TS2507: Type 'any' is not a constructor function type. +tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts(2,30): error TS1163: A 'yield' expression is only allowed in a generator body. -==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts (1 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts (2 errors) ==== function* g() { var x = class C extends (yield) {}; - ~ -!!! error TS9003: 'class' expressions are not currently supported. + ~~~~~~~ +!!! error TS2507: Type 'any' is not a constructor function type. + ~~~~~ +!!! error TS1163: A 'yield' expression is only allowed in a generator body. } \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck56.errors.txt b/tests/baselines/reference/generatorTypeCheck56.errors.txt index 99e3b00de41..20961935807 100644 --- a/tests/baselines/reference/generatorTypeCheck56.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck56.errors.txt @@ -1,12 +1,9 @@ -tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts(2,19): error TS9003: 'class' expressions are not currently supported. tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts(3,11): error TS1163: A 'yield' expression is only allowed in a generator body. -==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts (2 errors) ==== +==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts (1 errors) ==== function* g() { var x = class C { - ~ -!!! error TS9003: 'class' expressions are not currently supported. *[yield 0]() { ~~~~~ !!! error TS1163: A 'yield' expression is only allowed in a generator body. diff --git a/tests/baselines/reference/strictModeReservedWord.errors.txt b/tests/baselines/reference/strictModeReservedWord.errors.txt index b6e9161ce7e..6f6a387429d 100644 --- a/tests/baselines/reference/strictModeReservedWord.errors.txt +++ b/tests/baselines/reference/strictModeReservedWord.errors.txt @@ -17,8 +17,8 @@ tests/cases/compiler/strictModeReservedWord.ts(13,11): error TS1212: Identifier tests/cases/compiler/strictModeReservedWord.ts(13,20): error TS1212: Identifier expected. 'public' is a reserved word in strict mode tests/cases/compiler/strictModeReservedWord.ts(13,28): error TS1212: Identifier expected. 'package' is a reserved word in strict mode tests/cases/compiler/strictModeReservedWord.ts(15,25): error TS1213: Identifier expected. 'package' is a reserved word in strict mode. Class definitions are automatically in strict mode. -tests/cases/compiler/strictModeReservedWord.ts(15,25): error TS9003: 'class' expressions are not currently supported. tests/cases/compiler/strictModeReservedWord.ts(15,41): error TS1213: Identifier expected. 'public' is a reserved word in strict mode. Class definitions are automatically in strict mode. +tests/cases/compiler/strictModeReservedWord.ts(15,41): error TS2507: Type 'number' is not a constructor function type. tests/cases/compiler/strictModeReservedWord.ts(17,9): error TS2300: Duplicate identifier 'b'. tests/cases/compiler/strictModeReservedWord.ts(17,12): error TS1212: Identifier expected. 'public' is a reserved word in strict mode tests/cases/compiler/strictModeReservedWord.ts(17,12): error TS2503: Cannot find namespace 'public'. @@ -95,10 +95,10 @@ tests/cases/compiler/strictModeReservedWord.ts(24,5): error TS2349: Cannot invok var myClass = class package extends public {} ~~~~~~~ !!! error TS1213: Identifier expected. 'package' is a reserved word in strict mode. Class definitions are automatically in strict mode. - ~~~~~~~ -!!! error TS9003: 'class' expressions are not currently supported. ~~~~~~ !!! error TS1213: Identifier expected. 'public' is a reserved word in strict mode. Class definitions are automatically in strict mode. + ~~~~~~ +!!! error TS2507: Type 'number' is not a constructor function type. var b: public.bar; ~ diff --git a/tests/baselines/reference/strictModeReservedWord.js b/tests/baselines/reference/strictModeReservedWord.js index 9be21b20ae6..bec159dee6f 100644 --- a/tests/baselines/reference/strictModeReservedWord.js +++ b/tests/baselines/reference/strictModeReservedWord.js @@ -28,6 +28,11 @@ function foo() { //// [strictModeReservedWord.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; var let = 10; function foo() { "use strict"; From 556cb70c1d0de4d450baadf48279b7f0ca3d954e Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:00:36 -0700 Subject: [PATCH 120/309] Utilities + types setup for JSX and As --- src/compiler/core.ts | 4 +- src/compiler/types.ts | 91 +++++++++++++++++++++++++++++++++++++++ src/compiler/utilities.ts | 16 ++++--- 3 files changed, 104 insertions(+), 7 deletions(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index ced477eeeec..7b35c5e0d65 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -702,9 +702,9 @@ namespace ts { /** * List of supported extensions in order of file resolution precedence. */ - export const supportedExtensions = [".ts", ".d.ts"]; + export const supportedExtensions = [".tsx", ".ts", ".d.ts"]; - const extensionsToRemove = [".d.ts", ".ts", ".js"]; + const extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"]; export function removeFileExtension(path: string): string { for (let ext of extensionsToRemove) { if (fileExtensionIs(path, ext)) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index f9a2fa3b7b4..d78d38d5ba7 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -48,6 +48,7 @@ namespace ts { SemicolonToken, CommaToken, LessThanToken, + LessThanSlashToken, GreaterThanToken, LessThanEqualsToken, GreaterThanEqualsToken, @@ -217,6 +218,8 @@ namespace ts { ClassExpression, OmittedExpression, ExpressionWithTypeArguments, + AsExpression, + // Misc TemplateSpan, SemicolonClassElement, @@ -265,6 +268,16 @@ namespace ts { // Module references ExternalModuleReference, + //JSX + JsxElement, + JsxSelfClosingElement, + JsxOpeningElement, + JsxText, + JsxClosingElement, + JsxAttribute, + JsxSpreadAttribute, + JsxExpression, + // Clauses CaseClause, DefaultClause, @@ -396,6 +409,17 @@ namespace ts { HasAggregatedChildData = 1 << 8 } + export const enum JsxFlags { + None = 0, + IntrinsicNamedElement = 1 << 0, + IntrinsicIndexedElement = 1 << 1, + ClassElement = 1 << 2, + UnknownElement = 1 << 3, + + IntrinsicElement = IntrinsicNamedElement | IntrinsicIndexedElement + } + + /* @internal */ export const enum RelationComparisonResult { Succeeded = 1, // Should be truthy @@ -799,11 +823,66 @@ namespace ts { export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression; + export interface AsExpression extends Expression { + expression: Expression; + type: TypeNode; + } + export interface TypeAssertion extends UnaryExpression { type: TypeNode; expression: UnaryExpression; } + export type AssertionExpression = TypeAssertion | AsExpression; + + /// A JSX expression of the form ... + export interface JsxElement extends PrimaryExpression { + openingElement: JsxOpeningElement; + children: NodeArray; + closingElement: JsxClosingElement; + } + + /// The opening element of a ... JsxElement + export interface JsxOpeningElement extends Expression { + _openingElementBrand?: any; + tagName: EntityName; + attributes: NodeArray; + } + + /// A JSX expression of the form + export interface JsxSelfClosingElement extends PrimaryExpression, JsxOpeningElement { + _selfClosingElementBrand?: any; + } + + /// Either the opening tag in a ... pair, or the lone in a self-closing form + export type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement; + + export interface JsxAttribute extends Node { + name: Identifier; + /// JSX attribute initializers are optional; is sugar for + initializer?: Expression; + } + + export interface JsxSpreadAttribute extends Node { + expression: Expression; + } + + export interface JsxClosingElement extends Node { + tagName: EntityName; + } + + export interface JsxExpression extends Expression { + expression?: Expression; + } + + export interface JsxText extends Node { + _jsxTextExpressionBrand: any; + /// Used by the emitter to avoid recomputation + formattedReactText?: string; + } + + export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement; + export interface Statement extends Node { _statementBrand: any; } @@ -1144,6 +1223,7 @@ namespace ts { amdDependencies: {path: string; name: string}[]; moduleName: string; referencedFiles: FileReference[]; + isTSXFile: boolean; /** * lib.d.ts should have a reference comment like @@ -1323,6 +1403,9 @@ namespace ts { getAliasedSymbol(symbol: Symbol): Symbol; getExportsOfModule(moduleSymbol: Symbol): Symbol[]; + getJsxElementAttributesType(elementNode: JsxOpeningLikeElement): Type; + getJsxIntrinsicTagNames(): Symbol[]; + // Should not be called directly. Should only be accessed through the Program instance. /* @internal */ getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; /* @internal */ getGlobalDiagnostics(): Diagnostic[]; @@ -1603,6 +1686,7 @@ namespace ts { assignmentChecks?: Map; // Cache of assignment checks hasReportedStatementInAmbientContext?: boolean; // Cache boolean if we report statements in ambient context importOnRightSide?: Symbol; // for import declarations - import that appear on the right side + jsxFlags?: JsxFlags; // flags for knowning what kind of element/attributes we're dealing with } export const enum TypeFlags { @@ -1834,6 +1918,7 @@ namespace ts { help?: boolean; inlineSourceMap?: boolean; inlineSources?: boolean; + jsx?: JsxEmit; listFiles?: boolean; locale?: string; mapRoot?: string; @@ -1877,6 +1962,12 @@ namespace ts { System = 4, } + export const enum JsxEmit { + None = 0, + Preserve = 1, + React = 2 + } + export const enum NewLineKind { CarriageReturnLineFeed = 0, LineFeed = 1, diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index ee75454ad93..7ec599babbc 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -169,13 +169,13 @@ namespace ts { return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.decorators.end); } - export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node): string { + export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node, includeTrivia = false): string { if (nodeIsMissing(node)) { return ""; } let text = sourceFile.text; - return text.substring(skipTrivia(text, node.pos), node.end); + return text.substring(includeTrivia ? node.pos : skipTrivia(text, node.pos), node.end); } export function getTextOfNodeFromSourceText(sourceText: string, node: Node): string { @@ -186,8 +186,8 @@ namespace ts { return sourceText.substring(skipTrivia(sourceText, node.pos), node.end); } - export function getTextOfNode(node: Node): string { - return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node); + export function getTextOfNode(node: Node, includeTrivia = false): string { + return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia); } // Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' @@ -850,6 +850,7 @@ namespace ts { case SyntaxKind.CallExpression: case SyntaxKind.NewExpression: case SyntaxKind.TaggedTemplateExpression: + case SyntaxKind.AsExpression: case SyntaxKind.TypeAssertionExpression: case SyntaxKind.ParenthesizedExpression: case SyntaxKind.FunctionExpression: @@ -866,6 +867,8 @@ namespace ts { case SyntaxKind.TemplateExpression: case SyntaxKind.NoSubstitutionTemplateLiteral: case SyntaxKind.OmittedExpression: + case SyntaxKind.JsxElement: + case SyntaxKind.JsxSelfClosingElement: case SyntaxKind.YieldExpression: return true; case SyntaxKind.QualifiedName: @@ -912,7 +915,8 @@ namespace ts { return (forInStatement.initializer === node && forInStatement.initializer.kind !== SyntaxKind.VariableDeclarationList) || forInStatement.expression === node; case SyntaxKind.TypeAssertionExpression: - return node === (parent).expression; + case SyntaxKind.AsExpression: + return node === (parent).expression; case SyntaxKind.TemplateSpan: return node === (parent).expression; case SyntaxKind.ComputedPropertyName: @@ -1886,6 +1890,8 @@ namespace ts { case SyntaxKind.ElementAccessExpression: case SyntaxKind.NewExpression: case SyntaxKind.CallExpression: + case SyntaxKind.JsxElement: + case SyntaxKind.JsxSelfClosingElement: case SyntaxKind.TaggedTemplateExpression: case SyntaxKind.ArrayLiteralExpression: case SyntaxKind.ParenthesizedExpression: From a4045e539b4f115f854d3cb3351089e62a59f3f0 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:00:54 -0700 Subject: [PATCH 121/309] Scanner / parser for JSX and As --- src/compiler/parser.ts | 230 +++++++++++++++++++++++++++++++++++++++- src/compiler/scanner.ts | 65 +++++++++++- 2 files changed, 292 insertions(+), 3 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index a507125d4bb..d89ab3a771b 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -162,6 +162,9 @@ namespace ts { return visitNode(cbNode, (node).left) || visitNode(cbNode, (node).operatorToken) || visitNode(cbNode, (node).right); + case SyntaxKind.AsExpression: + return visitNode(cbNode, (node).expression) || + visitNode(cbNode, (node).type); case SyntaxKind.ConditionalExpression: return visitNode(cbNode, (node).condition) || visitNode(cbNode, (node).questionToken) || @@ -319,6 +322,25 @@ namespace ts { return visitNode(cbNode, (node).expression); case SyntaxKind.MissingDeclaration: return visitNodes(cbNodes, node.decorators); + + case SyntaxKind.JsxElement: + return visitNode(cbNode, (node).openingElement) || + visitNodes(cbNodes, (node).children) || + visitNode(cbNode, (node).closingElement); + case SyntaxKind.JsxSelfClosingElement: + case SyntaxKind.JsxOpeningElement: + return visitNode(cbNode, (node).tagName) || + visitNodes(cbNodes, (node).attributes); + case SyntaxKind.JsxAttribute: + return visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).initializer); + case SyntaxKind.JsxSpreadAttribute: + return visitNode(cbNode, (node).expression); + case SyntaxKind.JsxExpression: + return visitNode(cbNode, (node).expression); + case SyntaxKind.JsxClosingElement: + return visitNode(cbNode, (node).tagName); + case SyntaxKind.JSDocTypeExpression: return visitNode(cbNode, (node).type); case SyntaxKind.JSDocUnionType: @@ -634,6 +656,7 @@ namespace ts { sourceFile.languageVersion = languageVersion; sourceFile.fileName = normalizePath(fileName); sourceFile.flags = fileExtensionIs(sourceFile.fileName, ".d.ts") ? NodeFlags.DeclarationFile : 0; + sourceFile.isTSXFile = fileExtensionIs(sourceFile.fileName, ".tsx"); return sourceFile; } @@ -804,6 +827,10 @@ namespace ts { return token = scanner.reScanTemplateToken(); } + function scanJsxIdentifier(): SyntaxKind { + return token = scanner.scanJsxIdentifier(); + } + function speculationHelper(callback: () => T, isLookAhead: boolean): T { // Keep track of the state we'll need to rollback to if lookahead fails (or if the // caller asked us to always reset our state). @@ -1175,6 +1202,10 @@ namespace ts { return isHeritageClause(); case ParsingContext.ImportOrExportSpecifiers: return isIdentifierOrKeyword(); + case ParsingContext.JsxAttributes: + return isIdentifierOrKeyword() || token === SyntaxKind.OpenBraceToken; + case ParsingContext.JsxChildren: + return token === SyntaxKind.LessThanToken || token === SyntaxKind.OpenBraceToken || token === SyntaxKind.JsxText; case ParsingContext.JSDocFunctionParameters: case ParsingContext.JSDocTypeArguments: case ParsingContext.JSDocTupleTypes: @@ -1265,6 +1296,11 @@ namespace ts { return token === SyntaxKind.GreaterThanToken || token === SyntaxKind.OpenParenToken; case ParsingContext.HeritageClauses: return token === SyntaxKind.OpenBraceToken || token === SyntaxKind.CloseBraceToken; + case ParsingContext.JsxAttributes: + // For error recovery, include } here (otherwise an over-braced {expr}} will close the surrounding statement block and mess up the entire file). + return token === SyntaxKind.GreaterThanToken || token === SyntaxKind.SlashToken || token === SyntaxKind.CloseBraceToken; + case ParsingContext.JsxChildren: + return token === SyntaxKind.LessThanSlashToken; case ParsingContext.JSDocFunctionParameters: return token === SyntaxKind.CloseParenToken || token === SyntaxKind.ColonToken || token === SyntaxKind.CloseBraceToken; case ParsingContext.JSDocTypeArguments: @@ -1481,6 +1517,12 @@ namespace ts { // name list, and there can be left hand side expressions (which can have type // arguments.) case ParsingContext.HeritageClauseElement: + + // Perhaps safe to reuse, but it's unlikely we'd see more than a dozen attributes + // on any given element. Same for children. + case ParsingContext.JsxAttributes: + case ParsingContext.JsxChildren: + } return false; @@ -1639,6 +1681,8 @@ namespace ts { case ParsingContext.TupleElementTypes: return Diagnostics.Type_expected; case ParsingContext.HeritageClauses: return Diagnostics.Unexpected_token_expected; case ParsingContext.ImportOrExportSpecifiers: return Diagnostics.Identifier_expected; + case ParsingContext.JsxAttributes: return Diagnostics.Identifier_expected; + case ParsingContext.JsxChildren: return Diagnostics.Identifier_expected; case ParsingContext.JSDocFunctionParameters: return Diagnostics.Parameter_declaration_expected; case ParsingContext.JSDocTypeArguments: return Diagnostics.Type_argument_expected; case ParsingContext.JSDocTupleTypes: return Diagnostics.Type_expected; @@ -2794,6 +2838,32 @@ namespace ts { return Tristate.False; } + // JSX overrides + if (sourceFile.isTSXFile) { + let isArrowFunctionInJsx = lookAhead(() => { + let third = nextToken(); + let fourth = nextToken(); + if (third === SyntaxKind.ExtendsKeyword) { + switch (fourth) { + case SyntaxKind.EqualsToken: + case SyntaxKind.GreaterThanToken: + return false; + default: + return true; + } + } + else if (third === SyntaxKind.CommaToken) { + return true; + } + return false; + }); + if (isArrowFunctionInJsx) { + return Tristate.Unknown; + } else { + return Tristate.False; + } + } + // This *could* be a parenthesized arrow function. return Tristate.Unknown; } @@ -2910,7 +2980,23 @@ namespace ts { break; } - leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence)); + if (token === SyntaxKind.AsKeyword) { + // Make sure we *do* perform ASI for constructs like this: + // var x = foo + // as (Bar) + // This should be parsed as an initialized variable, followed + // by a function call to 'as' with the argument 'Bar' + if (scanner.hasPrecedingLineBreak()) { + break; + } + else { + nextToken(); + leftOperand = makeAsExpression(leftOperand, parseType()); + } + } + else { + leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence)); + } } return leftOperand; @@ -2947,6 +3033,7 @@ namespace ts { case SyntaxKind.GreaterThanEqualsToken: case SyntaxKind.InstanceOfKeyword: case SyntaxKind.InKeyword: + case SyntaxKind.AsKeyword: return 7; case SyntaxKind.LessThanLessThanToken: case SyntaxKind.GreaterThanGreaterThanToken: @@ -2974,6 +3061,13 @@ namespace ts { return finishNode(node); } + function makeAsExpression(left: Expression, right: TypeNode): AsExpression { + let node = createNode(SyntaxKind.AsExpression, left.pos); + node.expression = left; + node.type = right; + return finishNode(node); + } + function parsePrefixUnaryExpression() { let node = createNode(SyntaxKind.PrefixUnaryExpression); node.operator = token; @@ -3019,7 +3113,7 @@ namespace ts { case SyntaxKind.VoidKeyword: return parseVoidExpression(); case SyntaxKind.LessThanToken: - return parseTypeAssertion(); + return sourceFile.isTSXFile ? parseJsxElementOrSelfClosingElement() : parseTypeAssertion(); default: return parsePostfixExpressionOrHigher(); } @@ -3146,6 +3240,136 @@ namespace ts { node.name = parseRightSideOfDot(/*allowIdentifierNames*/ true); return finishNode(node); } + + function parseJsxChild(): JsxChild { + let result: JsxChild = undefined; + switch (token) { + case SyntaxKind.JsxText: + result = createNode(SyntaxKind.JsxText); + token = scanner.scanJsxToken(); + result = finishNode(result); + break; + case SyntaxKind.OpenBraceToken: + result = parseJsxExpression(); + break; + default: + Debug.assert(token === SyntaxKind.LessThanToken); + result = parseJsxElementOrSelfClosingElement(); + break; + } + token = scanner.reScanJsxToken(); + Debug.assert(result !== undefined, "parsed some JSX child"); + return result; + } + + function parseJsxElementOrSelfClosingElement(): JsxElement|JsxSelfClosingElement { + let opening = parseJsxOpeningOrSelfClosingElement(); + if (opening.kind === SyntaxKind.JsxOpeningElement) { + let node = createNode(SyntaxKind.JsxElement, opening.pos); + node.openingElement = opening; + + // Rescan since parsing the > messed up the scanner state + token = scanner.reScanJsxToken(); + node.children = parseList(ParsingContext.JsxChildren, parseJsxChild); + node.closingElement = parseJsxClosingElement(); + return finishNode(node); + } + else { + Debug.assert(opening.kind === SyntaxKind.JsxSelfClosingElement); + // Nothing else to do for self-closing elements + return opening; + } + } + + function parseJsxOpeningOrSelfClosingElement(): JsxOpeningElement|JsxSelfClosingElement { + let fullStart = scanner.getStartPos(); + + parseExpected(SyntaxKind.LessThanToken); + + let tagName = parseJsxElementName(); + let attributes = parseList(ParsingContext.JsxAttributes, parseJsxAttribute); + let node: JsxOpeningLikeElement; + if (token === SyntaxKind.SlashToken) { + node = createNode(SyntaxKind.JsxSelfClosingElement, fullStart); + + nextToken(); + } + else { + node = createNode(SyntaxKind.JsxOpeningElement, fullStart); + } + parseExpected(SyntaxKind.GreaterThanToken); + + node.tagName = tagName; + node.attributes = attributes; + + return finishNode(node); + } + + function parseJsxElementName(): EntityName { + scanJsxIdentifier(); + let elementName: EntityName = parseIdentifier(); + while (parseOptional(SyntaxKind.DotToken)) { + scanJsxIdentifier(); + let node = createNode(SyntaxKind.QualifiedName, elementName.pos); + node.left = elementName; + node.right = parseIdentifierName(); + elementName = finishNode(node); + } + return elementName; + } + + function parseJsxExpression(): JsxExpression { + let node = createNode(SyntaxKind.JsxExpression); + + parseExpected(SyntaxKind.OpenBraceToken); + if (token !== SyntaxKind.CloseBraceToken) { + node.expression = parseExpression(); + } + parseExpected(SyntaxKind.CloseBraceToken); + + return finishNode(node); + } + + function parseJsxAttribute(): JsxAttribute | JsxSpreadAttribute { + if (token === SyntaxKind.OpenBraceToken) { + return parseJsxSpreadAttribute(); + } + + scanJsxIdentifier(); + let node = createNode(SyntaxKind.JsxAttribute); + node.name = parseIdentifierName(); + if (parseOptional(SyntaxKind.EqualsToken)) { + switch (token) { + case SyntaxKind.LessThanToken: + node.initializer = parseJsxElementOrSelfClosingElement(); + break; + case SyntaxKind.StringLiteral: + node.initializer = parseLiteralNode(); + break; + default: + node.initializer = parseJsxExpression(); + break; + } + } + return finishNode(node); + } + + function parseJsxSpreadAttribute(): JsxSpreadAttribute { + let node = createNode(SyntaxKind.JsxSpreadAttribute); + parseExpected(SyntaxKind.OpenBraceToken); + parseExpected(SyntaxKind.DotDotDotToken); + node.expression = parseExpression(); + parseExpected(SyntaxKind.CloseBraceToken); + return finishNode(node); + } + + function parseJsxClosingElement(): JsxClosingElement { + let node = createNode(SyntaxKind.JsxClosingElement); + parseExpected(SyntaxKind.LessThanSlashToken); + node.tagName = parseJsxElementName(); + parseExpected(SyntaxKind.GreaterThanToken); + return finishNode(node); + } function parseTypeAssertion(): TypeAssertion { let node = createNode(SyntaxKind.TypeAssertionExpression); @@ -4881,6 +5105,8 @@ namespace ts { ArrayBindingElements, // Binding elements in array binding list ArgumentExpressions, // Expressions in argument list ObjectLiteralMembers, // Members in object literal + JsxAttributes, // Attributes in jsx element + JsxChildren, // Things between opening and closing JSX tags ArrayLiteralMembers, // Members in array literal Parameters, // Parameters in parameter list TypeParameters, // Type parameters in type parameter list diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index bcc31c39002..4ce0dadc1cd 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -21,6 +21,9 @@ namespace ts { reScanGreaterToken(): SyntaxKind; reScanSlashToken(): SyntaxKind; reScanTemplateToken(): SyntaxKind; + scanJsxIdentifier(): SyntaxKind; + reScanJsxToken(): SyntaxKind; + scanJsxToken(): SyntaxKind; scan(): SyntaxKind; // Sets the text for the scanner to scan. An optional subrange starting point and length // can be provided to have the scanner only scan a portion of the text. @@ -130,6 +133,7 @@ namespace ts { "++": SyntaxKind.PlusPlusToken, "--": SyntaxKind.MinusMinusToken, "<<": SyntaxKind.LessThanLessThanToken, + ">": SyntaxKind.GreaterThanGreaterThanToken, ">>>": SyntaxKind.GreaterThanGreaterThanGreaterThanToken, "&": SyntaxKind.AmpersandToken, @@ -621,7 +625,7 @@ namespace ts { ch >= CharacterCodes._0 && ch <= CharacterCodes._9 || ch === CharacterCodes.$ || ch === CharacterCodes._ || ch > CharacterCodes.maxAsciiCharacter && isUnicodeIdentifierPart(ch, languageVersion); } - + /* @internal */ // Creates a scanner over a (possibly unspecified) range of a piece of text. export function createScanner(languageVersion: ScriptTarget, @@ -665,6 +669,9 @@ namespace ts { reScanGreaterToken, reScanSlashToken, reScanTemplateToken, + scanJsxIdentifier, + reScanJsxToken, + scanJsxToken, scan, setText, setScriptTarget, @@ -1481,6 +1488,62 @@ namespace ts { return token = scanTemplateAndSetTokenValue(); } + function reScanJsxToken(): SyntaxKind { + pos = tokenPos = startPos; + return token = scanJsxToken(); + } + + function scanJsxToken(): SyntaxKind { + startPos = tokenPos = pos; + + if (pos >= end) { + return token = SyntaxKind.EndOfFileToken; + } + + let char = text.charCodeAt(pos); + if (char === CharacterCodes.lessThan) { + if (text.charCodeAt(pos + 1) === CharacterCodes.slash) { + pos += 2; + return token = SyntaxKind.LessThanSlashToken; + } + pos++; + return token = SyntaxKind.LessThanToken; + } + + if (char === CharacterCodes.openBrace) { + pos++; + return token = SyntaxKind.OpenBraceToken; + } + + while (pos < end) { + pos++; + char = text.charCodeAt(pos); + if ((char === CharacterCodes.openBrace) || (char === CharacterCodes.lessThan)) { + break; + } + } + return token = SyntaxKind.JsxText; + } + + // Scans a JSX identifier; these differ from normal identifiers in that + // they allow dashes + function scanJsxIdentifier(): SyntaxKind { + if (token === SyntaxKind.Identifier) { + let firstCharPosition = pos; + while (pos < end) { + let ch = text.charCodeAt(pos); + if (ch === CharacterCodes.minus || ((firstCharPosition === pos) ? isIdentifierStart(ch) : isIdentifierPart(ch))) { + pos++; + } + else { + break; + } + } + tokenValue += text.substr(firstCharPosition, pos - firstCharPosition); + } + return token; + } + function speculationHelper(callback: () => T, isLookahead: boolean): T { let savePos = pos; let saveStartPos = startPos; From 6dfe3d72cff72b7bc6d2fd8989f6030a7a0eb704 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:01:31 -0700 Subject: [PATCH 122/309] JSX/as support in tsc.js + error messages --- src/compiler/commandLineParser.ts | 25 +++++- .../diagnosticInformationMap.generated.ts | 19 ++++ src/compiler/diagnosticMessages.json | 88 +++++++++++++++++-- 3 files changed, 125 insertions(+), 7 deletions(-) diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 07bccf4a5ef..648724ad94e 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -38,6 +38,16 @@ namespace ts { name: "inlineSources", type: "boolean", }, + { + name: "jsx", + type: { + "preserve": JsxEmit.Preserve, + "react": JsxEmit.React + }, + paramType: Diagnostics.KIND, + description: Diagnostics.Specifies_how_to_transform_JSX_syntax_during_compilation, + error: Diagnostics.Argument_for_jsx_must_be_preserve_or_react + }, { name: "listFiles", type: "boolean", @@ -408,10 +418,21 @@ namespace ts { } else { var exclude = json["exclude"] instanceof Array ? map(json["exclude"], normalizeSlashes) : undefined; - var sysFiles = host.readDirectory(basePath, ".ts", exclude); + var sysFiles = host.readDirectory(basePath, ".ts", exclude).concat(host.readDirectory(basePath, ".tsx", exclude)); for (var i = 0; i < sysFiles.length; i++) { var name = sysFiles[i]; - if (!fileExtensionIs(name, ".d.ts") || !contains(sysFiles, name.substr(0, name.length - 5) + ".ts")) { + if (fileExtensionIs(name, ".d.ts")) { + let baseName = name.substr(0, name.length - ".d.ts".length); + if (!contains(sysFiles, baseName + ".tsx") && !contains(sysFiles, baseName + ".ts")) { + fileNames.push(name); + } + } + else if (fileExtensionIs(name, ".ts")) { + if (!contains(sysFiles, name + "x")) { + fileNames.push(name) + } + } + else { fileNames.push(name); } } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 09b009711fe..bd3737ee4bf 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -389,6 +389,17 @@ namespace ts { No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." }, Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." }, Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, + JSX_element_attributes_type_0_must_be_an_object_type: { code: 2600, category: DiagnosticCategory.Error, key: "JSX element attributes type '{0}' must be an object type." }, + The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: { code: 2601, category: DiagnosticCategory.Error, key: "The return type of a JSX element constructor must return an object type." }, + The_global_type_JSX_Element_must_exist_when_using_JSX: { code: 2602, category: DiagnosticCategory.Error, key: "The global type 'JSX.Element' must exist when using JSX." }, + Property_0_in_type_1_is_not_assignable_to_type_2: { code: 2603, category: DiagnosticCategory.Error, key: "Property '{0}' in type '{1}' is not assignable to type '{2}'" }, + JSX_element_0_is_not_a_constructor_function: { code: 2604, category: DiagnosticCategory.Error, key: "JSX element '{0}' is not a constructor function." }, + JSX_element_0_is_not_a_constructor_function_for_JSX_elements: { code: 2605, category: DiagnosticCategory.Error, key: "JSX element '{0}' is not a constructor function for JSX elements." }, + Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: { code: 2606, category: DiagnosticCategory.Error, key: "Property '{0}' of JSX spread attribute is not assignable to target property." }, + JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: { code: 2607, category: DiagnosticCategory.Error, key: "JSX element class does not support attributes because it does not have a '{0}' property" }, + The_global_type_JSX_0_may_not_have_more_than_one_property: { code: 2608, category: DiagnosticCategory.Error, key: "The global type 'JSX.{0}' may not have more than one property" }, + JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 2609, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because no interface JSX.{0} exists" }, + Cannot_emit_namespaced_JSX_elements_in_React: { code: 2650, category: DiagnosticCategory.Error, key: "Cannot emit namespaced JSX elements in React" }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -531,6 +542,8 @@ namespace ts { Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." }, NEWLINE: { code: 6061, category: DiagnosticCategory.Message, key: "NEWLINE" }, Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." }, + Specifies_how_to_transform_JSX_syntax_during_compilation: { code: 6080, category: DiagnosticCategory.Message, key: "Specifies how to transform JSX syntax during compilation." }, + Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: DiagnosticCategory.Message, key: "Argument for --jsx must be 'preserve' or 'react'." }, Option_experimentalDecorators_must_also_be_specified_when_option_emitDecoratorMetadata_is_specified: { code: 6064, category: DiagnosticCategory.Error, key: "Option 'experimentalDecorators' must also be specified when option 'emitDecoratorMetadata' is specified." }, Enables_experimental_support_for_ES7_decorators: { code: 6065, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 decorators." }, Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: DiagnosticCategory.Message, key: "Enables experimental support for emitting type metadata for decorators." }, @@ -569,5 +582,11 @@ namespace ts { decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." }, + class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration: { code: 9004, category: DiagnosticCategory.Error, key: "'class' declarations are only supported directly inside a module or as a top level declaration." }, + JSX_attributes_must_only_be_assigned_a_non_empty_expression: { code: 17000, category: DiagnosticCategory.Error, key: "JSX attributes must only be assigned a non-empty 'expression'." }, + JSX_elements_cannot_have_multiple_attributes_with_the_same_name: { code: 17001, category: DiagnosticCategory.Error, key: "JSX elements cannot have multiple attributes with the same name." }, + Expected_corresponding_JSX_closing_tag_for_0: { code: 17002, category: DiagnosticCategory.Error, key: "Expected corresponding JSX closing tag for '{0}'." }, + JSX_attribute_expected: { code: 17003, category: DiagnosticCategory.Error, key: "JSX attribute expected." }, + Cannot_use_JSX_unless_the_jsx_flag_is_provided: { code: 17004, category: DiagnosticCategory.Error, key: "Cannot use JSX unless the '--jsx' flag is provided." }, }; } \ No newline at end of file diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index fee46a84c1e..23ab3b89f70 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -686,7 +686,7 @@ "Experimental support for decorators is a feature that is subject to change in a future release. Specify '--experimentalDecorators' to remove this warning.": { "category": "Error", "code": 1219 - }, + }, "Generators are only available when targeting ECMAScript 6 or higher.": { "category": "Error", "code": 1220 @@ -1546,6 +1546,52 @@ "code": 2510 }, + "JSX element attributes type '{0}' must be an object type.": { + "category": "Error", + "code": 2600 + }, + "The return type of a JSX element constructor must return an object type.": { + "category": "Error", + "code": 2601 + }, + "The global type 'JSX.Element' must exist when using JSX.": { + "category": "Error", + "code": 2602 + }, + "Property '{0}' in type '{1}' is not assignable to type '{2}'": { + "category": "Error", + "code": 2603 + }, + "JSX element '{0}' is not a constructor function.": { + "category": "Error", + "code": 2604 + }, + "JSX element '{0}' is not a constructor function for JSX elements.": { + "category": "Error", + "code": 2605 + }, + "Property '{0}' of JSX spread attribute is not assignable to target property.": { + "category": "Error", + "code": 2606 + }, + "JSX element class does not support attributes because it does not have a '{0}' property": { + "category": "Error", + "code": 2607 + }, + "The global type 'JSX.{0}' may not have more than one property": { + "category": "Error", + "code": 2608 + }, + "JSX element implicitly has type 'any' because no interface JSX.{0} exists": { + "category": "Error", + "code": 2609 + }, + + "Cannot emit namespaced JSX elements in React": { + "category": "Error", + "code": 2650 + }, + "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 @@ -1914,7 +1960,7 @@ "category": "Error", "code": 5050 }, - "Option 'inlineSources' can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided.": { + "Option 'inlineSources' can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided.": { "category": "Error", "code": 5051 }, @@ -2107,14 +2153,22 @@ "category": "Message", "code": 6060 }, - "NEWLINE": { - "category": "Message", + "NEWLINE": { + "category": "Message", "code": 6061 }, "Argument for '--newLine' option must be 'CRLF' or 'LF'.": { - "category": "Error", + "category": "Error", "code": 6062 }, + "Specifies how to transform JSX syntax during compilation.": { + "category": "Message", + "code": 6080 + }, + "Argument for --jsx must be 'preserve' or 'react'.": { + "category": "Message", + "code": 6081 + }, "Option 'experimentalDecorators' must also be specified when option 'emitDecoratorMetadata' is specified.": { "category": "Error", "code": 6064 @@ -2268,5 +2322,29 @@ "'class' expressions are not currently supported.": { "category": "Error", "code": 9003 + }, + "'class' declarations are only supported directly inside a module or as a top level declaration.": { + "category": "Error", + "code": 9004 + }, + "JSX attributes must only be assigned a non-empty 'expression'.": { + "category": "Error", + "code": 17000 + }, + "JSX elements cannot have multiple attributes with the same name.": { + "category": "Error", + "code": 17001 + }, + "Expected corresponding JSX closing tag for '{0}'.": { + "category": "Error", + "code": 17002 + }, + "JSX attribute expected.": { + "category": "Error", + "code": 17003 + }, + "Cannot use JSX unless the '--jsx' flag is provided.": { + "category": "Error", + "code": 17004 } } From 195db034f8ebaf8d709acba295876f06d81a8ce9 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:01:42 -0700 Subject: [PATCH 123/309] Checker work for JSX + As --- src/compiler/checker.ts | 550 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 527 insertions(+), 23 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 68a0916f743..3ee4b57b44a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -74,6 +74,9 @@ namespace ts { getAliasedSymbol: resolveAlias, getEmitResolver, getExportsOfModule: getExportsOfModuleAsArray, + + getJsxElementAttributesType, + getJsxIntrinsicTagNames }; let unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown"); @@ -113,6 +116,8 @@ namespace ts { let globalRegExpType: ObjectType; let globalTemplateStringsArrayType: ObjectType; let globalESSymbolType: ObjectType; + let jsxElementType: ObjectType; + let jsxIntrinsicElementsType: ObjectType; let globalIterableType: GenericType; let globalIteratorType: GenericType; let globalIterableIteratorType: GenericType; @@ -159,6 +164,14 @@ namespace ts { } }; + let JsxNames = { + JSX: 'JSX', + IntrinsicElements: 'IntrinsicElements', + ElementClass: 'ElementClass', + ElementAttributesPropertyNameContainer: 'ElementAttributesProperty', + Element: 'Element' + }; + let subtypeRelation: Map = {}; let assignableRelation: Map = {}; let identityRelation: Map = {}; @@ -1986,7 +1999,7 @@ namespace ts { // If the binding pattern is empty, this variable declaration is not visible return false; } - // Otherwise fall through + // Otherwise fall through case SyntaxKind.ModuleDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: @@ -3762,6 +3775,12 @@ namespace ts { return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), arity); } + function getExportedTypeOfNamespace(namespace: string, name: string): Type { + var namespaceSymbol = getGlobalSymbol(namespace, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined); + var typeSymbol = namespaceSymbol && getSymbol(namespaceSymbol.exports, name, SymbolFlags.Type); + return (typeSymbol && getDeclaredTypeOfSymbol(typeSymbol)) || unknownType; + } + function getGlobalESSymbolConstructorSymbol() { return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); } @@ -4249,8 +4268,8 @@ namespace ts { return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage): boolean { - return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage); + function checkTypeAssignableTo(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source: Signature, target: Signature): boolean { @@ -5505,6 +5524,7 @@ namespace ts { case SyntaxKind.CallExpression: case SyntaxKind.NewExpression: case SyntaxKind.TypeAssertionExpression: + case SyntaxKind.AsExpression: case SyntaxKind.ParenthesizedExpression: case SyntaxKind.PrefixUnaryExpression: case SyntaxKind.DeleteExpression: @@ -5531,6 +5551,11 @@ namespace ts { case SyntaxKind.ThrowStatement: case SyntaxKind.TryStatement: case SyntaxKind.CatchClause: + case SyntaxKind.JsxElement: + case SyntaxKind.JsxSelfClosingElement: + case SyntaxKind.JsxAttribute: + case SyntaxKind.JsxSpreadAttribute: + case SyntaxKind.JsxOpeningElement: return forEachChild(node, isAssignedIn); } return false; @@ -6297,6 +6322,26 @@ namespace ts { return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional) : undefined; } + function getContextualTypeForJsxExpression(expr: JsxExpression|JsxSpreadAttribute): Type { + // Contextual type only applies to JSX expressions that are in attribute assignments (not in 'Children' positions) + if (expr.parent.kind === SyntaxKind.JsxAttribute) { + let attrib = expr.parent; + let attrsType = getJsxElementAttributesType(attrib.parent); + if (!attrsType || isTypeAny(attrsType)) { + return undefined; + } + else { + return getTypeOfPropertyOfType(attrsType, attrib.name.text); + } + } + else if (expr.kind === SyntaxKind.JsxSpreadAttribute) { + return getJsxElementAttributesType(expr.parent); + } + else { + return undefined; + } + } + // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily // be "pushed" onto a node using the contextualType property. function getContextualType(node: Expression): Type { @@ -6324,7 +6369,8 @@ namespace ts { case SyntaxKind.NewExpression: return getContextualTypeForArgument(parent, node); case SyntaxKind.TypeAssertionExpression: - return getTypeFromTypeNode((parent).type); + case SyntaxKind.AsExpression: + return getTypeFromTypeNode((parent).type); case SyntaxKind.BinaryExpression: return getContextualTypeForBinaryOperand(node); case SyntaxKind.PropertyAssignment: @@ -6338,6 +6384,9 @@ namespace ts { return getContextualTypeForSubstitutionExpression(parent.parent, node); case SyntaxKind.ParenthesizedExpression: return getContextualType(parent); + case SyntaxKind.JsxExpression: + case SyntaxKind.JsxSpreadAttribute: + return getContextualTypeForJsxExpression(parent); } return undefined; } @@ -6478,7 +6527,6 @@ namespace ts { let restArrayType = checkExpression((e).expression, contextualMapper); let restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) || (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined); - if (restElementType) { elementTypes.push(restElementType); } @@ -6638,6 +6686,412 @@ namespace ts { } } + + function checkJsxSelfClosingElement(node: JsxSelfClosingElement) { + checkJsxOpeningLikeElement(node); + return jsxElementType; + } + + function checkJsxElement(node: JsxElement) { + // Check that the closing tag matches + let expectedClosingTag = getTextOfNode(node.openingElement.tagName); + if (expectedClosingTag !== getTextOfNode(node.closingElement.tagName)) { + error(node.closingElement, Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, expectedClosingTag); + } + + // Check attributes + checkJsxOpeningLikeElement(node.openingElement); + + // Check children + for (var i = 0, n = node.children.length; i < n; i++) { + if (node.children[i].kind === SyntaxKind.JsxExpression) { + checkJsxExpression(node.children[i]); + } + else if (node.children[i].kind === SyntaxKind.JsxElement) { + checkJsxElement(node.children[i]); + } + else if (node.children[i].kind === SyntaxKind.JsxSelfClosingElement) { + checkJsxSelfClosingElement(node.children[i]); + } + else { + // No checks for JSX Text + Debug.assert(node.children[i].kind === SyntaxKind.JsxText); + } + } + + return jsxElementType; + } + + /// Returns true iff the JSX element name would be a valid identifier, ignoring restrictions about keywords not being identifiers + function isIdentifierLike(name: string) { + // - is the only character supported in JSX attribute names that isn't valid in JavaScript identifiers + return name.indexOf('-') < 0; + } + + /// Returns true iff React would emit this tag name as a string rather than an identifier or qualified name + function isJsxIntrinsicIdentifier(tagName: Identifier|QualifiedName) { + if (tagName.kind === SyntaxKind.QualifiedName) { + return false; + } + else { + let firstChar = (tagName).text.charAt(0); + return firstChar.toLowerCase() === firstChar; + } + } + + function checkJsxAttribute(node: JsxAttribute, elementAttributesType: Type, nameTable: Map) { + var correspondingPropType: Type = undefined; + + // Look up the corresponding property for this attribute + if (elementAttributesType === emptyObjectType && isIdentifierLike(node.name.text)) { + // If there is no 'props' property, you may not have non-"data-" attributes + error(node.parent, Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, getJsxElementPropertiesName()); + } + else if (elementAttributesType && !isTypeAny(elementAttributesType)) { + var correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text); + correspondingPropType = correspondingPropSymbol && getTypeOfSymbol(correspondingPropSymbol); + if (!correspondingPropType) { + // If there's no corresponding property with this name, error + if (isIdentifierLike(node.name.text)) { + error(node.name, Diagnostics.Property_0_does_not_exist_on_type_1, node.name.text, typeToString(elementAttributesType)); + return unknownType; + } + } + } + + let exprType: Type; + if (node.initializer) { + exprType = checkExpression(node.initializer); + } + else { + // is sugar for + exprType = booleanType; + } + + if (correspondingPropType) { + checkTypeAssignableTo(exprType, correspondingPropType, node); + } + + nameTable[node.name.text] = true; + return exprType; + } + + function checkJsxSpreadAttribute(node: JsxSpreadAttribute, elementAttributesType: Type, nameTable: Map) { + let type = checkExpression(node.expression); + let props = getPropertiesOfType(type); + for (var i = 0; i < props.length; i++) { + // Is there a corresponding property in the element attributes type? Skip checking of properties + // that have already been assigned to, as these are not actually pushed into the resulting type + if (!nameTable[props[i].name]) { + let targetPropSym = getPropertyOfType(elementAttributesType, props[i].name); + if (targetPropSym) { + let msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, props[i].name); + checkTypeAssignableTo(getTypeOfSymbol(props[i]), getTypeOfSymbol(targetPropSym), node, undefined, msg); + } + + nameTable[props[i].name] = true; + } + } + } + + /// Returns the type JSX.IntrinsicElements. May return `unknownType` if that type is not present. + function getJsxIntrinsicElementsType() { + if (!jsxIntrinsicElementsType) { + let jsxNamespace = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, undefined); + let intrinsicsSymbol = jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.IntrinsicElements, SymbolFlags.Type); + let intrinsicsType = intrinsicsSymbol && getDeclaredTypeOfSymbol(intrinsicsSymbol); + jsxIntrinsicElementsType = intrinsicsType || unknownType; + } + return jsxIntrinsicElementsType; + } + + /// Given a JSX opening element or self-closing element, return the symbol of the property that the tag name points to if + /// this is an intrinsic tag. This might be a named + /// property of the IntrinsicElements interface, or its string indexer. + /// If this is a class-based tag (otherwise returns undefined), returns the symbol of the class + /// type or factory function. + /// Otherwise, returns unknownSymbol. + function getJsxElementTagSymbol(node: JsxOpeningLikeElement): Symbol { + let flags: JsxFlags = JsxFlags.UnknownElement; + var links = getNodeLinks(node); + if (!links.resolvedSymbol) { + if (isJsxIntrinsicIdentifier(node.tagName)) { + links.resolvedSymbol = lookupIntrinsicTag(node); + } else { + links.resolvedSymbol = lookupClassTag(node); + } + } + return links.resolvedSymbol; + + function lookupIntrinsicTag(node: JsxOpeningLikeElement): Symbol { + let intrinsicElementsType = getJsxIntrinsicElementsType(); + if (intrinsicElementsType !== unknownType) { + // Property case + let intrinsicProp = getPropertyOfType(intrinsicElementsType, getTextOfNode(node.tagName)); + if (intrinsicProp) { + links.jsxFlags |= JsxFlags.IntrinsicNamedElement; + return intrinsicProp; + } + + // Intrinsic string indexer case + let indexSignatureType = getIndexTypeOfType(intrinsicElementsType, IndexKind.String); + if (indexSignatureType) { + links.jsxFlags |= JsxFlags.IntrinsicIndexedElement; + return intrinsicElementsType.symbol; + } + + // Wasn't found + error(node, Diagnostics.Property_0_does_not_exist_on_type_1, getTextOfNode(node.tagName), 'JSX.' + JsxNames.IntrinsicElements); + return unknownSymbol; + } + else { + if (compilerOptions.noImplicitAny) { + error(node, Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, JsxNames.IntrinsicElements); + } + } + } + + function lookupClassTag(node: JsxOpeningLikeElement): Symbol { + let valueSym: Symbol; + + // Look up the value in the current scope + if (node.tagName.kind === SyntaxKind.Identifier) { + valueSym = getResolvedSymbol(node.tagName); + } + else { + valueSym = checkQualifiedName(node.tagName).symbol; + } + + if (valueSym !== unknownSymbol) { + links.jsxFlags |= JsxFlags.ClassElement; + } + + return valueSym || unknownSymbol; + } + } + + /// Given a JSX element that is a class element, finds the Element Instance Type. If the + /// element is not a class element, or the class element type cannot be determined, returns 'undefined'. + /// For example, in the element , the element instance type is `MyClass` (not `typeof MyClass`). + function getJsxElementInstanceType(node: JsxOpeningLikeElement) { + if (!(getNodeLinks(node).jsxFlags & JsxFlags.ClassElement)) { + // There is no such thing as an instance type for a non-class element + return undefined; + } + + var classSymbol = getJsxElementTagSymbol(node); + if (classSymbol === unknownSymbol) { + // Couldn't find the class instance type. Error has already been issued + return anyType; + } + + var valueType = getTypeOfSymbol(classSymbol); + if (isTypeAny(valueType)) { + // Short-circuit if the class tag is using an element type 'any' + return anyType; + } + + // Resolve the signatures, preferring constructors + var signatures = getSignaturesOfType(valueType, SignatureKind.Construct); + if (signatures.length === 0) { + // No construct signatures, try call signatures + signatures = getSignaturesOfType(valueType, SignatureKind.Call); + } + if (signatures.length === 0) { + // We found no signatures at all, which is an error + error(node.tagName, Diagnostics.JSX_element_0_is_not_a_constructor_function, getTextOfNode(node.tagName)); + return undefined; + } + + else { + // Check that the constructor/factory returns an object type + var returnType = getUnionType(signatures.map(s => getReturnTypeOfSignature(s))); + if (!isTypeAny(returnType) && !(returnType.flags & TypeFlags.ObjectType)) { + error(node.tagName, Diagnostics.The_return_type_of_a_JSX_element_constructor_must_return_an_object_type); + return undefined; + } + + // Issue an error if this return type isn't assignable to JSX.ElementClass + // TODO: Move this to a 'check' function + var elemClassType = getJsxGlobalElementClassType(); + if (elemClassType) { + checkTypeRelatedTo(returnType, elemClassType, assignableRelation, node, Diagnostics.JSX_element_0_is_not_a_constructor_function_for_JSX_elements); + } + + return returnType; + } + } + + /// e.g. "props" for React.d.ts, + /// or 'undefined' if ElementAttributesPropery doesn't exist (which means all + /// non-intrinsic elements' attributes type is 'any'), + /// or '' if it has 0 properties (which means all + /// non-instrinsic elements' attributes type is the element instance type) + function getJsxElementPropertiesName() { + // JSX + let jsxNamespace = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, /*diagnosticMessage*/undefined); + // JSX.ElementAttributesProperty [symbol] + let attribsPropTypeSym = jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.ElementAttributesPropertyNameContainer, SymbolFlags.Type); + // JSX.ElementAttributesProperty [type] + let attribPropType = attribsPropTypeSym && getDeclaredTypeOfSymbol(attribsPropTypeSym); + // The properites of JSX.ElementAttributesProperty + let attribProperties = attribPropType && getPropertiesOfType(attribPropType); + + if (attribProperties) { + if (attribProperties.length === 0) { + return ''; + } + else if (attribProperties.length === 1) { + return attribProperties[0].name; + } + else { + error(attribsPropTypeSym.declarations[0], Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, JsxNames.ElementAttributesPropertyNameContainer); + return undefined; + } + } + else { + return undefined; + } + } + + /// Given an opening/self-closing element, get the 'element attributes type', i.e. the type that tells + /// us which attributes are valid on a given element. + function getJsxElementAttributesType(node: JsxOpeningLikeElement): Type { + let links = getNodeLinks(node); + if (!links.resolvedType) { + let sym = getJsxElementTagSymbol(node); + + if (links.jsxFlags & JsxFlags.ClassElement) { + let elemInstanceType = getJsxElementInstanceType(node); + + if (isTypeAny(elemInstanceType)) { + return links.resolvedType = anyType; + } + + var propsName = getJsxElementPropertiesName(); + if (propsName === undefined) { + // There is no type ElementAttributesProperty, return 'any' + return links.resolvedType = anyType; + } + else if (propsName === '') { + // If there is no e.g. 'props' member in ElementAttributesProperty, use the element class type instead + return links.resolvedType = elemInstanceType; + } + else { + var attributesType = getTypeOfPropertyOfType(elemInstanceType, propsName); + + if (!attributesType) { + // There is no property named 'props' on this instance type + return links.resolvedType = emptyObjectType; + } + else if (isTypeAny(attributesType) || (attributesType === unknownType)) { + return links.resolvedType = attributesType; + } + else if (!(attributesType.flags & TypeFlags.ObjectType)) { + error(node.tagName, Diagnostics.JSX_element_attributes_type_0_must_be_an_object_type, typeToString(attributesType)); + return links.resolvedType = anyType; + } + else { + return links.resolvedType = attributesType; + } + } + } + else if (links.jsxFlags & JsxFlags.IntrinsicNamedElement) { + return links.resolvedType = getTypeOfSymbol(sym); + } + else if (links.jsxFlags & JsxFlags.IntrinsicIndexedElement) { + return links.resolvedType = getIndexTypeOfSymbol(sym, IndexKind.String); + } + else { + // Resolution failed + return links.resolvedType = anyType; + } + } + + return links.resolvedType; + } + + /// Given a JSX attribute, returns the symbol for the corresponds property + /// of the element attributes type. Will return unknownSymbol for attributes + /// that have no matching element attributes type property. + function getJsxAttributePropertySymbol(attrib: JsxAttribute): Symbol { + let attributesType = getJsxElementAttributesType(attrib.parent); + let prop = getPropertyOfType(attributesType, attrib.name.text); + return prop || unknownSymbol; + } + + function getJsxGlobalElementClassType(): Type { + var jsxNS = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined); + if (jsxNS) { + let sym = getSymbol(jsxNS.exports, JsxNames.ElementClass, SymbolFlags.Type); + let elemClassType = sym && getDeclaredTypeOfSymbol(sym); + return elemClassType; + } + else { + return undefined; + } + } + + /// Returns all the properties of the Jsx.IntrinsicElements interface + function getJsxIntrinsicTagNames(): Symbol[] { + let intrinsics = getJsxIntrinsicElementsType(); + return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray; + } + + function checkJsxPreconditions(errorNode: Node) { + // Preconditions for using JSX + if ((compilerOptions.jsx || JsxEmit.None) === JsxEmit.None) { + error(errorNode, Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided); + } + + if (jsxElementType === unknownType) { + error(errorNode, Diagnostics.The_global_type_JSX_Element_must_exist_when_using_JSX); + } + } + + function checkJsxOpeningLikeElement(node: JsxOpeningLikeElement) { + checkGrammarJsxElement(node); + checkJsxPreconditions(node); + + var targetAttributesType = getJsxElementAttributesType(node); + + var nameTable: Map = {}; + // Process this array in right-to-left order so we know which + // attributes (mostly from spreads) are being overwritten and + // thus should have their types ignored + for (var i = node.attributes.length - 1; i >= 0; i--) { + if (node.attributes[i].kind === SyntaxKind.JsxAttribute) { + checkJsxAttribute((node.attributes[i]), targetAttributesType, nameTable); + } + else { + Debug.assert(node.attributes[i].kind === SyntaxKind.JsxSpreadAttribute); + checkJsxSpreadAttribute((node.attributes[i]), targetAttributesType, nameTable); + } + } + + // Check that all required properties have been provided + if (targetAttributesType) { + let targetProperties = getPropertiesOfType(targetAttributesType); + for (var i = 0; i < targetProperties.length; i++) { + if (!(targetProperties[i].flags & SymbolFlags.Optional) && + nameTable[targetProperties[i].name] === undefined) { + + error(node, Diagnostics.Property_0_is_missing_in_type_1, targetProperties[i].name, typeToString(targetAttributesType)); + } + } + } + } + + function checkJsxExpression(node: JsxExpression) { + if (node.expression) { + return checkExpression(node.expression); + } + else { + /// is shorthand for + return booleanType; + } + } + // If a symbol is a synthesized symbol with no value declaration, we assume it is a property. Example of this are the synthesized // '.prototype' property as well as synthesized tuple index properties. function getDeclarationKindFromSymbol(s: Symbol) { @@ -7361,7 +7815,7 @@ namespace ts { if (!hasCorrectArity(node, args, originalCandidate)) { continue; } - + let candidate: Signature; let typeArgumentsAreValid: boolean; let inferenceContext = originalCandidate.typeParameters @@ -7618,7 +8072,7 @@ namespace ts { return getReturnTypeOfSignature(getResolvedSignature(node)); } - function checkTypeAssertion(node: TypeAssertion): Type { + function checkAssertion(node: AssertionExpression) { let exprType = checkExpression(node.expression); let targetType = getTypeFromTypeNode(node.type); if (produceDiagnostics && targetType !== unknownType) { @@ -7791,7 +8245,6 @@ namespace ts { function checkFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | MethodDeclaration, contextualMapper?: TypeMapper): Type { Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node)); - // Grammar checking let hasGrammarError = checkGrammarFunctionLikeDeclaration(node); if (!hasGrammarError && node.kind === SyntaxKind.FunctionExpression) { @@ -8275,7 +8728,7 @@ namespace ts { if (!checkForDisallowedESSymbolOperand(operator)) { return booleanType; } - // Fall through + // Fall through case SyntaxKind.EqualsEqualsToken: case SyntaxKind.ExclamationEqualsToken: case SyntaxKind.EqualsEqualsEqualsToken: @@ -8303,8 +8756,8 @@ namespace ts { function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean { let offendingSymbolOperand = someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? node.left : - someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : - undefined; + someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : + undefined; if (offendingSymbolOperand) { error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator)); return false; @@ -8559,8 +9012,6 @@ namespace ts { return checkCallExpression(node); case SyntaxKind.TaggedTemplateExpression: return checkTaggedTemplateExpression(node); - case SyntaxKind.TypeAssertionExpression: - return checkTypeAssertion(node); case SyntaxKind.ParenthesizedExpression: return checkExpression((node).expression, contextualMapper); case SyntaxKind.ClassExpression: @@ -8570,6 +9021,9 @@ namespace ts { return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); case SyntaxKind.TypeOfExpression: return checkTypeOfExpression(node); + case SyntaxKind.TypeAssertionExpression: + case SyntaxKind.AsExpression: + return checkAssertion(node); case SyntaxKind.DeleteExpression: return checkDeleteExpression(node); case SyntaxKind.VoidExpression: @@ -8588,6 +9042,14 @@ namespace ts { return undefinedType; case SyntaxKind.YieldExpression: return checkYieldExpression(node); + case SyntaxKind.JsxExpression: + return checkJsxExpression(node); + case SyntaxKind.JsxElement: + return checkJsxElement(node); + case SyntaxKind.JsxSelfClosingElement: + return checkJsxSelfClosingElement(node); + case SyntaxKind.JsxOpeningElement: + Debug.fail("Shouldn't ever directly check a JsxOpeningElement"); } return unknownType; } @@ -9483,7 +9945,7 @@ namespace ts { case SyntaxKind.MethodDeclaration: checkParameterTypeAnnotationsAsExpressions(node); - // fall-through + // fall-through case SyntaxKind.SetAccessor: case SyntaxKind.GetAccessor: @@ -10060,7 +10522,7 @@ namespace ts { if (allowStringInput) { return checkElementTypeOfArrayOrString(inputType, errorNode); } - + if (isArrayLikeType(inputType)) { let indexType = getIndexTypeOfType(inputType, IndexKind.Number); if (indexType) { @@ -11145,7 +11607,7 @@ namespace ts { // if the module merges with a class declaration in the same lexical scope, // we need to track this to ensure the correct emit. - let mergedClass = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration); + let mergedClass = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration); if (mergedClass && inSameLexicalScope(node, mergedClass)) { getNodeLinks(node).flags |= NodeCheckFlags.LexicalModuleMergesWithClass; @@ -11569,6 +12031,7 @@ namespace ts { case SyntaxKind.TemplateExpression: case SyntaxKind.TemplateSpan: case SyntaxKind.TypeAssertionExpression: + case SyntaxKind.AsExpression: case SyntaxKind.ParenthesizedExpression: case SyntaxKind.TypeOfExpression: case SyntaxKind.VoidExpression: @@ -11606,6 +12069,12 @@ namespace ts { case SyntaxKind.EnumMember: case SyntaxKind.ExportAssignment: case SyntaxKind.SourceFile: + case SyntaxKind.JsxExpression: + case SyntaxKind.JsxElement: + case SyntaxKind.JsxSelfClosingElement: + case SyntaxKind.JsxAttribute: + case SyntaxKind.JsxSpreadAttribute: + case SyntaxKind.JsxOpeningElement: forEachChild(node, checkFunctionExpressionBodies); break; } @@ -11890,6 +12359,9 @@ namespace ts { meaning |= SymbolFlags.Alias; return resolveEntityName(entityName, meaning); } + else if ((entityName.parent.kind === SyntaxKind.JsxOpeningElement) || (entityName.parent.kind === SyntaxKind.JsxSelfClosingElement)) { + return getJsxElementTagSymbol(entityName.parent); + } else if (isExpression(entityName)) { if (nodeIsMissing(entityName)) { // Missing entity name. @@ -11924,6 +12396,9 @@ namespace ts { meaning |= SymbolFlags.Alias; return resolveEntityName(entityName, meaning); } + else if (entityName.parent.kind === SyntaxKind.JsxAttribute) { + return getJsxAttributePropertySymbol(entityName.parent); + } // Do we want to return undefined here? return undefined; @@ -12051,6 +12526,7 @@ namespace ts { return unknownType; } + function getTypeOfExpression(expr: Expression): Type { if (isRightSideOfQualifiedNameOrPropertyAccess(expr)) { expr = expr.parent; @@ -12381,7 +12857,7 @@ namespace ts { break; } } - + return "Object"; } @@ -12507,7 +12983,7 @@ namespace ts { let isVariableDeclarationOrBindingElement = n.parent.kind === SyntaxKind.BindingElement || (n.parent.kind === SyntaxKind.VariableDeclaration && (n.parent).name === n); - let symbol = + let symbol = (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) || getNodeLinks(n).resolvedSymbol || resolveName(n, n.text, SymbolFlags.Value | SymbolFlags.Alias, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined); @@ -12535,7 +13011,7 @@ namespace ts { if (!signature) { return unknownType; } - + let instantiatedSignature = getSignatureInstantiation(signature, typeArguments); return getOrCreateTypeFromSignature(instantiatedSignature); } @@ -12594,6 +13070,7 @@ namespace ts { globalNumberType = getGlobalType("Number"); globalBooleanType = getGlobalType("Boolean"); globalRegExpType = getGlobalType("RegExp"); + jsxElementType = getExportedTypeOfNamespace("JSX", JsxNames.Element); getGlobalClassDecoratorType = memoize(() => getGlobalType("ClassDecorator")); getGlobalPropertyDecoratorType = memoize(() => getGlobalType("PropertyDecorator")); getGlobalMethodDecoratorType = memoize(() => getGlobalType("MethodDecorator")); @@ -12626,7 +13103,6 @@ namespace ts { } // GRAMMAR CHECKING - function checkGrammarDecorators(node: Node): boolean { if (!node.decorators) { return false; @@ -13078,13 +13554,13 @@ namespace ts { let currentKind: number; if (prop.kind === SyntaxKind.PropertyAssignment || prop.kind === SyntaxKind.ShorthandPropertyAssignment) { // Grammar checking for computedPropertName and shorthandPropertyAssignment - checkGrammarForInvalidQuestionMark(prop,(prop).questionToken, Diagnostics.An_object_member_cannot_be_declared_optional); + checkGrammarForInvalidQuestionMark(prop, (prop).questionToken, Diagnostics.An_object_member_cannot_be_declared_optional); if (name.kind === SyntaxKind.NumericLiteral) { checkGrammarNumericLiteral(name); } currentKind = Property; } - else if ( prop.kind === SyntaxKind.MethodDeclaration) { + else if (prop.kind === SyntaxKind.MethodDeclaration) { currentKind = Property; } else if (prop.kind === SyntaxKind.GetAccessor) { @@ -13120,6 +13596,29 @@ namespace ts { } } + function checkGrammarJsxElement(node: JsxOpeningElement|JsxSelfClosingElement) { + const seen: Map = {}; + for (let attr of node.attributes) { + if (attr.kind === SyntaxKind.JsxSpreadAttribute) { + continue; + } + + let jsxAttr = (attr); + let name = jsxAttr.name; + if (!hasProperty(seen, name.text)) { + seen[name.text] = true; + } + else { + return grammarErrorOnNode(name, Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name); + } + + let initializer = jsxAttr.initializer; + if (initializer && initializer.kind === SyntaxKind.JsxExpression && !(initializer).expression) { + return grammarErrorOnNode(jsxAttr.initializer, Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression); + } + } + } + function checkGrammarForInOrForOfStatement(forInOrOfStatement: ForInStatement | ForOfStatement): boolean { if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; @@ -13348,7 +13847,7 @@ namespace ts { } } - let checkLetConstNames = languageVersion >= ScriptTarget.ES6 && (isLet(node) || isConst(node)); + let checkLetConstNames = languageVersion >= ScriptTarget.ES6 && (isLet(node) || isConst(node)); // 1. LexicalDeclaration : LetOrConst BindingList ; // It is a Syntax Error if the BoundNames of BindingList contains "let". @@ -13496,6 +13995,11 @@ namespace ts { } } + function isEvalOrArgumentsIdentifier(node: Node): boolean { + return node.kind === SyntaxKind.Identifier && + ((node).text === "eval" || (node).text === "arguments"); + } + function checkGrammarConstructorTypeParameters(node: ConstructorDeclaration) { if (node.typeParameters) { return grammarErrorAtPos(getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration); From f5336db82ae301f8ac35d69d532270d051a76e81 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:01:49 -0700 Subject: [PATCH 124/309] Emitter for JSX --- src/compiler/emitter.ts | 325 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 310 insertions(+), 15 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 469b13294ad..265690cd680 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -47,16 +47,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return function (target, key) { decorator(target, key, paramIndex); } };`; + let compilerOptions = host.getCompilerOptions(); let languageVersion = compilerOptions.target || ScriptTarget.ES3; let sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined; let diagnostics: Diagnostic[] = []; let newLine = host.getNewLine(); + let jsxDesugaring = host.getCompilerOptions().jsx === JsxEmit.React; if (targetSourceFile === undefined) { forEach(host.getSourceFiles(), sourceFile => { if (shouldEmitToOwnFile(sourceFile, compilerOptions)) { - let jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, ".js"); + let jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, (!sourceFile.isTSXFile || jsxDesugaring) ? ".js" : ".jsx"); emitFile(jsFilePath, sourceFile); } }); @@ -68,7 +70,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { else { // targetSourceFile is specified (e.g calling emitter from language service or calling getSemanticDiagnostic from language service) if (shouldEmitToOwnFile(targetSourceFile, compilerOptions)) { - let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".js"); + let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, (host.getSourceFiles().every(f => !f.isTSXFile) || jsxDesugaring) ? ".js" : ".jsx"); emitFile(jsFilePath, targetSourceFile); } else if (!isDeclarationFile(targetSourceFile) && compilerOptions.out) { @@ -1106,6 +1108,203 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { emit(span.literal); } + function jsxEmitReact(node: JsxElement|JsxSelfClosingElement) { + /// Emit a tag name, which is either '"div"' for lower-cased names, or + /// 'Div' for upper-cased or dotted names + function emitTagName(name: Identifier|QualifiedName) { + if (name.kind === SyntaxKind.Identifier) { + var ch = (name).text.charAt(0); + if (ch.toUpperCase() === ch) { + emit(name); + } + else { + write('"'); + emit(name); + write('"'); + } + return ch.toUpperCase() !== ch; + } + else { + Debug.assert(name.kind === SyntaxKind.QualifiedName); + emit(name); + } + } + + /// Emit an attribute name, which is quoted if it needs to be quoted. Because + /// these emit into an object literal property name, we don't need to be worried + /// about keywords, just non-identifier characters + function emitAttributeName(name: Identifier) { + if (/[A-Za-z_]+[\w*]/.test(name.text)) { + write('"'); + emit(name); + write('"'); + } + else { + emit(name); + } + } + + /// Emit an name/value pair for an attribute (e.g. "x: 3") + function emitJsxAttribute(node: JsxAttribute) { + emitAttributeName(node.name); + write(': '); + emit(node.initializer); + } + + function emitJsxElement(openingNode: JsxOpeningElement|JsxSelfClosingElement, children?: JsxChild[]) { + // Call React.createElement(tag, ... + emitLeadingComments(openingNode); + write('React.createElement('); + emitTagName(openingNode.tagName); + write(', '); + + // Attribute list + if (openingNode.attributes.length === 0) { + // When there are no attributes, React wants 'null' + write('null'); + } + else { + // Either emit one big object literal (no spread attribs), or + // a call to React.__spread + let attrs = openingNode.attributes; + if (attrs.some(attr => attr.kind === SyntaxKind.JsxSpreadAttribute)) { + write('React.__spread('); + + let haveOpenedObjectLiteral = false; + for (var i = 0; i < attrs.length; i++) { + if (attrs[i].kind === SyntaxKind.JsxSpreadAttribute) { + if (haveOpenedObjectLiteral) { + write('}'); + haveOpenedObjectLiteral = false; + } + if (i > 0) write(', '); + emit((attrs[i]).expression); + } + else { + Debug.assert(attrs[i].kind === SyntaxKind.JsxAttribute); + if (haveOpenedObjectLiteral) { + write(', '); + } + else { + haveOpenedObjectLiteral = true; + if (i > 0) write(', '); + write('{'); + } + emitJsxAttribute(attrs[i]); + } + } + if (haveOpenedObjectLiteral) write('}'); + + write(')'); // closing paren to React.__spread( + } + else { + // One object literal with all the attributes in them + write('{'); + for (var i = 0; i < attrs.length; i++) { + if (i > 0) write(', '); + emitJsxAttribute(attrs[i]); + } + write('}'); + } + } + + // Children + if (children) { + for (var i = 0; i < children.length; i++) { + // Don't emit empty expressions + if (children[i].kind === SyntaxKind.JsxExpression && !((children[i]).expression)) continue; + + // Don't emit empty strings + if (children[i].kind === SyntaxKind.JsxText && !shouldEmitJsxText(children[i])) continue; + + write(', '); + emit(children[i]); + } + } + + // Closing paren + write(')'); // closes 'React.createElement(' + emitTrailingComments(openingNode); + } + + if (node.kind === SyntaxKind.JsxElement) { + emitJsxElement((node).openingElement, (node).children); + } + else { + Debug.assert(node.kind === SyntaxKind.JsxSelfClosingElement); + emitJsxElement(node); + } + } + + function jsxEmitPreserve(node: JsxElement|JsxSelfClosingElement) { + function emitJsxAttribute(node: JsxAttribute) { + emit(node.name); + write('='); + emit(node.initializer); + } + + function emitJsxSpreadAttribute(node: JsxSpreadAttribute) { + write('{...'); + emit(node.expression); + write('}'); + } + + function emitAttributes(attribs: NodeArray) { + for (var i = 0, n = attribs.length; i < n; i++) { + if (i > 0) write(' '); + + if (attribs[i].kind === SyntaxKind.JsxSpreadAttribute) { + emitJsxSpreadAttribute(attribs[i]); + } + else { + Debug.assert(attribs[i].kind === SyntaxKind.JsxAttribute); + emitJsxAttribute(attribs[i]); + } + } + } + + function emitJsxOpeningOrSelfClosingElement(node: JsxOpeningElement|JsxSelfClosingElement) { + write('<'); + emit(node.tagName); + if (node.attributes.length > 0 || (node.kind === SyntaxKind.JsxSelfClosingElement)) { + write(' '); + } + + emitAttributes(node.attributes); + + if (node.kind === SyntaxKind.JsxSelfClosingElement) { + write('/>'); + } + else { + write('>'); + } + } + + function emitJsxClosingElement(node: JsxClosingElement) { + write(''); + } + + function emitJsxElement(node: JsxElement) { + emitJsxOpeningOrSelfClosingElement(node.openingElement); + + for (var i = 0, n = node.children.length; i < n; i++) { + emit(node.children[i]); + } + + emitJsxClosingElement(node.closingElement); + } + + if (node.kind === SyntaxKind.JsxElement) { + emitJsxElement(node); + } + else { + Debug.assert(node.kind === SyntaxKind.JsxSelfClosingElement); + emitJsxOpeningOrSelfClosingElement(node); + } + } + // This function specifically handles numeric/string literals for enum and accessor 'identifiers'. // In a sense, it does not actually emit identifiers as much as it declares a name for a specific property. // For example, this is utilized when feeding in a result to Object.defineProperty. @@ -1182,6 +1381,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { case SyntaxKind.ForInStatement: case SyntaxKind.ForOfStatement: case SyntaxKind.IfStatement: + case SyntaxKind.JsxSelfClosingElement: + case SyntaxKind.JsxOpeningElement: case SyntaxKind.NewExpression: case SyntaxKind.ParenthesizedExpression: case SyntaxKind.PostfixUnaryExpression: @@ -1658,8 +1859,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { function parenthesizeForAccess(expr: Expression): LeftHandSideExpression { // When diagnosing whether the expression needs parentheses, the decision should be based // on the innermost expression in a chain of nested type assertions. - while (expr.kind === SyntaxKind.TypeAssertionExpression) { - expr = (expr).expression; + while (expr.kind === SyntaxKind.TypeAssertionExpression || expr.kind === SyntaxKind.AsExpression) { + expr = (expr).expression; } // isLeftHandSideExpression is almost the correct criterion for when it is not necessary @@ -1805,8 +2006,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } function skipParentheses(node: Expression): Expression { - while (node.kind === SyntaxKind.ParenthesizedExpression || node.kind === SyntaxKind.TypeAssertionExpression) { - node = (node).expression; + while (node.kind === SyntaxKind.ParenthesizedExpression || node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression) { + node = (node).expression; } return node; } @@ -1956,12 +2157,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { // not the user. If we didn't want them, the emitter would not have put them // there. if (!nodeIsSynthesized(node) && node.parent.kind !== SyntaxKind.ArrowFunction) { - if (node.expression.kind === SyntaxKind.TypeAssertionExpression) { + if (node.expression.kind === SyntaxKind.TypeAssertionExpression || node.expression.kind === SyntaxKind.AsExpression) { let operand = (node.expression).expression; // Make sure we consider all nested cast expressions, e.g.: // (-A).x; - while (operand.kind === SyntaxKind.TypeAssertionExpression) { + while (operand.kind === SyntaxKind.TypeAssertionExpression || operand.kind === SyntaxKind.AsExpression) { operand = (operand).expression; } @@ -3807,7 +4008,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { emitClassLikeDeclarationForES6AndHigher(node); } } - + function emitClassLikeDeclarationForES6AndHigher(node: ClassLikeDeclaration) { let thisNodeIsDecorated = nodeIsDecorated(node); if (node.kind === SyntaxKind.ClassDeclaration) { @@ -4066,7 +4267,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { write(".prototype"); } } - + function emitDecoratorsOfClass(node: ClassLikeDeclaration) { emitDecoratorsOfMembers(node, /*staticFlag*/ 0); emitDecoratorsOfMembers(node, NodeFlags.Static); @@ -4978,7 +5179,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { let started = false; for (let importNode of externalImports) { // do not create variable declaration for exports and imports that lack import clause - let skipNode = + let skipNode = importNode.kind === SyntaxKind.ExportDeclaration || (importNode.kind === SyntaxKind.ImportDeclaration && !(importNode).importClause) @@ -5075,7 +5276,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { write("};"); return emitExportStarFunction(exportedNamesStorageRef); - + function emitExportStarFunction(localNames: string): string { const exportStarFunction = makeUniqueName("exportStar"); @@ -5102,7 +5303,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return exportStarFunction; } - + function writeExportedName(node: Identifier | Declaration): void { // do not record default exports // they are local to module and never overwritten (explicitly skipped) by star export @@ -5398,7 +5599,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { if (importNode.kind === SyntaxKind.ImportDeclaration && (importNode).importClause.namedBindings) { - + let namedBindings = (importNode).importClause.namedBindings; if (namedBindings.kind === SyntaxKind.NamespaceImport) { // emit re-export for namespace @@ -5657,6 +5858,91 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } } + function emitJsxElement(node: JsxElement|JsxSelfClosingElement) { + switch (compilerOptions.jsx) { + case JsxEmit.React: + jsxEmitReact(node); + break; + // Fall back to preserve if None was specified (we'll error earlier) + default: + jsxEmitPreserve(node); + break; + } + } + + function trimReactWhitespace(node: JsxText): string { + // Could be empty string, do not use !node.formattedReactText + if (node.formattedReactText !== undefined) { + return node.formattedReactText; + } + + let lines: string[] = []; + let text = getTextOfNode(node); + let firstNonWhitespace = 0; + let lastNonWhitespace = -1; + + for (var i = 0; i < text.length; i++) { + var c = text.charCodeAt(i); + if (c === CharacterCodes.lineFeed || c === CharacterCodes.carriageReturn) { + if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) { + lines.push(text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1)); + } + firstNonWhitespace = -1; + } + else if (!isWhiteSpace(c)) { + lastNonWhitespace = i; + if (firstNonWhitespace === -1) { + firstNonWhitespace = i; + } + } + } + if (firstNonWhitespace !== -1) { + lines.push(text.substr(firstNonWhitespace)); + } + + return node.formattedReactText = lines.join('" + \' \' + "'); + } + + function shouldEmitJsxText(node: JsxText) { + if (compilerOptions.jsx === JsxEmit.React) { + return trimReactWhitespace(node).length > 0; + } + else { + return true; + } + } + + function emitJsxText(node: JsxText) { + switch (compilerOptions.jsx) { + case JsxEmit.React: + write('"'); + write(trimReactWhitespace(node)); + write('"'); + break; + + case JsxEmit.Preserve: + default: // Emit JSX-preserve as default when no --jsx flag is specified + write(getTextOfNode(node, true)); + break; + } + } + + function emitJsxExpression(node: JsxExpression) { + if (node.expression && node.expression.kind !== SyntaxKind.OmittedExpression) { + switch (compilerOptions.jsx) { + case JsxEmit.Preserve: + default: + write('{'); + emit(node.expression); + write('}'); + break; + case JsxEmit.React: + emit(node.expression); + break; + } + } + } + function emitDirectivePrologues(statements: Node[], startWithNewLine: boolean): number { for (let i = 0; i < statements.length; ++i) { if (isPrologueDirective(statements[i])) { @@ -5799,7 +6085,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { if (node.kind !== SyntaxKind.Block && node.parent && node.parent.kind === SyntaxKind.ArrowFunction && - (node.parent).body === node && + (node.parent).body === node && compilerOptions.target <= ScriptTarget.ES5) { return false; @@ -5844,6 +6130,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return emitTemplateExpression(node); case SyntaxKind.TemplateSpan: return emitTemplateSpan(node); + case SyntaxKind.JsxElement: + case SyntaxKind.JsxSelfClosingElement: + return emitJsxElement(node); + case SyntaxKind.JsxText: + return emitJsxText(node); + case SyntaxKind.JsxExpression: + return emitJsxExpression(node); case SyntaxKind.QualifiedName: return emitQualifiedName(node); case SyntaxKind.ObjectBindingPattern: @@ -5874,6 +6167,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return emitTaggedTemplateExpression(node); case SyntaxKind.TypeAssertionExpression: return emit((node).expression); + case SyntaxKind.AsExpression: + return emit((node).expression); case SyntaxKind.ParenthesizedExpression: return emitParenExpression(node); case SyntaxKind.FunctionDeclaration: From 6d01a44be05f71730c6c5701dc2796a36a7627e3 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:02:02 -0700 Subject: [PATCH 125/309] Formatting and LS for JSX and As --- src/services/formatting/rules.ts | 1 + src/services/formatting/tokenRange.ts | 2 +- src/services/services.ts | 195 ++++++++++++++++---------- 3 files changed, 124 insertions(+), 74 deletions(-) diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index abb08f5bf22..8c20bab92ad 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -470,6 +470,7 @@ namespace ts.formatting { switch (context.contextNode.kind) { case SyntaxKind.BinaryExpression: case SyntaxKind.ConditionalExpression: + case SyntaxKind.AsExpression: case SyntaxKind.TypePredicate: return true; diff --git a/src/services/formatting/tokenRange.ts b/src/services/formatting/tokenRange.ts index 3391365f328..19185cdf78d 100644 --- a/src/services/formatting/tokenRange.ts +++ b/src/services/formatting/tokenRange.ts @@ -112,7 +112,7 @@ namespace ts.formatting { static AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([SyntaxKind.MultiLineCommentTrivia])); static Keywords = TokenRange.FromRange(SyntaxKind.FirstKeyword, SyntaxKind.LastKeyword); static BinaryOperators = TokenRange.FromRange(SyntaxKind.FirstBinaryOperator, SyntaxKind.LastBinaryOperator); - static BinaryKeywordOperators = TokenRange.FromTokens([SyntaxKind.InKeyword, SyntaxKind.InstanceOfKeyword, SyntaxKind.OfKeyword, SyntaxKind.IsKeyword]); + static BinaryKeywordOperators = TokenRange.FromTokens([SyntaxKind.InKeyword, SyntaxKind.InstanceOfKeyword, SyntaxKind.OfKeyword, SyntaxKind.AsKeyword, SyntaxKind.IsKeyword]); static UnaryPrefixOperators = TokenRange.FromTokens([SyntaxKind.PlusPlusToken, SyntaxKind.MinusMinusToken, SyntaxKind.TildeToken, SyntaxKind.ExclamationToken]); static UnaryPrefixExpressions = TokenRange.FromTokens([SyntaxKind.NumericLiteral, SyntaxKind.Identifier, SyntaxKind.OpenParenToken, SyntaxKind.OpenBracketToken, SyntaxKind.OpenBraceToken, SyntaxKind.ThisKeyword, SyntaxKind.NewKeyword]); static UnaryPreincrementExpressions = TokenRange.FromTokens([SyntaxKind.Identifier, SyntaxKind.OpenParenToken, SyntaxKind.ThisKeyword, SyntaxKind.NewKeyword]); diff --git a/src/services/services.ts b/src/services/services.ts index 70022cfe0bf..7e1aba31d54 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -198,8 +198,8 @@ namespace ts { list._children = []; let pos = nodes.pos; - - + + for (let node of nodes) { if (pos < node.pos) { pos = this.addSyntheticNodes(list._children, pos, node.pos); @@ -737,6 +737,7 @@ namespace ts { public amdDependencies: { name: string; path: string }[]; public moduleName: string; public referencedFiles: FileReference[]; + public isTSXFile: boolean; public syntacticDiagnostics: Diagnostic[]; public referenceDiagnostics: Diagnostic[]; @@ -875,7 +876,7 @@ namespace ts { case SyntaxKind.SetAccessor: case SyntaxKind.TypeLiteral: addDeclaration(node); - // fall through + // fall through case SyntaxKind.Constructor: case SyntaxKind.VariableStatement: case SyntaxKind.VariableDeclarationList: @@ -1095,7 +1096,7 @@ namespace ts { export const definition = "definition"; export const reference = "reference"; export const writtenReference = "writtenReference"; - } + } export interface HighlightSpan { textSpan: TextSpan; @@ -1610,6 +1611,7 @@ namespace ts { return { target: ScriptTarget.ES5, module: ModuleKind.None, + jsx: JsxEmit.Preserve }; } @@ -2895,11 +2897,18 @@ namespace ts { return undefined; } + let location = getTouchingPropertyName(sourceFile, position); + let options = program.getCompilerOptions(); + let jsx = options.jsx !== JsxEmit.None; + let target = options.target; + // Find the node where completion is requested on, in the case of a completion after // a dot, it is the member access expression other wise, it is a request for all // visible symbols in the scope, and the node is the current location. let node = currentToken; let isRightOfDot = false; + let isRightOfOpenTag = false; + if (contextToken && contextToken.kind === SyntaxKind.DotToken && contextToken.parent.kind === SyntaxKind.PropertyAccessExpression) { node = (contextToken.parent).expression; isRightOfDot = true; @@ -2907,11 +2916,11 @@ namespace ts { else if (contextToken && contextToken.kind === SyntaxKind.DotToken && contextToken.parent.kind === SyntaxKind.QualifiedName) { node = (contextToken.parent).left; isRightOfDot = true; + } else if (contextToken && contextToken.kind === SyntaxKind.LessThanToken && sourceFile.isTSXFile) { + isRightOfOpenTag = true; + location = contextToken; } - let location = getTouchingPropertyName(sourceFile, position); - var target = program.getCompilerOptions().target; - let semanticStart = new Date().getTime(); let isMemberCompletion: boolean; let isNewIdentifierLocation: boolean; @@ -2920,6 +2929,17 @@ namespace ts { if (isRightOfDot) { getTypeScriptMemberSymbols(); } + else if (isRightOfOpenTag) { + // TODO include all in-scope value identifiers + let tagSymbols = typeChecker.getJsxIntrinsicTagNames();; + if (tryGetGlobalSymbols()) { + symbols = tagSymbols.concat(symbols.filter(s => !!(s.flags & SymbolFlags.Value))); + } else { + symbols = tagSymbols; + } + isMemberCompletion = true; + isNewIdentifierLocation = false; + } else { // For JavaScript or TypeScript, if we're not after a dot, then just try to get the // global symbols in scope. These results should be valid for either language as @@ -2931,7 +2951,7 @@ namespace ts { log("getCompletionData: Semantic work: " + (new Date().getTime() - semanticStart)); - return { symbols, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot }; + return { symbols, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot: (isRightOfDot || isRightOfOpenTag) }; function getTypeScriptMemberSymbols(): void { // Right of dot member completion list @@ -2986,6 +3006,7 @@ namespace ts { function tryGetGlobalSymbols(): boolean { let containingObjectLiteral = getContainingObjectLiteralApplicableForCompletion(contextToken); + let jsxElement: JsxElement, jsxSelfClosingElement: JsxSelfClosingElement; if (containingObjectLiteral) { // Object literal expression, look up possible property names from contextual type isMemberCompletion = true; @@ -3001,6 +3022,7 @@ namespace ts { // Add filtered items to the completion list symbols = filterContextualMembersList(contextualTypeMembers, containingObjectLiteral.properties); } + return true; } else if (getAncestor(contextToken, SyntaxKind.ImportClause)) { // cursor is in import clause @@ -3022,51 +3044,77 @@ namespace ts { //let exports = typeInfoResolver.getExportsOfImportDeclaration(importDeclaration); symbols = exports ? filterModuleExports(exports, importDeclaration) : emptyArray; } + return true; } - else { - // Get all entities in the current scope. - isMemberCompletion = false; - isNewIdentifierLocation = isNewIdentifierDefinitionLocation(contextToken); + else if (getAncestor(contextToken, SyntaxKind.JsxElement) || getAncestor(contextToken, SyntaxKind.JsxSelfClosingElement)) { + // Go up until we hit either the element or expression + let jsxNode = contextToken; - if (previousToken !== contextToken) { - Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'."); + while (jsxNode) { + if (jsxNode.kind === SyntaxKind.JsxExpression) { + // Defer to global completion if we're inside an {expression} + break; + } else if (jsxNode.kind === SyntaxKind.JsxSelfClosingElement || jsxNode.kind === SyntaxKind.JsxElement) { + let attrsType: Type; + if (jsxNode.kind === SyntaxKind.JsxSelfClosingElement) { + // Cursor is inside a JSX self-closing element + attrsType = typeChecker.getJsxElementAttributesType(jsxNode); + } + else { + Debug.assert(jsxNode.kind === SyntaxKind.JsxElement); + // Cursor is inside a JSX element + attrsType = typeChecker.getJsxElementAttributesType((jsxNode).openingElement); + } + symbols = typeChecker.getPropertiesOfType(attrsType); + isMemberCompletion = true; + return true; + } + jsxNode = jsxNode.parent; } - // We need to find the node that will give us an appropriate scope to begin - // aggregating completion candidates. This is achieved in 'getScopeNode' - // by finding the first node that encompasses a position, accounting for whether a node - // is "complete" to decide whether a position belongs to the node. - // - // However, at the end of an identifier, we are interested in the scope of the identifier - // itself, but fall outside of the identifier. For instance: - // - // xyz => x$ - // - // the cursor is outside of both the 'x' and the arrow function 'xyz => x', - // so 'xyz' is not returned in our results. - // - // We define 'adjustedPosition' so that we may appropriately account for - // being at the end of an identifier. The intention is that if requesting completion - // at the end of an identifier, it should be effectively equivalent to requesting completion - // anywhere inside/at the beginning of the identifier. So in the previous case, the - // 'adjustedPosition' will work as if requesting completion in the following: - // - // xyz => $x - // - // If previousToken !== contextToken, then - // - 'contextToken' was adjusted to the token prior to 'previousToken' - // because we were at the end of an identifier. - // - 'previousToken' is defined. - let adjustedPosition = previousToken !== contextToken ? - previousToken.getStart() : - position; - - let scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile; - - /// TODO filter meaning based on the current context - let symbolMeanings = SymbolFlags.Type | SymbolFlags.Value | SymbolFlags.Namespace | SymbolFlags.Alias; - symbols = typeChecker.getSymbolsInScope(scopeNode, symbolMeanings); } + // Get all entities in the current scope. + isMemberCompletion = false; + isNewIdentifierLocation = isNewIdentifierDefinitionLocation(contextToken); + + if (previousToken !== contextToken) { + Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'."); + } + // We need to find the node that will give us an appropriate scope to begin + // aggregating completion candidates. This is achieved in 'getScopeNode' + // by finding the first node that encompasses a position, accounting for whether a node + // is "complete" to decide whether a position belongs to the node. + // + // However, at the end of an identifier, we are interested in the scope of the identifier + // itself, but fall outside of the identifier. For instance: + // + // xyz => x$ + // + // the cursor is outside of both the 'x' and the arrow function 'xyz => x', + // so 'xyz' is not returned in our results. + // + // We define 'adjustedPosition' so that we may appropriately account for + // being at the end of an identifier. The intention is that if requesting completion + // at the end of an identifier, it should be effectively equivalent to requesting completion + // anywhere inside/at the beginning of the identifier. So in the previous case, the + // 'adjustedPosition' will work as if requesting completion in the following: + // + // xyz => $x + // + // If previousToken !== contextToken, then + // - 'contextToken' was adjusted to the token prior to 'previousToken' + // because we were at the end of an identifier. + // - 'previousToken' is defined. + let adjustedPosition = previousToken !== contextToken ? + previousToken.getStart() : + position; + + let scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile; + + /// TODO filter meaning based on the current context + let symbolMeanings = SymbolFlags.Type | SymbolFlags.Value | SymbolFlags.Namespace | SymbolFlags.Alias; + symbols = typeChecker.getSymbolsInScope(scopeNode, symbolMeanings); + return true; } @@ -4200,7 +4248,7 @@ namespace ts { function getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] { let results = getOccurrencesAtPositionCore(fileName, position); - + if (results) { let sourceFile = getCanonicalFileName(normalizeSlashes(fileName)); @@ -4869,7 +4917,7 @@ namespace ts { return convertReferences(referencedSymbols); } - function findReferences(fileName: string, position: number): ReferencedSymbol[]{ + function findReferences(fileName: string, position: number): ReferencedSymbol[] { var referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings:*/ false, /*findInComments:*/ false); // Only include referenced symbols that have a valid definition. @@ -5804,7 +5852,7 @@ namespace ts { } function isTypeReference(node: Node): boolean { - if (isRightSideOfQualifiedNameOrPropertyAccess(node) ) { + if (isRightSideOfQualifiedNameOrPropertyAccess(node)) { node = node.parent; } @@ -5973,13 +6021,13 @@ namespace ts { return BreakpointResolver.spanInSourceFileAtLocation(sourceFile, position); } - function getNavigationBarItems(fileName: string): NavigationBarItem[]{ + function getNavigationBarItems(fileName: string): NavigationBarItem[] { let sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return NavigationBar.getNavigationBarItems(sourceFile); } - function getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]{ + function getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[] { return convertClassifications(getEncodedSemanticClassifications(fileName, span)); } @@ -6108,7 +6156,7 @@ namespace ts { return result; } - function getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]{ + function getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[] { return convertClassifications(getEncodedSyntacticClassifications(fileName, span)); } @@ -6471,14 +6519,14 @@ namespace ts { function getMatchingTokenKind(token: Node): ts.SyntaxKind { switch (token.kind) { - case ts.SyntaxKind.OpenBraceToken: return ts.SyntaxKind.CloseBraceToken - case ts.SyntaxKind.OpenParenToken: return ts.SyntaxKind.CloseParenToken; - case ts.SyntaxKind.OpenBracketToken: return ts.SyntaxKind.CloseBracketToken; - case ts.SyntaxKind.LessThanToken: return ts.SyntaxKind.GreaterThanToken; - case ts.SyntaxKind.CloseBraceToken: return ts.SyntaxKind.OpenBraceToken - case ts.SyntaxKind.CloseParenToken: return ts.SyntaxKind.OpenParenToken; - case ts.SyntaxKind.CloseBracketToken: return ts.SyntaxKind.OpenBracketToken; - case ts.SyntaxKind.GreaterThanToken: return ts.SyntaxKind.LessThanToken; + case ts.SyntaxKind.OpenBraceToken: return ts.SyntaxKind.CloseBraceToken + case ts.SyntaxKind.OpenParenToken: return ts.SyntaxKind.CloseParenToken; + case ts.SyntaxKind.OpenBracketToken: return ts.SyntaxKind.CloseBracketToken; + case ts.SyntaxKind.LessThanToken: return ts.SyntaxKind.GreaterThanToken; + case ts.SyntaxKind.CloseBraceToken: return ts.SyntaxKind.OpenBraceToken + case ts.SyntaxKind.CloseParenToken: return ts.SyntaxKind.OpenParenToken; + case ts.SyntaxKind.CloseBracketToken: return ts.SyntaxKind.OpenBracketToken; + case ts.SyntaxKind.GreaterThanToken: return ts.SyntaxKind.LessThanToken; } return undefined; @@ -6693,6 +6741,7 @@ namespace ts { if (defaultLibFileName) { for (let current of declarations) { let sourceFile = current.getSourceFile(); + var canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile.fileName)); if (sourceFile && getCanonicalFileName(ts.normalizePath(sourceFile.fileName)) === getCanonicalFileName(ts.normalizePath(defaultLibFileName))) { return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library.key)); } @@ -6921,7 +6970,7 @@ namespace ts { case ClassificationType.stringLiteral: return TokenClass.StringLiteral; case ClassificationType.whiteSpace: return TokenClass.Whitespace; case ClassificationType.punctuation: return TokenClass.Punctuation; - case ClassificationType.identifier: + case ClassificationType.identifier: case ClassificationType.className: case ClassificationType.enumName: case ClassificationType.interfaceName: @@ -6976,7 +7025,7 @@ namespace ts { case EndOfLineState.InTemplateMiddleOrTail: text = "}\n" + text; offset = 2; - // fallthrough + // fallthrough case EndOfLineState.InTemplateSubstitutionPosition: templateStack.push(SyntaxKind.TemplateHead); break; @@ -7015,9 +7064,9 @@ namespace ts { if (!isTrivia(token)) { if ((token === SyntaxKind.SlashToken || token === SyntaxKind.SlashEqualsToken) && !noRegexTable[lastNonTriviaToken]) { - if (scanner.reScanSlashToken() === SyntaxKind.RegularExpressionLiteral) { - token = SyntaxKind.RegularExpressionLiteral; - } + if (scanner.reScanSlashToken() === SyntaxKind.RegularExpressionLiteral) { + token = SyntaxKind.RegularExpressionLiteral; + } } else if (lastNonTriviaToken === SyntaxKind.DotToken && isKeyword(token)) { token = SyntaxKind.Identifier; @@ -7030,7 +7079,7 @@ namespace ts { token = SyntaxKind.Identifier; } else if (lastNonTriviaToken === SyntaxKind.Identifier && - token === SyntaxKind.LessThanToken) { + token === SyntaxKind.LessThanToken) { // Could be the start of something generic. Keep track of that by bumping // up the current count of generic contexts we may be in. angleBracketStack++; @@ -7041,10 +7090,10 @@ namespace ts { angleBracketStack--; } else if (token === SyntaxKind.AnyKeyword || - token === SyntaxKind.StringKeyword || - token === SyntaxKind.NumberKeyword || - token === SyntaxKind.BooleanKeyword || - token === SyntaxKind.SymbolKeyword) { + token === SyntaxKind.StringKeyword || + token === SyntaxKind.NumberKeyword || + token === SyntaxKind.BooleanKeyword || + token === SyntaxKind.SymbolKeyword) { if (angleBracketStack > 0 && !syntacticClassifierAbsent) { // If it looks like we're could be in something generic, don't classify this // as a keyword. We may just get overwritten by the syntactic classifier, @@ -7280,7 +7329,7 @@ namespace ts { declare let __dirname: string; /** - * Get the path of the default library file (lib.d.ts) as distributed with the typescript + * Get the path of the default library files (lib.d.ts) as distributed with the typescript * node package. * The functionality is not supported if the ts module is consumed outside of a node module. */ From e34d8cdccbd127e9e99b93960db4afafaa61e246 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:02:22 -0700 Subject: [PATCH 126/309] Test support for TSX files --- src/harness/compilerRunner.ts | 16 ++++++++-------- src/harness/harness.ts | 33 ++++++++++++++++++++++++++++----- src/harness/runnerbase.ts | 2 +- 3 files changed, 37 insertions(+), 14 deletions(-) diff --git a/src/harness/compilerRunner.ts b/src/harness/compilerRunner.ts index 21e88b9e41a..1b399e1b706 100644 --- a/src/harness/compilerRunner.ts +++ b/src/harness/compilerRunner.ts @@ -149,7 +149,7 @@ class CompilerBaselineRunner extends RunnerBase { // check errors it('Correct errors for ' + fileName, () => { if (this.errors) { - Harness.Baseline.runBaseline('Correct errors for ' + fileName, justName.replace(/\.ts$/, '.errors.txt'), (): string => { + Harness.Baseline.runBaseline('Correct errors for ' + fileName, justName.replace(/\.tsx?$/, '.errors.txt'), (): string => { if (result.errors.length === 0) return null; return getErrorBaseline(toBeCompiled, otherFiles, result); }); @@ -159,7 +159,7 @@ class CompilerBaselineRunner extends RunnerBase { // Source maps? it('Correct sourcemap content for ' + fileName, () => { if (options.sourceMap || options.inlineSourceMap) { - Harness.Baseline.runBaseline('Correct sourcemap content for ' + fileName, justName.replace(/\.ts$/, '.sourcemap.txt'), () => { + Harness.Baseline.runBaseline('Correct sourcemap content for ' + fileName, justName.replace(/\.tsx?$/, '.sourcemap.txt'), () => { var record = result.getSourceMapRecord(); if (options.noEmitOnError && result.errors.length !== 0 && record === undefined) { // Because of the noEmitOnError option no files are created. We need to return null because baselining isn't required. @@ -177,7 +177,7 @@ class CompilerBaselineRunner extends RunnerBase { } // check js output - Harness.Baseline.runBaseline('Correct JS output for ' + fileName, justName.replace(/\.ts/, '.js'), () => { + Harness.Baseline.runBaseline('Correct JS output for ' + fileName, justName.replace(/\.tsx?/, '.js'), () => { var tsCode = ''; var tsSources = otherFiles.concat(toBeCompiled); if (tsSources.length > 1) { @@ -235,7 +235,7 @@ class CompilerBaselineRunner extends RunnerBase { throw new Error('Number of sourcemap files should be same as js files.'); } - Harness.Baseline.runBaseline('Correct Sourcemap output for ' + fileName, justName.replace(/\.ts/, '.js.map'), () => { + Harness.Baseline.runBaseline('Correct Sourcemap output for ' + fileName, justName.replace(/\.tsx?/, '.js.map'), () => { if (options.noEmitOnError && result.errors.length !== 0 && result.sourceMaps.length === 0) { // We need to return null here or the runBaseLine will actually create a empty file. // Baselining isn't required here because there is no output. @@ -320,11 +320,11 @@ class CompilerBaselineRunner extends RunnerBase { let pullExtension = isSymbolBaseLine ? '.symbols.pull' : '.types.pull'; if (fullBaseLine !== pullBaseLine) { - Harness.Baseline.runBaseline('Correct full information for ' + fileName, justName.replace(/\.ts/, fullExtension), () => fullBaseLine); - Harness.Baseline.runBaseline('Correct pull information for ' + fileName, justName.replace(/\.ts/, pullExtension), () => pullBaseLine); + Harness.Baseline.runBaseline('Correct full information for ' + fileName, justName.replace(/\.tsx?/, fullExtension), () => fullBaseLine); + Harness.Baseline.runBaseline('Correct pull information for ' + fileName, justName.replace(/\.tsx?/, pullExtension), () => pullBaseLine); } else { - Harness.Baseline.runBaseline('Correct information for ' + fileName, justName.replace(/\.ts/, fullExtension), () => fullBaseLine); + Harness.Baseline.runBaseline('Correct information for ' + fileName, justName.replace(/\.tsx?/, fullExtension), () => fullBaseLine); } } @@ -391,7 +391,7 @@ class CompilerBaselineRunner extends RunnerBase { // this will set up a series of describe/it blocks to run between the setup and cleanup phases if (this.tests.length === 0) { - var testFiles = this.enumerateFiles(this.basePath, /\.ts$/, { recursive: true }); + var testFiles = this.enumerateFiles(this.basePath, /\.tsx?$/, { recursive: true }); testFiles.forEach(fn => { fn = fn.replace(/\\/g, "/"); this.checkTestCodeOutput(fn); diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 6a559488150..0ea7db33fe1 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -212,7 +212,7 @@ module Utils { } var result = ""; - ts.forEach(Object.getOwnPropertyNames(flags),(v: any) => { + ts.forEach(Object.getOwnPropertyNames(flags), (v: any) => { if (isFinite(v)) { v = +v; if (f === +v) { @@ -410,7 +410,7 @@ module Harness { deleteFile(fileName: string): void; listFiles(path: string, filter: RegExp, options?: { recursive?: boolean }): string[]; log(text: string): void; - getMemoryUsage? (): number; + getMemoryUsage?(): number; } module IOImpl { @@ -794,7 +794,7 @@ module Harness { public reset() { this.fileCollection = {}; } - public toArray(): { fileName: string; file: WriterAggregator; }[]{ + public toArray(): { fileName: string; file: WriterAggregator; }[] { var result: { fileName: string; file: WriterAggregator; }[] = []; for (var p in this.fileCollection) { if (this.fileCollection.hasOwnProperty(p)) { @@ -1166,6 +1166,12 @@ module Harness { options.inlineSources = setting.value === 'true'; break; + case 'jsx': + options.jsx = setting.value.toLowerCase() === 'react' ? ts.JsxEmit.React : + setting.value.toLowerCase() === 'preserve' ? ts.JsxEmit.Preserve : + ts.JsxEmit.None; + break; + default: throw new Error('Unsupported compiler setting ' + setting.flag); } @@ -1229,7 +1235,7 @@ module Harness { } var dTsFileName = ts.removeFileExtension(sourceFileName) + ".d.ts"; - + return ts.forEach(result.declFilesCode, declFile => declFile.fileName === dTsFileName ? declFile : undefined); } @@ -1428,6 +1434,10 @@ module Harness { return stringEndsWith(fileName, '.ts'); } + export function isTSX(fileName: string) { + return stringEndsWith(fileName, '.tsx'); + } + export function isDTS(fileName: string) { return stringEndsWith(fileName, '.d.ts'); } @@ -1435,6 +1445,9 @@ module Harness { export function isJS(fileName: string) { return stringEndsWith(fileName, '.js'); } + export function isJSX(fileName: string) { + return stringEndsWith(fileName, '.jsx'); + } export function isJSMap(fileName: string) { return stringEndsWith(fileName, '.js.map'); @@ -1455,7 +1468,7 @@ module Harness { if (isDTS(emittedFile.fileName)) { // .d.ts file, add to declFiles emit this.declFilesCode.push(emittedFile); - } else if (isJS(emittedFile.fileName)) { + } else if (isJS(emittedFile.fileName) || isJSX(emittedFile.fileName)) { // .js file, add to files this.files.push(emittedFile); } else if (isJSMap(emittedFile.fileName)) { @@ -1495,6 +1508,16 @@ module Harness { // Regex for parsing options in the format "@Alpha: Value of any sort" var optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm; // multiple matches on multiple lines + // List of allowed metadata names + var fileMetadataNames = ["filename", "comments", "declaration", "module", + "nolib", "sourcemap", "target", "out", "outdir", "noemithelpers", "noemitonerror", + "noimplicitany", "noresolve", "newline", "normalizenewline", "emitbom", + "errortruncation", "usecasesensitivefilenames", "preserveconstenums", + "includebuiltfile", "suppressimplicitanyindexerrors", "stripinternal", + "isolatedmodules", "inlinesourcemap", "maproot", "sourceroot", + "inlinesources", "emitdecoratormetadata", "experimentaldecorators", + "skipdefaultlibcheck", "jsx"]; + function extractCompilerSettings(content: string): CompilerSetting[] { var opts: CompilerSetting[] = []; diff --git a/src/harness/runnerbase.ts b/src/harness/runnerbase.ts index 269e889704c..fa8d9d2c597 100644 --- a/src/harness/runnerbase.ts +++ b/src/harness/runnerbase.ts @@ -27,7 +27,7 @@ class RunnerBase { var fixedPath = path; // full paths either start with a drive letter or / for *nix, shouldn't have \ in the path at this point - var fullPath = /(\w+:|\/)?([\w+\-\.]|\/)*\.ts/g; + var fullPath = /(\w+:|\/)?([\w+\-\.]|\/)*\.tsx?/g; var fullPathList = fixedPath.match(fullPath); if (fullPathList) { fullPathList.forEach((match: string) => fixedPath = fixedPath.replace(match, Harness.Path.getFileName(match))); From fa198a5cef50c4767e39f0414a6db45abfc86ea4 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:02:47 -0700 Subject: [PATCH 127/309] Fourslash tests for JSX and As --- tests/cases/fourslash/asOperatorFormatting.ts | 7 +++++ .../fourslash/server/tsxIncrementalServer.ts | 13 +++++++++ tests/cases/fourslash/tsxCompletion1.ts | 14 +++++++++ tests/cases/fourslash/tsxCompletion2.ts | 15 ++++++++++ .../fourslash/tsxGoToDefinitionClasses.ts | 23 +++++++++++++++ .../fourslash/tsxGoToDefinitionIntrinsics.ts | 29 +++++++++++++++++++ tests/cases/fourslash/tsxIncremental.ts | 13 +++++++++ tests/cases/fourslash/tsxParsing.ts | 5 ++++ tests/cases/fourslash/tsxRename1.ts | 17 +++++++++++ tests/cases/fourslash/tsxRename2.ts | 17 +++++++++++ tests/cases/fourslash/tsxRename3.ts | 20 +++++++++++++ 11 files changed, 173 insertions(+) create mode 100644 tests/cases/fourslash/asOperatorFormatting.ts create mode 100644 tests/cases/fourslash/server/tsxIncrementalServer.ts create mode 100644 tests/cases/fourslash/tsxCompletion1.ts create mode 100644 tests/cases/fourslash/tsxCompletion2.ts create mode 100644 tests/cases/fourslash/tsxGoToDefinitionClasses.ts create mode 100644 tests/cases/fourslash/tsxGoToDefinitionIntrinsics.ts create mode 100644 tests/cases/fourslash/tsxIncremental.ts create mode 100644 tests/cases/fourslash/tsxParsing.ts create mode 100644 tests/cases/fourslash/tsxRename1.ts create mode 100644 tests/cases/fourslash/tsxRename2.ts create mode 100644 tests/cases/fourslash/tsxRename3.ts diff --git a/tests/cases/fourslash/asOperatorFormatting.ts b/tests/cases/fourslash/asOperatorFormatting.ts new file mode 100644 index 00000000000..f697ffd8bb6 --- /dev/null +++ b/tests/cases/fourslash/asOperatorFormatting.ts @@ -0,0 +1,7 @@ +/// + +//// /**/var x = 3 as number; + +goTo.marker(); +format.document(); +verify.currentLineContentIs("var x = 3 as number;"); diff --git a/tests/cases/fourslash/server/tsxIncrementalServer.ts b/tests/cases/fourslash/server/tsxIncrementalServer.ts new file mode 100644 index 00000000000..9ae51406c2f --- /dev/null +++ b/tests/cases/fourslash/server/tsxIncrementalServer.ts @@ -0,0 +1,13 @@ +/// + +//// /**/ + +goTo.marker(); +edit.insert("<"); +edit.insert("div"); +edit.insert(" "); +edit.insert(" id"); +edit.insert("="); +edit.insert("\"foo"); +edit.insert("\""); +edit.insert(">"); diff --git a/tests/cases/fourslash/tsxCompletion1.ts b/tests/cases/fourslash/tsxCompletion1.ts new file mode 100644 index 00000000000..f638b0b6e4f --- /dev/null +++ b/tests/cases/fourslash/tsxCompletion1.ts @@ -0,0 +1,14 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// div: { ONE: string; TWO: number; } +//// } +//// } +//// var x =
; + +goTo.marker(); +verify.completionListContains('ONE'); +verify.completionListContains('TWO'); diff --git a/tests/cases/fourslash/tsxCompletion2.ts b/tests/cases/fourslash/tsxCompletion2.ts new file mode 100644 index 00000000000..d33f9106877 --- /dev/null +++ b/tests/cases/fourslash/tsxCompletion2.ts @@ -0,0 +1,15 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// } +//// interface ElementAttributesProperty { props; } +//// } +//// class MyComp { props: { ONE: string; TWO: number } } +//// var x = ; + +goTo.marker(); +verify.completionListContains('ONE'); +verify.completionListContains('TWO'); diff --git a/tests/cases/fourslash/tsxGoToDefinitionClasses.ts b/tests/cases/fourslash/tsxGoToDefinitionClasses.ts new file mode 100644 index 00000000000..11ff3afeb8a --- /dev/null +++ b/tests/cases/fourslash/tsxGoToDefinitionClasses.ts @@ -0,0 +1,23 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { } +//// interface ElementAttributesProperty { props; } +//// } +//// /*ct*/class MyClass { +//// props: { +//// /*pt*/foo: string; +//// } +//// } +//// var x = ; +//// var y = ; + +goTo.marker('c'); +goTo.definition(); +verify.caretAtMarker('ct'); + +goTo.marker('p'); +goTo.definition(); +verify.caretAtMarker('pt'); diff --git a/tests/cases/fourslash/tsxGoToDefinitionIntrinsics.ts b/tests/cases/fourslash/tsxGoToDefinitionIntrinsics.ts new file mode 100644 index 00000000000..bbdf395e478 --- /dev/null +++ b/tests/cases/fourslash/tsxGoToDefinitionIntrinsics.ts @@ -0,0 +1,29 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// /*dt*/div: { +//// /*pt*/name?: string; +//// isOpen?: boolean; +//// }; +//// /*st*/span: { n: string; }; +//// } +//// } +//// var x = ; +//// var y = ; +//// var z =
; + +goTo.marker('ds'); +goTo.definition(); +verify.caretAtMarker('dt'); + +goTo.marker('ss'); +goTo.definition(); +verify.caretAtMarker('st'); + +goTo.marker('ps'); +goTo.definition(); +verify.caretAtMarker('pt'); + diff --git a/tests/cases/fourslash/tsxIncremental.ts b/tests/cases/fourslash/tsxIncremental.ts new file mode 100644 index 00000000000..c901401fff9 --- /dev/null +++ b/tests/cases/fourslash/tsxIncremental.ts @@ -0,0 +1,13 @@ +/// + +//// /**/ + +goTo.marker(); +edit.insert("<"); +edit.insert("div"); +edit.insert(" "); +edit.insert(" id"); +edit.insert("="); +edit.insert("\"foo"); +edit.insert("\""); +edit.insert(">"); diff --git a/tests/cases/fourslash/tsxParsing.ts b/tests/cases/fourslash/tsxParsing.ts new file mode 100644 index 00000000000..e5b2e7ea841 --- /dev/null +++ b/tests/cases/fourslash/tsxParsing.ts @@ -0,0 +1,5 @@ +//// var x =
; +//// var y = /**/x; + +goTo.marker(); +verify.quickInfoExists(); diff --git a/tests/cases/fourslash/tsxRename1.ts b/tests/cases/fourslash/tsxRename1.ts new file mode 100644 index 00000000000..3fb973ec996 --- /dev/null +++ b/tests/cases/fourslash/tsxRename1.ts @@ -0,0 +1,17 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// [|div|]: { +//// name?: string; +//// isOpen?: boolean; +//// }; +//// span: { n: string; }; +//// } +//// } +//// var x = <[|di/*ds*/v|] />; + +goTo.marker('ds'); +verify.renameLocations(false, false); diff --git a/tests/cases/fourslash/tsxRename2.ts b/tests/cases/fourslash/tsxRename2.ts new file mode 100644 index 00000000000..d0f5737214b --- /dev/null +++ b/tests/cases/fourslash/tsxRename2.ts @@ -0,0 +1,17 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// div: { +//// [|name|]?: string; +//// isOpen?: boolean; +//// }; +//// span: { n: string; }; +//// } +//// } +//// var x =
; + +goTo.marker(); +verify.renameLocations(false, false); diff --git a/tests/cases/fourslash/tsxRename3.ts b/tests/cases/fourslash/tsxRename3.ts new file mode 100644 index 00000000000..1ab9c8a5915 --- /dev/null +++ b/tests/cases/fourslash/tsxRename3.ts @@ -0,0 +1,20 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// } +//// interface ElementAttributesProperty { props } +//// } +//// class MyClass { +//// props: { +//// [|name|]?: string; +//// size?: number; +//// } +//// +//// +//// var x = ; + +goTo.marker(); +verify.renameLocations(false, false); From 2b44dcac4d3e5d40a0ad0f46d534ad26ba3050da Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:03:14 -0700 Subject: [PATCH 128/309] Conformance tests for 'as' operator --- .../conformance/expressions/asOperator/asOperator1.ts | 8 ++++++++ .../conformance/expressions/asOperator/asOperator2.ts | 1 + .../conformance/expressions/asOperator/asOperator3.ts | 10 ++++++++++ .../expressions/asOperator/asOperatorASI.ts | 10 ++++++++++ .../expressions/asOperator/asOperatorAmbiguity.ts | 8 ++++++++ .../expressions/asOperator/asOperatorContextualType.ts | 2 ++ .../expressions/asOperator/asOperatorNames.ts | 4 ++++ 7 files changed, 43 insertions(+) create mode 100644 tests/cases/conformance/expressions/asOperator/asOperator1.ts create mode 100644 tests/cases/conformance/expressions/asOperator/asOperator2.ts create mode 100644 tests/cases/conformance/expressions/asOperator/asOperator3.ts create mode 100644 tests/cases/conformance/expressions/asOperator/asOperatorASI.ts create mode 100644 tests/cases/conformance/expressions/asOperator/asOperatorAmbiguity.ts create mode 100644 tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts create mode 100644 tests/cases/conformance/expressions/asOperator/asOperatorNames.ts diff --git a/tests/cases/conformance/expressions/asOperator/asOperator1.ts b/tests/cases/conformance/expressions/asOperator/asOperator1.ts new file mode 100644 index 00000000000..cf953d75ab4 --- /dev/null +++ b/tests/cases/conformance/expressions/asOperator/asOperator1.ts @@ -0,0 +1,8 @@ +var as = 43; +var x = undefined as number; +var y = (null as string).length; +var z = Date as any as string; + +// Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string' +var j = 32 as number|string; +j = ''; diff --git a/tests/cases/conformance/expressions/asOperator/asOperator2.ts b/tests/cases/conformance/expressions/asOperator/asOperator2.ts new file mode 100644 index 00000000000..1fa5f2c938d --- /dev/null +++ b/tests/cases/conformance/expressions/asOperator/asOperator2.ts @@ -0,0 +1 @@ +var x = 23 as string; diff --git a/tests/cases/conformance/expressions/asOperator/asOperator3.ts b/tests/cases/conformance/expressions/asOperator/asOperator3.ts new file mode 100644 index 00000000000..4c136247e00 --- /dev/null +++ b/tests/cases/conformance/expressions/asOperator/asOperator3.ts @@ -0,0 +1,10 @@ +declare function tag(...x: any[]): any; + +var a = `${123 + 456 as number}`; +var b = `leading ${123 + 456 as number}`; +var c = `${123 + 456 as number} trailing`; +var d = `Hello ${123} World` as string; +var e = `Hello` as string; +var f = 1 + `${1} end of string` as string; +var g = tag `Hello ${123} World` as string; +var h = tag `Hello` as string; \ No newline at end of file diff --git a/tests/cases/conformance/expressions/asOperator/asOperatorASI.ts b/tests/cases/conformance/expressions/asOperator/asOperatorASI.ts new file mode 100644 index 00000000000..a4dd44a15ad --- /dev/null +++ b/tests/cases/conformance/expressions/asOperator/asOperatorASI.ts @@ -0,0 +1,10 @@ +class Foo { } +declare function as(...args: any[]); + +// Example 1 +var x = 10 +as `Hello world`; // should not error + +// Example 2 +var y = 20 +as(Foo); // should emit diff --git a/tests/cases/conformance/expressions/asOperator/asOperatorAmbiguity.ts b/tests/cases/conformance/expressions/asOperator/asOperatorAmbiguity.ts new file mode 100644 index 00000000000..e4921314ba7 --- /dev/null +++ b/tests/cases/conformance/expressions/asOperator/asOperatorAmbiguity.ts @@ -0,0 +1,8 @@ +interface A { x: T; } +interface B { m: string; } + +// Make sure this is a type assertion to an array type, and not nested comparison operators. +var x: any; +var y = x as A[]; +var z = y[0].m; // z should be string + diff --git a/tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts b/tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts new file mode 100644 index 00000000000..d3a23e224ba --- /dev/null +++ b/tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts @@ -0,0 +1,2 @@ +// should error +var x = (v => v) as (x: number) => string; \ No newline at end of file diff --git a/tests/cases/conformance/expressions/asOperator/asOperatorNames.ts b/tests/cases/conformance/expressions/asOperator/asOperatorNames.ts new file mode 100644 index 00000000000..a0b54d43e84 --- /dev/null +++ b/tests/cases/conformance/expressions/asOperator/asOperatorNames.ts @@ -0,0 +1,4 @@ +var a = 20; +var b = a as string; +var as = "hello"; +var as1 = as as string; From bc9b53a6fe3ef8f6bcad049ec05270ec35626470 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:03:43 -0700 Subject: [PATCH 129/309] Conformance tests for JSX --- .../conformance/jsx/jsxAndTypeAssertion.tsx | 22 ++++ .../conformance/jsx/jsxEsprimaFbTestSuite.tsx | 54 ++++++++ .../jsx/jsxInvalidEsprimaTestSuite.tsx | 36 ++++++ .../conformance/jsx/jsxReactTestSuite.tsx | 117 ++++++++++++++++++ .../conformance/jsx/tsxAttributeErrors.tsx | 26 ++++ .../jsx/tsxAttributeInvalidNames.tsx | 12 ++ .../jsx/tsxAttributeResolution.tsx | 9 ++ .../jsx/tsxAttributeResolution1.jsx | 15 +++ .../jsx/tsxAttributeResolution1.tsx | 33 +++++ .../jsx/tsxAttributeResolution2.jsx | 5 + .../jsx/tsxAttributeResolution2.tsx | 19 +++ .../jsx/tsxAttributeResolution3.jsx | 21 ++++ .../jsx/tsxAttributeResolution3.tsx | 41 ++++++ .../jsx/tsxAttributeResolution4.jsx | 4 + .../jsx/tsxAttributeResolution4.tsx | 17 +++ .../jsx/tsxAttributeResolution5.jsx | 11 ++ .../jsx/tsxAttributeResolution5.tsx | 32 +++++ .../jsx/tsxAttributeResolution6.tsx | 19 +++ .../jsx/tsxAttributeResolution7.tsx | 16 +++ .../conformance/jsx/tsxElementResolution.tsx | 25 ++++ .../conformance/jsx/tsxElementResolution1.jsx | 4 + .../conformance/jsx/tsxElementResolution1.tsx | 14 +++ .../jsx/tsxElementResolution10.tsx | 21 ++++ .../jsx/tsxElementResolution11.jsx | 6 + .../jsx/tsxElementResolution11.tsx | 25 ++++ .../jsx/tsxElementResolution12.jsx | 9 ++ .../jsx/tsxElementResolution12.tsx | 32 +++++ .../jsx/tsxElementResolution13.jsx | 2 + .../jsx/tsxElementResolution13.tsx | 12 ++ .../jsx/tsxElementResolution14.jsx | 2 + .../jsx/tsxElementResolution14.tsx | 11 ++ .../jsx/tsxElementResolution15.jsx | 2 + .../jsx/tsxElementResolution15.tsx | 13 ++ .../jsx/tsxElementResolution16.jsx | 2 + .../jsx/tsxElementResolution16.tsx | 10 ++ .../jsx/tsxElementResolution17.tsx | 27 ++++ .../jsx/tsxElementResolution18.tsx | 9 ++ .../conformance/jsx/tsxElementResolution2.tsx | 14 +++ .../conformance/jsx/tsxElementResolution3.tsx | 14 +++ .../conformance/jsx/tsxElementResolution4.tsx | 18 +++ .../conformance/jsx/tsxElementResolution5.tsx | 8 ++ .../conformance/jsx/tsxElementResolution6.tsx | 10 ++ .../conformance/jsx/tsxElementResolution7.jsx | 14 +++ .../conformance/jsx/tsxElementResolution7.tsx | 22 ++++ .../conformance/jsx/tsxElementResolution8.jsx | 15 +++ .../conformance/jsx/tsxElementResolution8.tsx | 36 ++++++ .../conformance/jsx/tsxElementResolution9.jsx | 6 + .../conformance/jsx/tsxElementResolution9.tsx | 27 ++++ tests/cases/conformance/jsx/tsxEmit1.jsx | 34 +++++ tests/cases/conformance/jsx/tsxEmit1.tsx | 41 ++++++ tests/cases/conformance/jsx/tsxEmit2.tsx | 15 +++ tests/cases/conformance/jsx/tsxEmit3.jsx | 41 ++++++ tests/cases/conformance/jsx/tsxEmit3.tsx | 41 ++++++ .../jsx/tsxGenericArrowFunctionParsing.tsx | 28 +++++ tests/cases/conformance/jsx/tsxNoJsx.tsx | 3 + .../cases/conformance/jsx/tsxParseTests1.tsx | 8 ++ tests/cases/conformance/jsx/tsxReactEmit1.tsx | 41 ++++++ tests/cases/conformance/jsx/tsxReactEmit2.tsx | 15 +++ tests/cases/conformance/jsx/tsxReactEmit3.tsx | 8 ++ tests/cases/conformance/jsx/tsxReactEmit4.tsx | 15 +++ .../jsx/tsxReactEmitWhitespace.tsx | 52 ++++++++ tests/cases/conformance/jsx/tsxTypeErrors.tsx | 34 +++++ 62 files changed, 1295 insertions(+) create mode 100644 tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx create mode 100644 tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx create mode 100644 tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx create mode 100644 tests/cases/conformance/jsx/jsxReactTestSuite.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeErrors.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution1.jsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution1.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution2.jsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution2.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution3.jsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution3.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution4.jsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution4.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution5.jsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution5.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution6.tsx create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution7.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution1.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution1.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution10.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution11.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution11.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution12.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution12.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution13.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution13.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution14.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution14.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution15.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution15.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution16.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution16.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution17.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution18.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution2.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution3.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution4.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution5.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution6.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution7.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution7.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution8.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution8.tsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution9.jsx create mode 100644 tests/cases/conformance/jsx/tsxElementResolution9.tsx create mode 100644 tests/cases/conformance/jsx/tsxEmit1.jsx create mode 100644 tests/cases/conformance/jsx/tsxEmit1.tsx create mode 100644 tests/cases/conformance/jsx/tsxEmit2.tsx create mode 100644 tests/cases/conformance/jsx/tsxEmit3.jsx create mode 100644 tests/cases/conformance/jsx/tsxEmit3.tsx create mode 100644 tests/cases/conformance/jsx/tsxGenericArrowFunctionParsing.tsx create mode 100644 tests/cases/conformance/jsx/tsxNoJsx.tsx create mode 100644 tests/cases/conformance/jsx/tsxParseTests1.tsx create mode 100644 tests/cases/conformance/jsx/tsxReactEmit1.tsx create mode 100644 tests/cases/conformance/jsx/tsxReactEmit2.tsx create mode 100644 tests/cases/conformance/jsx/tsxReactEmit3.tsx create mode 100644 tests/cases/conformance/jsx/tsxReactEmit4.tsx create mode 100644 tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx create mode 100644 tests/cases/conformance/jsx/tsxTypeErrors.tsx diff --git a/tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx b/tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx new file mode 100644 index 00000000000..b20dea210a9 --- /dev/null +++ b/tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx @@ -0,0 +1,22 @@ +// @jsx: preserve + +declare var createElement: any; + +class foo {} + +var x: any; +x = { test: }; + +x = ; + +x = hello {{}} ; + +x = {}}>hello; + +x = {}}>hello{{}}; + +x = x, x = ; + +{{/foo/.test(x) ? : }} + + diff --git a/tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx b/tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx new file mode 100644 index 00000000000..163357454aa --- /dev/null +++ b/tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx @@ -0,0 +1,54 @@ +// @jsx: preserve +declare var React: any; +declare var 日本語; +declare var AbC_def; +declare var LeftRight; +declare var x; +declare var a; +declare var props; + +; + +//; Namespace unsuported + +// {value} ; Namespace unsuported + +; + +; +; + +<日本語>; + + +bar +baz +; + + : } />; + +{}; + +{/* this is a comment */}; + +
@test content
; + +

7x invalid-js-identifier
; + + right=monkeys /> gorillas />; + +; + +; + +(
) < x; + +
; + +
; + +
; + + ; diff --git a/tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx b/tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx new file mode 100644 index 00000000000..815cd4abb21 --- /dev/null +++ b/tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx @@ -0,0 +1,36 @@ +// @jsx: preserve +declare var React: any; + +; +; +<:a />; +; +; +; +; +; +
; +
; + +
stuff
; +
stuff
; + +>; + >; +; +; +}; +; \ No newline at end of file diff --git a/tests/cases/conformance/jsx/jsxReactTestSuite.tsx b/tests/cases/conformance/jsx/jsxReactTestSuite.tsx new file mode 100644 index 00000000000..96b91987cbc --- /dev/null +++ b/tests/cases/conformance/jsx/jsxReactTestSuite.tsx @@ -0,0 +1,117 @@ +// @jsx: preserve + +declare var React: any; +declare var Component:any; +declare var Composite:any; +declare var Composite2:any; +declare var Child:any; +declare var Namespace:any; +declare var foo: any; +declare var bar: any; +declare var y:any; +declare var x:any; +declare var z:any; +declare var hasOwnProperty:any; + +
text
; + +
+ {this.props.children} +
; + +
+

+ {foo}
{bar} +
+
; + + + + {this.props.children} +; + + + +; + +var x = +
+
; + +( +
+ {/* A comment at the beginning */} + {/* A second comment at the beginning */} + + {/* A nested comment */} + + {/* A sandwiched comment */} +
+ {/* A comment at the end */} + {/* A second comment at the end */} +
+); + +( +
+ +
+); + +
 
; + +
 
; + +testing; + +; + +; + +; + +; + +; + +; + +; + +; + +; + +; + +; + +; + + +; + +Text; + + diff --git a/tests/cases/conformance/jsx/tsxAttributeErrors.tsx b/tests/cases/conformance/jsx/tsxAttributeErrors.tsx new file mode 100644 index 00000000000..477135e1544 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeErrors.tsx @@ -0,0 +1,26 @@ +// @jsx: preserve + +declare namespace JSX { + interface Element { } + interface IntrinsicElements { + div: { + text?: string; + width?: number; + } + + span: any; + } +} + +// Error, number is not assignable to string +
; + +// Error, string is not assignable to number +
; + +// Error, number is not assignable to string +var attribs = { text: 100 }; +
; + +// No errors here +; diff --git a/tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx b/tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx new file mode 100644 index 00000000000..a3a8d293535 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx @@ -0,0 +1,12 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: { "data-foo"?: string }; + } +} + +// Invalid names +; +; \ No newline at end of file diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution.tsx new file mode 100644 index 00000000000..a7519d00c94 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution.tsx @@ -0,0 +1,9 @@ +/// @jsx: preserve + +declare namespace JSX { + interface IntrinsicElements { + x: { y: number; z: string; }; + } +} + + diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution1.jsx b/tests/cases/conformance/jsx/tsxAttributeResolution1.jsx new file mode 100644 index 00000000000..fb54f9d7c82 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution1.jsx @@ -0,0 +1,15 @@ +// OK +; // OK +; // OK +; // OK +; // OK +; // OK +// Errors +; // Error, '0' is not number +; // Error, no property "y" +; // Error, no property "y" +; // Error, "32" is not number +// TODO attribute 'var' should be parseable +// ; // Error, no 'var' property +; // Error, missing reqd +; // Error, reqd is not string diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution1.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution1.tsx new file mode 100644 index 00000000000..edb203655ef --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution1.tsx @@ -0,0 +1,33 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + test2: { reqd: string }; + } +} +interface Attribs1 { + x?: number; + s?: string; +} + +// OK +; // OK +; // OK +; // OK + +; // OK +; // OK + +// Errors +; // Error, '0' is not number +; // Error, no property "y" +; // Error, no property "y" +; // Error, "32" is not number +// TODO attribute 'var' should be parseable +// ; // Error, no 'var' property + +; // Error, missing reqd +; // Error, reqd is not string + diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution2.jsx b/tests/cases/conformance/jsx/tsxAttributeResolution2.jsx new file mode 100644 index 00000000000..7c47046dcde --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution2.jsx @@ -0,0 +1,5 @@ +// OK +; // OK +; // OK +// Errors +; // Error, no leng on 'string' diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution2.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution2.tsx new file mode 100644 index 00000000000..c9bc2de978a --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution2.tsx @@ -0,0 +1,19 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } +} +interface Attribs1 { + c1?: (x: string) => void; +} + +// OK + x.length} />; // OK + x.leng} />; // OK + + +// Errors + x.leng} />; // Error, no leng on 'string' diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution3.jsx b/tests/cases/conformance/jsx/tsxAttributeResolution3.jsx new file mode 100644 index 00000000000..46cb5d8ff69 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution3.jsx @@ -0,0 +1,21 @@ +// OK +var obj1 = { x: 'foo' }; +; +// Error, x is not string +var obj2 = { x: 32 }; +; +// Error, x is missing +var obj3 = { y: 32 }; +; +// OK +var obj4 = { x: 32, y: 32 }; +; +// Error +var obj5 = { x: 32, y: 32 }; +; +// OK +var obj6 = { x: 'ok', y: 32, extra: 100 }; +; +// Error +var obj7 = { x: 'foo' }; +; diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution3.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution3.tsx new file mode 100644 index 00000000000..dc0c2fed8d6 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution3.tsx @@ -0,0 +1,41 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } +} +interface Attribs1 { + x: string; + y?: number; + z?: string; +} + +// OK +var obj1 = { x: 'foo' }; + + +// Error, x is not string +var obj2 = { x: 32 }; + + +// Error, x is missing +var obj3 = { y: 32 }; + + +// OK +var obj4 = { x: 32, y: 32 }; + + +// Error +var obj5 = { x: 32, y: 32 }; + + +// OK +var obj6 = { x: 'ok', y: 32, extra: 100 }; + + +// Error +var obj7 = { x: 'foo' }; + diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution4.jsx b/tests/cases/conformance/jsx/tsxAttributeResolution4.jsx new file mode 100644 index 00000000000..da2e1d12038 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution4.jsx @@ -0,0 +1,4 @@ +// OK +; +// Error, no member 'len' on 'string' +; diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution4.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution4.tsx new file mode 100644 index 00000000000..caaad3559c3 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution4.tsx @@ -0,0 +1,17 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } +} +interface Attribs1 { + x(n: string): void; +} + +// OK + 0} } />; + +// Error, no member 'len' on 'string' + n.len} } />; diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution5.jsx b/tests/cases/conformance/jsx/tsxAttributeResolution5.jsx new file mode 100644 index 00000000000..3e4c89d06fb --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution5.jsx @@ -0,0 +1,11 @@ +function make1(obj) { + return ; // OK +} +function make2(obj) { + return ; // Error (x is number, not string) +} +function make3(obj) { + return ; // Error, missing x +} +; // Error, missing x +; // OK diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution5.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution5.tsx new file mode 100644 index 00000000000..dd16ade10e3 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution5.tsx @@ -0,0 +1,32 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + test2: Attribs2; + } +} +interface Attribs1 { + x: string; +} + +interface Attribs2 { + toString(): string; +} + +function make1 (obj: T) { + return ; // OK +} + +function make2 (obj: T) { + return ; // Error (x is number, not string) +} + +function make3 (obj: T) { + return ; // Error, missing x +} + + +; // Error, missing x +; // OK diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution6.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution6.tsx new file mode 100644 index 00000000000..b083247ba7a --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution6.tsx @@ -0,0 +1,19 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: { n?: boolean; s?: string}; + test2: { n: boolean; }; + } +} + +// Error +; +; +; + +// OK +; +; +; diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution7.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution7.tsx new file mode 100644 index 00000000000..1fc6a873187 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution7.tsx @@ -0,0 +1,16 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: { "data-foo"?: string }; + } +} + +// Error +; + +// OK +; +; +; diff --git a/tests/cases/conformance/jsx/tsxElementResolution.tsx b/tests/cases/conformance/jsx/tsxElementResolution.tsx new file mode 100644 index 00000000000..e5c3c191f05 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution.tsx @@ -0,0 +1,25 @@ +//@jsx: preserve + +declare namespace JSX { + interface IntrinsicElements { + foundFirst: { x: string }; + 'string_named'; + 'var'; + } +} + +class foundFirst { } +class Other {} + +module Dotted { + export class Name { } +} + +// Should find the intrinsic element, not the class element +var a = ; +var b = ; +// TODO: This should not be a parse error (should +// parse a property name here, not identifier) +// var c = ; +var d = ; +var e = ; diff --git a/tests/cases/conformance/jsx/tsxElementResolution1.jsx b/tests/cases/conformance/jsx/tsxElementResolution1.jsx new file mode 100644 index 00000000000..97357dbba8e --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution1.jsx @@ -0,0 +1,4 @@ +// OK +
; +// Fail +; diff --git a/tests/cases/conformance/jsx/tsxElementResolution1.tsx b/tests/cases/conformance/jsx/tsxElementResolution1.tsx new file mode 100644 index 00000000000..b9c1b91d05e --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution1.tsx @@ -0,0 +1,14 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + div: any + } +} + +// OK +
; + +// Fail +; \ No newline at end of file diff --git a/tests/cases/conformance/jsx/tsxElementResolution10.tsx b/tests/cases/conformance/jsx/tsxElementResolution10.tsx new file mode 100644 index 00000000000..526c0529e1b --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution10.tsx @@ -0,0 +1,21 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface ElementClass { + render: any; + } + interface IntrinsicElements { } +} + +interface Obj1type { + new(n: string): { x: number }; +} +var Obj1: Obj1type; +; // Error, no render member + +interface Obj2type { + (n: string): { x: number; render: any; }; +} +var Obj2: Obj2type; +; // OK diff --git a/tests/cases/conformance/jsx/tsxElementResolution11.jsx b/tests/cases/conformance/jsx/tsxElementResolution11.jsx new file mode 100644 index 00000000000..6349906508c --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution11.jsx @@ -0,0 +1,6 @@ +var Obj1; +; // OK +var Obj2; +; // Error +var Obj3; +; // OK diff --git a/tests/cases/conformance/jsx/tsxElementResolution11.tsx b/tests/cases/conformance/jsx/tsxElementResolution11.tsx new file mode 100644 index 00000000000..0fc74335500 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution11.tsx @@ -0,0 +1,25 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface ElementAttributesProperty { } + interface IntrinsicElements { } +} + +interface Obj1type { + new(n: string): any; +} +var Obj1: Obj1type; +; // OK + +interface Obj2type { + new(n: string): { q?: number }; +} +var Obj2: Obj2type; +; // Error + +interface Obj3type { + new(n: string): { x: number; }; +} +var Obj3: Obj3type; +; // OK diff --git a/tests/cases/conformance/jsx/tsxElementResolution12.jsx b/tests/cases/conformance/jsx/tsxElementResolution12.jsx new file mode 100644 index 00000000000..ef137fd0e29 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution12.jsx @@ -0,0 +1,9 @@ +var obj1; +; // OK +var obj2; +; // OK +var obj3; +; // Error +var obj4; +; // OK +; // Error diff --git a/tests/cases/conformance/jsx/tsxElementResolution12.tsx b/tests/cases/conformance/jsx/tsxElementResolution12.tsx new file mode 100644 index 00000000000..a5d8f2d812b --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution12.tsx @@ -0,0 +1,32 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface ElementAttributesProperty { pr: any; } + interface IntrinsicElements { } +} + +interface Obj1type { + new(n: string): any; +} +var Obj1: Obj1type; +; // OK + +interface Obj2type { + new(n: string): { q?: number; pr: any }; +} +var obj2: Obj2type; +; // OK + +interface Obj3type { + new(n: string): { x: number; }; +} +var Obj3: Obj3type; +; // Error + +interface Obj4type { + new(n: string): { x: number; pr: { x: number; } }; +} +var Obj4: Obj4type; +; // OK +; // Error diff --git a/tests/cases/conformance/jsx/tsxElementResolution13.jsx b/tests/cases/conformance/jsx/tsxElementResolution13.jsx new file mode 100644 index 00000000000..6a55efa612d --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution13.jsx @@ -0,0 +1,2 @@ +var obj1; +; // Error diff --git a/tests/cases/conformance/jsx/tsxElementResolution13.tsx b/tests/cases/conformance/jsx/tsxElementResolution13.tsx new file mode 100644 index 00000000000..32ee20afbfe --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution13.tsx @@ -0,0 +1,12 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface ElementAttributesProperty { pr1: any; pr2: any; } +} + +interface Obj1 { + new(n: string): any; +} +var obj1: Obj1; +; // Error diff --git a/tests/cases/conformance/jsx/tsxElementResolution14.jsx b/tests/cases/conformance/jsx/tsxElementResolution14.jsx new file mode 100644 index 00000000000..29df7710af1 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution14.jsx @@ -0,0 +1,2 @@ +var obj1; +; // OK diff --git a/tests/cases/conformance/jsx/tsxElementResolution14.tsx b/tests/cases/conformance/jsx/tsxElementResolution14.tsx new file mode 100644 index 00000000000..f76af00bbeb --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution14.tsx @@ -0,0 +1,11 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } +} + +interface Obj1 { + new(n: string): {}; +} +var obj1: Obj1; +; // OK diff --git a/tests/cases/conformance/jsx/tsxElementResolution15.jsx b/tests/cases/conformance/jsx/tsxElementResolution15.jsx new file mode 100644 index 00000000000..6a55efa612d --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution15.jsx @@ -0,0 +1,2 @@ +var obj1; +; // Error diff --git a/tests/cases/conformance/jsx/tsxElementResolution15.tsx b/tests/cases/conformance/jsx/tsxElementResolution15.tsx new file mode 100644 index 00000000000..61cea63ce76 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution15.tsx @@ -0,0 +1,13 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface ElementAttributesProperty { pr1: any; pr2: any; } + interface IntrinsicElements { } +} + +interface Obj1type { + new(n: string): {}; +} +var Obj1: Obj1type; +; // Error diff --git a/tests/cases/conformance/jsx/tsxElementResolution16.jsx b/tests/cases/conformance/jsx/tsxElementResolution16.jsx new file mode 100644 index 00000000000..e1987489bbb --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution16.jsx @@ -0,0 +1,2 @@ +var obj1; +; // Error (JSX.Element is missing) diff --git a/tests/cases/conformance/jsx/tsxElementResolution16.tsx b/tests/cases/conformance/jsx/tsxElementResolution16.tsx new file mode 100644 index 00000000000..7d71b5f2b69 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution16.tsx @@ -0,0 +1,10 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { +} + +interface Obj1 { + new(n: string): {}; +} +var obj1: Obj1; +; // Error (JSX.Element is missing) diff --git a/tests/cases/conformance/jsx/tsxElementResolution17.tsx b/tests/cases/conformance/jsx/tsxElementResolution17.tsx new file mode 100644 index 00000000000..97777d76a58 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution17.tsx @@ -0,0 +1,27 @@ +//@jsx: preserve +//@module: amd + +//@filename: file.tsx +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +declare module 'elements1' { + class MyElement { + + } +} + +declare module 'elements2' { + class MyElement { + + } +} + +//@filename: consumer.tsx +/// +// Should keep s1 and elide s2 +import s1 = require('elements1'); +import s2 = require('elements2'); +; diff --git a/tests/cases/conformance/jsx/tsxElementResolution18.tsx b/tests/cases/conformance/jsx/tsxElementResolution18.tsx new file mode 100644 index 00000000000..89081d7629f --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution18.tsx @@ -0,0 +1,9 @@ +//@jsx: preserve +//@filename: file1.tsx +//@noimplicitany: true +declare module JSX { + interface Element { } +} + +// Error under implicit any +
; diff --git a/tests/cases/conformance/jsx/tsxElementResolution2.tsx b/tests/cases/conformance/jsx/tsxElementResolution2.tsx new file mode 100644 index 00000000000..75e4956e728 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution2.tsx @@ -0,0 +1,14 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + [x: string]: any; + } +} + +// OK +
; + +// OK +; \ No newline at end of file diff --git a/tests/cases/conformance/jsx/tsxElementResolution3.tsx b/tests/cases/conformance/jsx/tsxElementResolution3.tsx new file mode 100644 index 00000000000..c3f057c4ff5 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution3.tsx @@ -0,0 +1,14 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + [x: string]: { n: string; }; + } +} + +// OK +
; + +// Error +; \ No newline at end of file diff --git a/tests/cases/conformance/jsx/tsxElementResolution4.tsx b/tests/cases/conformance/jsx/tsxElementResolution4.tsx new file mode 100644 index 00000000000..413ae6d5ed9 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution4.tsx @@ -0,0 +1,18 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + div: { n: string; }; + span: { m: string; }; + } +} + +// OK +
; + +// OK +; + +// Error +; diff --git a/tests/cases/conformance/jsx/tsxElementResolution5.tsx b/tests/cases/conformance/jsx/tsxElementResolution5.tsx new file mode 100644 index 00000000000..c12c07d3e60 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution5.tsx @@ -0,0 +1,8 @@ +//@jsx: preserve +//@filename: file1.tsx +declare module JSX { + interface Element { } +} + +// OK, but implicit any +
; diff --git a/tests/cases/conformance/jsx/tsxElementResolution6.tsx b/tests/cases/conformance/jsx/tsxElementResolution6.tsx new file mode 100644 index 00000000000..74d3324ea0f --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution6.tsx @@ -0,0 +1,10 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +var div: any; +// Still an error +
; diff --git a/tests/cases/conformance/jsx/tsxElementResolution7.jsx b/tests/cases/conformance/jsx/tsxElementResolution7.jsx new file mode 100644 index 00000000000..e95505539ab --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution7.jsx @@ -0,0 +1,14 @@ +var my; +(function (my) { +})(my || (my = {})); +// OK +; +// Error +; +var q; +(function (q) { + // OK + ; + // Error + ; +})(q || (q = {})); diff --git a/tests/cases/conformance/jsx/tsxElementResolution7.tsx b/tests/cases/conformance/jsx/tsxElementResolution7.tsx new file mode 100644 index 00000000000..c7ab23e76ea --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution7.tsx @@ -0,0 +1,22 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +module my { + export var div: any; +} +// OK +; +// Error +; + +module q { + import mine = my; + // OK + ; + // Error + ; +} diff --git a/tests/cases/conformance/jsx/tsxElementResolution8.jsx b/tests/cases/conformance/jsx/tsxElementResolution8.jsx new file mode 100644 index 00000000000..e0f95dc6d22 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution8.jsx @@ -0,0 +1,15 @@ +// Error +var div = 3; +
; +// OK +function fact() { return null; } +; +// Error +function fnum() { return 42; } +; +var obj1; +; // OK, prefer construct signatures +var obj2; +; // Error +var obj3; +; // Error diff --git a/tests/cases/conformance/jsx/tsxElementResolution8.tsx b/tests/cases/conformance/jsx/tsxElementResolution8.tsx new file mode 100644 index 00000000000..624302da062 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution8.tsx @@ -0,0 +1,36 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +// Error +var Div = 3; +
; + +// OK +function Fact(): any { return null; } + + +// Error +function Fnum(): number{ return 42; } + + +interface Obj1 { + new(): {}; + (): number; +} +var Obj1: Obj1; +; // OK, prefer construct signatures + +interface Obj2 { + (): number; +} +var Obj2: Obj2; +; // Error + +interface Obj3 { +} +var Obj3: Obj3; +; // Error diff --git a/tests/cases/conformance/jsx/tsxElementResolution9.jsx b/tests/cases/conformance/jsx/tsxElementResolution9.jsx new file mode 100644 index 00000000000..2b62d86eac5 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution9.jsx @@ -0,0 +1,6 @@ +var obj1; +; // Error, return type is not an object type +var obj2; +; // Error, return type is not an object type +var obj3; +; // OK diff --git a/tests/cases/conformance/jsx/tsxElementResolution9.tsx b/tests/cases/conformance/jsx/tsxElementResolution9.tsx new file mode 100644 index 00000000000..7165f8277b3 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxElementResolution9.tsx @@ -0,0 +1,27 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +interface Obj1 { + new(n: string): { x: number }; + new(n: number): { y: string }; +} +var Obj1: Obj1; +; // Error, return type is not an object type + +interface Obj2 { + (n: string): { x: number }; + (n: number): { y: string }; +} +var Obj2: Obj2; +; // Error, return type is not an object type + +interface Obj3 { + (n: string): { x: number }; + (n: number): { x: number; y: string }; +} +var Obj3: Obj3; +; // OK diff --git a/tests/cases/conformance/jsx/tsxEmit1.jsx b/tests/cases/conformance/jsx/tsxEmit1.jsx new file mode 100644 index 00000000000..45ca6e2469f --- /dev/null +++ b/tests/cases/conformance/jsx/tsxEmit1.jsx @@ -0,0 +1,34 @@ +var p; +/* +var selfClosed1 =
; +var selfClosed2 =
; +var selfClosed3 =
; +var selfClosed4 =
; +var selfClosed5 =
; +var selfClosed6 =
; +var selfClosed7 =
; + +var openClosed1 =
; +var openClosed2 =
foo
; +var openClosed3 =
{p}
; +var openClosed4 =
{p < p}
; +var openClosed5 =
{p > p}
; +*/ +var SomeClass = (function () { + function SomeClass() { + } + SomeClass.prototype.f = function () { + var _this = this; + var rewrites1 =
{function () { return _this; }}
; + var rewrites4 =
; + }; + return SomeClass; +})(); +/* +var q = () => this; +var rewrites2 =
{[p, ...p, p]}
; +var rewrites3 =
{{p}}
; + +var rewrites5 =
; +var rewrites6 =
; +*/ diff --git a/tests/cases/conformance/jsx/tsxEmit1.tsx b/tests/cases/conformance/jsx/tsxEmit1.tsx new file mode 100644 index 00000000000..9f3d9ca3a5e --- /dev/null +++ b/tests/cases/conformance/jsx/tsxEmit1.tsx @@ -0,0 +1,41 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p; +var selfClosed1 =
; +var selfClosed2 =
; +var selfClosed3 =
; +var selfClosed4 =
; +var selfClosed5 =
; +var selfClosed6 =
; +var selfClosed7 =
; + +var openClosed1 =
; +var openClosed2 =
foo
; +var openClosed3 =
{p}
; +var openClosed4 =
{p < p}
; +var openClosed5 =
{p > p}
; + +class SomeClass { + f() { + var rewrites1 =
{() => this}
; + var rewrites2 =
{[p, ...p, p]}
; + var rewrites3 =
{{p}}
; + + var rewrites4 =
this}>
; + var rewrites5 =
; + var rewrites6 =
; + } +} + +var whitespace1 =
; +var whitespace2 =
{p}
; +var whitespace3 =
+ {p} +
; diff --git a/tests/cases/conformance/jsx/tsxEmit2.tsx b/tests/cases/conformance/jsx/tsxEmit2.tsx new file mode 100644 index 00000000000..24f51a4583d --- /dev/null +++ b/tests/cases/conformance/jsx/tsxEmit2.tsx @@ -0,0 +1,15 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p1, p2, p3; +var spreads1 =
{p2}
; +var spreads2 =
{p2}
; +var spreads3 =
{p2}
; +var spreads4 =
{p2}
; +var spreads5 =
{p2}
; diff --git a/tests/cases/conformance/jsx/tsxEmit3.jsx b/tests/cases/conformance/jsx/tsxEmit3.jsx new file mode 100644 index 00000000000..7c979051d00 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxEmit3.jsx @@ -0,0 +1,41 @@ +var M; +(function (M) { + var Foo = (function () { + function Foo() { + } + return Foo; + })(); + M.Foo = Foo; + var S; + (function (S) { + var Bar = (function () { + function Bar() { + } + return Bar; + })(); + S.Bar = Bar; + })(S = M.S || (M.S = {})); +})(M || (M = {})); +var M; +(function (M) { + // Emit M.Foo + M.Foo, ; + var S; + (function (S) { + // Emit M.Foo + M.Foo, ; + // Emit S.Bar + S.Bar, ; + })(S = M.S || (M.S = {})); +})(M || (M = {})); +var M; +(function (M) { + // Emit M.S.Bar + M.S.Bar, ; +})(M || (M = {})); +var M; +(function (M_1) { + var M = 100; + // Emit M_1.Foo + M_1.Foo, ; +})(M || (M = {})); diff --git a/tests/cases/conformance/jsx/tsxEmit3.tsx b/tests/cases/conformance/jsx/tsxEmit3.tsx new file mode 100644 index 00000000000..b3c3350dd11 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxEmit3.tsx @@ -0,0 +1,41 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +module M { + export class Foo { constructor() { } } + export module S { + export class Bar { } + + // Emit Foo + // Foo, ; + } +} + +module M { + // Emit M.Foo + Foo, ; + + export module S { + // Emit M.Foo + Foo, ; + + // Emit S.Bar + Bar, ; + } + +} + +module M { + // Emit M.S.Bar + S.Bar, ; +} + +module M { + var M = 100; + // Emit M_1.Foo + Foo, ; +} diff --git a/tests/cases/conformance/jsx/tsxGenericArrowFunctionParsing.tsx b/tests/cases/conformance/jsx/tsxGenericArrowFunctionParsing.tsx new file mode 100644 index 00000000000..b3d3d34020a --- /dev/null +++ b/tests/cases/conformance/jsx/tsxGenericArrowFunctionParsing.tsx @@ -0,0 +1,28 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { isElement; } +} + +var T, T1, T2; + +// This is an element +var x1 = () => {}; +x1.isElement; + +// This is a generic function +var x2 = () => {}; +x2(); + +// This is a generic function +var x3 = () => {}; +x3(); + +// This is an element +var x4 = () => {}; +x4.isElement; + +// This is an element +var x5 = () => {}; +x5.isElement; + diff --git a/tests/cases/conformance/jsx/tsxNoJsx.tsx b/tests/cases/conformance/jsx/tsxNoJsx.tsx new file mode 100644 index 00000000000..03b827b7e61 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxNoJsx.tsx @@ -0,0 +1,3 @@ +//@jsx: preserve + +; diff --git a/tests/cases/conformance/jsx/tsxParseTests1.tsx b/tests/cases/conformance/jsx/tsxParseTests1.tsx new file mode 100644 index 00000000000..7675aee7962 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxParseTests1.tsx @@ -0,0 +1,8 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { div; span; } +} + +var x =
; diff --git a/tests/cases/conformance/jsx/tsxReactEmit1.tsx b/tests/cases/conformance/jsx/tsxReactEmit1.tsx new file mode 100644 index 00000000000..8ca8ef1ff40 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxReactEmit1.tsx @@ -0,0 +1,41 @@ +//@filename: file.tsx +//@jsx: react +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p; +var selfClosed1 =
; +var selfClosed2 =
; +var selfClosed3 =
; +var selfClosed4 =
; +var selfClosed5 =
; +var selfClosed6 =
; +var selfClosed7 =
; + +var openClosed1 =
; +var openClosed2 =
foo
; +var openClosed3 =
{p}
; +var openClosed4 =
{p < p}
; +var openClosed5 =
{p > p}
; + +class SomeClass { + f() { + var rewrites1 =
{() => this}
; + var rewrites2 =
{[p, ...p, p]}
; + var rewrites3 =
{{p}}
; + + var rewrites4 =
this}>
; + var rewrites5 =
; + var rewrites6 =
; + } +} + +var whitespace1 =
; +var whitespace2 =
{p}
; +var whitespace3 =
+ {p} +
; diff --git a/tests/cases/conformance/jsx/tsxReactEmit2.tsx b/tests/cases/conformance/jsx/tsxReactEmit2.tsx new file mode 100644 index 00000000000..39a78a7da87 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxReactEmit2.tsx @@ -0,0 +1,15 @@ +//@filename: file.tsx +//@jsx: react +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p1, p2, p3; +var spreads1 =
{p2}
; +var spreads2 =
{p2}
; +var spreads3 =
{p2}
; +var spreads4 =
{p2}
; +var spreads5 =
{p2}
; diff --git a/tests/cases/conformance/jsx/tsxReactEmit3.tsx b/tests/cases/conformance/jsx/tsxReactEmit3.tsx new file mode 100644 index 00000000000..eb63be44f3b --- /dev/null +++ b/tests/cases/conformance/jsx/tsxReactEmit3.tsx @@ -0,0 +1,8 @@ +//@jsx: react +//@filename: test.tsx + +declare module JSX { interface Element { } } + +declare var Foo, Bar, baz; + + q s ; \ No newline at end of file diff --git a/tests/cases/conformance/jsx/tsxReactEmit4.tsx b/tests/cases/conformance/jsx/tsxReactEmit4.tsx new file mode 100644 index 00000000000..0987b89c978 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxReactEmit4.tsx @@ -0,0 +1,15 @@ +//@filename: file.tsx +//@jsx: react +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p; +var openClosed1 =
+ + {blah} + +
; diff --git a/tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx b/tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx new file mode 100644 index 00000000000..38c966fa700 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx @@ -0,0 +1,52 @@ +//@filename: file.tsx +//@jsx: react +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +// THIS FILE HAS TEST-SIGNIFICANT LEADING/TRAILING +// WHITESPACE, DO NOT RUN 'FORMAT DOCUMENT' ON IT + +var p = 0; +// Emit " " +
; +// Emit " ", p, " " +
{p}
; +// Emit only p +
+ {p} +
; + +// Emit only p +
+ {p} +
; + +// Emit " 3" +
3 +
; + +// Emit " 3 " +
3
; + +// Emit "3" +
+ 3 +
; + +// Emit no args +
+
; + +// Emit "foo" + ' ' + "bar" +
+ + foo + + bar + +
; + diff --git a/tests/cases/conformance/jsx/tsxTypeErrors.tsx b/tests/cases/conformance/jsx/tsxTypeErrors.tsx new file mode 100644 index 00000000000..f8288b68ce3 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxTypeErrors.tsx @@ -0,0 +1,34 @@ +//@jsx: preserve + +// A built-in element (OK) +var a1 =
; + +// A built-in element with a mistyped property (error) +var a2 = + +// A built-in element with a badly-typed attribute value (error) +var thing = { oops: 100 }; +var a3 =
+ +// Mistyped html name (error) +var e1 = + +// A custom type +class MyClass { + props: { + pt?: { x: number; y: number; }; + name?: string; + reqd: boolean; + } +} + +// Let's use it +// TODO: Error on missing 'reqd' +var b1 = ; + +// Mistyped attribute member +// sample.tsx(23,22): error TS2322: Type '{ x: number; y: string; }' is not assignable to type '{ x: number; y: number; }'. +// Types of property 'y' are incompatible. +// Type 'string' is not assignable to type 'number'. +var b2 = ; + From a5c44a30121f220c684841968be486bc36586306 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:04:11 -0700 Subject: [PATCH 130/309] Baseline-accept --- tests/baselines/reference/APISample_linter.js | 22 +- tests/baselines/reference/asOperator1.js | 19 ++ tests/baselines/reference/asOperator1.symbols | 24 ++ tests/baselines/reference/asOperator1.types | 35 +++ .../reference/asOperator2.errors.txt | 8 + tests/baselines/reference/asOperator2.js | 6 + tests/baselines/reference/asOperator3.js | 22 ++ tests/baselines/reference/asOperator3.symbols | 31 ++ tests/baselines/reference/asOperator3.types | 63 ++++ tests/baselines/reference/asOperatorASI.js | 26 ++ .../baselines/reference/asOperatorASI.symbols | 23 ++ tests/baselines/reference/asOperatorASI.types | 28 ++ .../reference/asOperatorAmbiguity.errors.txt | 15 + .../reference/asOperatorAmbiguity.js | 16 + .../asOperatorContextualType.errors.txt | 10 + .../reference/asOperatorContextualType.js | 7 + .../reference/asOperatorNames.errors.txt | 11 + tests/baselines/reference/asOperatorNames.js | 12 + .../reference/jsxAndTypeAssertion.errors.txt | 125 ++++++++ .../reference/jsxAndTypeAssertion.js | 47 +++ .../jsxEsprimaFbTestSuite.errors.txt | 131 ++++++++ .../reference/jsxEsprimaFbTestSuite.js | 81 +++++ .../jsxInvalidEsprimaTestSuite.errors.txt | 283 ++++++++++++++++++ .../reference/jsxInvalidEsprimaTestSuite.js | 71 +++++ .../reference/jsxReactTestSuite.errors.txt | 246 +++++++++++++++ .../baselines/reference/jsxReactTestSuite.js | 171 +++++++++++ .../amd/invalidRootFile.errors.txt | 4 +- .../node/invalidRootFile.errors.txt | 4 +- .../reference/tsxAttributeErrors.errors.txt | 40 +++ .../baselines/reference/tsxAttributeErrors.js | 38 +++ .../tsxAttributeInvalidNames.errors.txt | 25 ++ .../reference/tsxAttributeInvalidNames.js | 16 + .../reference/tsxAttributeResolution.js | 14 + .../reference/tsxAttributeResolution.symbols | 18 ++ .../reference/tsxAttributeResolution.types | 18 ++ .../tsxAttributeResolution1.errors.txt | 53 ++++ .../reference/tsxAttributeResolution1.js | 50 ++++ .../tsxAttributeResolution2.errors.txt | 24 ++ .../reference/tsxAttributeResolution2.js | 26 ++ .../tsxAttributeResolution3.errors.txt | 59 ++++ .../reference/tsxAttributeResolution3.js | 64 ++++ .../tsxAttributeResolution4.errors.txt | 22 ++ .../reference/tsxAttributeResolution4.js | 23 ++ .../tsxAttributeResolution5.errors.txt | 45 +++ .../reference/tsxAttributeResolution5.js | 45 +++ .../tsxAttributeResolution6.errors.txt | 30 ++ .../reference/tsxAttributeResolution6.js | 29 ++ .../tsxAttributeResolution7.errors.txt | 21 ++ .../reference/tsxAttributeResolution7.js | 24 ++ .../reference/tsxElementResolution.errors.txt | 40 +++ .../reference/tsxElementResolution.js | 55 ++++ .../tsxElementResolution1.errors.txt | 18 ++ .../reference/tsxElementResolution1.js | 19 ++ .../tsxElementResolution10.errors.txt | 28 ++ .../reference/tsxElementResolution10.js | 27 ++ .../tsxElementResolution11.errors.txt | 30 ++ .../reference/tsxElementResolution11.js | 33 ++ .../tsxElementResolution12.errors.txt | 43 +++ .../reference/tsxElementResolution12.js | 43 +++ .../reference/tsxElementResolution13.js | 16 + .../reference/tsxElementResolution13.symbols | 26 ++ .../reference/tsxElementResolution13.types | 28 ++ .../reference/tsxElementResolution14.js | 15 + .../reference/tsxElementResolution14.symbols | 21 ++ .../reference/tsxElementResolution14.types | 23 ++ .../tsxElementResolution15.errors.txt | 18 ++ .../reference/tsxElementResolution15.js | 17 ++ .../tsxElementResolution16.errors.txt | 15 + .../reference/tsxElementResolution16.js | 14 + .../reference/tsxElementResolution17.js | 34 +++ .../reference/tsxElementResolution17.symbols | 38 +++ .../reference/tsxElementResolution17.types | 40 +++ .../tsxElementResolution18.errors.txt | 13 + .../reference/tsxElementResolution18.js | 12 + .../reference/tsxElementResolution2.js | 19 ++ .../reference/tsxElementResolution2.symbols | 23 ++ .../reference/tsxElementResolution2.types | 25 ++ .../tsxElementResolution3.errors.txt | 21 ++ .../reference/tsxElementResolution3.js | 19 ++ .../tsxElementResolution4.errors.txt | 26 ++ .../reference/tsxElementResolution4.js | 26 ++ .../reference/tsxElementResolution5.js | 12 + .../reference/tsxElementResolution5.symbols | 12 + .../reference/tsxElementResolution5.types | 14 + .../tsxElementResolution6.errors.txt | 15 + .../reference/tsxElementResolution6.js | 15 + .../tsxElementResolution7.errors.txt | 30 ++ .../reference/tsxElementResolution7.js | 39 +++ .../tsxElementResolution8.errors.txt | 50 ++++ .../reference/tsxElementResolution8.js | 53 ++++ .../tsxElementResolution9.errors.txt | 35 +++ .../reference/tsxElementResolution9.js | 35 +++ tests/baselines/reference/tsxEmit1.js | 75 +++++ tests/baselines/reference/tsxEmit1.symbols | 144 +++++++++ tests/baselines/reference/tsxEmit1.types | 194 ++++++++++++ tests/baselines/reference/tsxEmit2.js | 23 ++ tests/baselines/reference/tsxEmit2.symbols | 44 +++ tests/baselines/reference/tsxEmit2.types | 68 +++++ tests/baselines/reference/tsxEmit3.js | 84 ++++++ tests/baselines/reference/tsxEmit3.symbols | 75 +++++ tests/baselines/reference/tsxEmit3.types | 87 ++++++ .../tsxGenericArrowFunctionParsing.js | 46 +++ .../tsxGenericArrowFunctionParsing.symbols | 64 ++++ .../tsxGenericArrowFunctionParsing.types | 75 +++++ tests/baselines/reference/tsxNoJsx.errors.txt | 9 + tests/baselines/reference/tsxNoJsx.js | 7 + tests/baselines/reference/tsxParseTests1.js | 11 + .../reference/tsxParseTests1.symbols | 20 ++ .../baselines/reference/tsxParseTests1.types | 28 ++ tests/baselines/reference/tsxReactEmit1.js | 73 +++++ .../baselines/reference/tsxReactEmit1.symbols | 144 +++++++++ tests/baselines/reference/tsxReactEmit1.types | 194 ++++++++++++ tests/baselines/reference/tsxReactEmit2.js | 23 ++ .../baselines/reference/tsxReactEmit2.symbols | 44 +++ tests/baselines/reference/tsxReactEmit2.types | 68 +++++ tests/baselines/reference/tsxReactEmit3.js | 10 + .../baselines/reference/tsxReactEmit3.symbols | 18 ++ tests/baselines/reference/tsxReactEmit3.types | 25 ++ .../reference/tsxReactEmit4.errors.txt | 20 ++ tests/baselines/reference/tsxReactEmit4.js | 19 ++ .../reference/tsxReactEmitWhitespace.js | 75 +++++ .../reference/tsxReactEmitWhitespace.symbols | 77 +++++ .../reference/tsxReactEmitWhitespace.types | 101 +++++++ .../reference/tsxTypeErrors.errors.txt | 55 ++++ tests/baselines/reference/tsxTypeErrors.js | 60 ++++ 125 files changed, 5405 insertions(+), 15 deletions(-) create mode 100644 tests/baselines/reference/asOperator1.js create mode 100644 tests/baselines/reference/asOperator1.symbols create mode 100644 tests/baselines/reference/asOperator1.types create mode 100644 tests/baselines/reference/asOperator2.errors.txt create mode 100644 tests/baselines/reference/asOperator2.js create mode 100644 tests/baselines/reference/asOperator3.js create mode 100644 tests/baselines/reference/asOperator3.symbols create mode 100644 tests/baselines/reference/asOperator3.types create mode 100644 tests/baselines/reference/asOperatorASI.js create mode 100644 tests/baselines/reference/asOperatorASI.symbols create mode 100644 tests/baselines/reference/asOperatorASI.types create mode 100644 tests/baselines/reference/asOperatorAmbiguity.errors.txt create mode 100644 tests/baselines/reference/asOperatorAmbiguity.js create mode 100644 tests/baselines/reference/asOperatorContextualType.errors.txt create mode 100644 tests/baselines/reference/asOperatorContextualType.js create mode 100644 tests/baselines/reference/asOperatorNames.errors.txt create mode 100644 tests/baselines/reference/asOperatorNames.js create mode 100644 tests/baselines/reference/jsxAndTypeAssertion.errors.txt create mode 100644 tests/baselines/reference/jsxAndTypeAssertion.js create mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt create mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.js create mode 100644 tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt create mode 100644 tests/baselines/reference/jsxInvalidEsprimaTestSuite.js create mode 100644 tests/baselines/reference/jsxReactTestSuite.errors.txt create mode 100644 tests/baselines/reference/jsxReactTestSuite.js create mode 100644 tests/baselines/reference/tsxAttributeErrors.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeErrors.js create mode 100644 tests/baselines/reference/tsxAttributeInvalidNames.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeInvalidNames.js create mode 100644 tests/baselines/reference/tsxAttributeResolution.js create mode 100644 tests/baselines/reference/tsxAttributeResolution.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution.types create mode 100644 tests/baselines/reference/tsxAttributeResolution1.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeResolution1.js create mode 100644 tests/baselines/reference/tsxAttributeResolution2.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeResolution2.js create mode 100644 tests/baselines/reference/tsxAttributeResolution3.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeResolution3.js create mode 100644 tests/baselines/reference/tsxAttributeResolution4.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeResolution4.js create mode 100644 tests/baselines/reference/tsxAttributeResolution5.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeResolution5.js create mode 100644 tests/baselines/reference/tsxAttributeResolution6.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeResolution6.js create mode 100644 tests/baselines/reference/tsxAttributeResolution7.errors.txt create mode 100644 tests/baselines/reference/tsxAttributeResolution7.js create mode 100644 tests/baselines/reference/tsxElementResolution.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution.js create mode 100644 tests/baselines/reference/tsxElementResolution1.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution1.js create mode 100644 tests/baselines/reference/tsxElementResolution10.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution10.js create mode 100644 tests/baselines/reference/tsxElementResolution11.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution11.js create mode 100644 tests/baselines/reference/tsxElementResolution12.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution12.js create mode 100644 tests/baselines/reference/tsxElementResolution13.js create mode 100644 tests/baselines/reference/tsxElementResolution13.symbols create mode 100644 tests/baselines/reference/tsxElementResolution13.types create mode 100644 tests/baselines/reference/tsxElementResolution14.js create mode 100644 tests/baselines/reference/tsxElementResolution14.symbols create mode 100644 tests/baselines/reference/tsxElementResolution14.types create mode 100644 tests/baselines/reference/tsxElementResolution15.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution15.js create mode 100644 tests/baselines/reference/tsxElementResolution16.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution16.js create mode 100644 tests/baselines/reference/tsxElementResolution17.js create mode 100644 tests/baselines/reference/tsxElementResolution17.symbols create mode 100644 tests/baselines/reference/tsxElementResolution17.types create mode 100644 tests/baselines/reference/tsxElementResolution18.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution18.js create mode 100644 tests/baselines/reference/tsxElementResolution2.js create mode 100644 tests/baselines/reference/tsxElementResolution2.symbols create mode 100644 tests/baselines/reference/tsxElementResolution2.types create mode 100644 tests/baselines/reference/tsxElementResolution3.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution3.js create mode 100644 tests/baselines/reference/tsxElementResolution4.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution4.js create mode 100644 tests/baselines/reference/tsxElementResolution5.js create mode 100644 tests/baselines/reference/tsxElementResolution5.symbols create mode 100644 tests/baselines/reference/tsxElementResolution5.types create mode 100644 tests/baselines/reference/tsxElementResolution6.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution6.js create mode 100644 tests/baselines/reference/tsxElementResolution7.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution7.js create mode 100644 tests/baselines/reference/tsxElementResolution8.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution8.js create mode 100644 tests/baselines/reference/tsxElementResolution9.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution9.js create mode 100644 tests/baselines/reference/tsxEmit1.js create mode 100644 tests/baselines/reference/tsxEmit1.symbols create mode 100644 tests/baselines/reference/tsxEmit1.types create mode 100644 tests/baselines/reference/tsxEmit2.js create mode 100644 tests/baselines/reference/tsxEmit2.symbols create mode 100644 tests/baselines/reference/tsxEmit2.types create mode 100644 tests/baselines/reference/tsxEmit3.js create mode 100644 tests/baselines/reference/tsxEmit3.symbols create mode 100644 tests/baselines/reference/tsxEmit3.types create mode 100644 tests/baselines/reference/tsxGenericArrowFunctionParsing.js create mode 100644 tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols create mode 100644 tests/baselines/reference/tsxGenericArrowFunctionParsing.types create mode 100644 tests/baselines/reference/tsxNoJsx.errors.txt create mode 100644 tests/baselines/reference/tsxNoJsx.js create mode 100644 tests/baselines/reference/tsxParseTests1.js create mode 100644 tests/baselines/reference/tsxParseTests1.symbols create mode 100644 tests/baselines/reference/tsxParseTests1.types create mode 100644 tests/baselines/reference/tsxReactEmit1.js create mode 100644 tests/baselines/reference/tsxReactEmit1.symbols create mode 100644 tests/baselines/reference/tsxReactEmit1.types create mode 100644 tests/baselines/reference/tsxReactEmit2.js create mode 100644 tests/baselines/reference/tsxReactEmit2.symbols create mode 100644 tests/baselines/reference/tsxReactEmit2.types create mode 100644 tests/baselines/reference/tsxReactEmit3.js create mode 100644 tests/baselines/reference/tsxReactEmit3.symbols create mode 100644 tests/baselines/reference/tsxReactEmit3.types create mode 100644 tests/baselines/reference/tsxReactEmit4.errors.txt create mode 100644 tests/baselines/reference/tsxReactEmit4.js create mode 100644 tests/baselines/reference/tsxReactEmitWhitespace.js create mode 100644 tests/baselines/reference/tsxReactEmitWhitespace.symbols create mode 100644 tests/baselines/reference/tsxReactEmitWhitespace.types create mode 100644 tests/baselines/reference/tsxTypeErrors.errors.txt create mode 100644 tests/baselines/reference/tsxTypeErrors.js diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js index 9b2675535f2..ca7078981f7 100644 --- a/tests/baselines/reference/APISample_linter.js +++ b/tests/baselines/reference/APISample_linter.js @@ -75,28 +75,28 @@ function delint(sourceFile) { delintNode(sourceFile); function delintNode(node) { switch (node.kind) { - case 189 /* ForStatement */: - case 190 /* ForInStatement */: - case 188 /* WhileStatement */: - case 187 /* DoStatement */: - if (node.statement.kind !== 182 /* Block */) { + case 191 /* ForStatement */: + case 192 /* ForInStatement */: + case 190 /* WhileStatement */: + case 189 /* DoStatement */: + if (node.statement.kind !== 184 /* Block */) { report(node, "A looping statement's contents should be wrapped in a block body."); } break; - case 186 /* IfStatement */: + case 188 /* IfStatement */: var ifStatement = node; - if (ifStatement.thenStatement.kind !== 182 /* Block */) { + if (ifStatement.thenStatement.kind !== 184 /* Block */) { report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); } if (ifStatement.elseStatement && - ifStatement.elseStatement.kind !== 182 /* Block */ && - ifStatement.elseStatement.kind !== 186 /* IfStatement */) { + ifStatement.elseStatement.kind !== 184 /* Block */ && + ifStatement.elseStatement.kind !== 188 /* IfStatement */) { report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); } break; - case 172 /* BinaryExpression */: + case 173 /* BinaryExpression */: var op = node.operatorToken.kind; - if (op === 28 /* EqualsEqualsToken */ || op == 29 /* ExclamationEqualsToken */) { + if (op === 29 /* EqualsEqualsToken */ || op == 30 /* ExclamationEqualsToken */) { report(node, "Use '===' and '!=='."); } break; diff --git a/tests/baselines/reference/asOperator1.js b/tests/baselines/reference/asOperator1.js new file mode 100644 index 00000000000..1b23d0a86f7 --- /dev/null +++ b/tests/baselines/reference/asOperator1.js @@ -0,0 +1,19 @@ +//// [asOperator1.ts] +var as = 43; +var x = undefined as number; +var y = (null as string).length; +var z = Date as any as string; + +// Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string' +var j = 32 as number|string; +j = ''; + + +//// [asOperator1.js] +var as = 43; +var x = undefined; +var y = null.length; +var z = Date; +// Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string' +var j = 32; +j = ''; diff --git a/tests/baselines/reference/asOperator1.symbols b/tests/baselines/reference/asOperator1.symbols new file mode 100644 index 00000000000..27353ec7b30 --- /dev/null +++ b/tests/baselines/reference/asOperator1.symbols @@ -0,0 +1,24 @@ +=== tests/cases/conformance/expressions/asOperator/asOperator1.ts === +var as = 43; +>as : Symbol(as, Decl(asOperator1.ts, 0, 3)) + +var x = undefined as number; +>x : Symbol(x, Decl(asOperator1.ts, 1, 3)) +>undefined : Symbol(undefined) + +var y = (null as string).length; +>y : Symbol(y, Decl(asOperator1.ts, 2, 3)) +>(null as string).length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) + +var z = Date as any as string; +>z : Symbol(z, Decl(asOperator1.ts, 3, 3)) +>Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) + +// Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string' +var j = 32 as number|string; +>j : Symbol(j, Decl(asOperator1.ts, 6, 3)) + +j = ''; +>j : Symbol(j, Decl(asOperator1.ts, 6, 3)) + diff --git a/tests/baselines/reference/asOperator1.types b/tests/baselines/reference/asOperator1.types new file mode 100644 index 00000000000..3f69871ea09 --- /dev/null +++ b/tests/baselines/reference/asOperator1.types @@ -0,0 +1,35 @@ +=== tests/cases/conformance/expressions/asOperator/asOperator1.ts === +var as = 43; +>as : number +>43 : number + +var x = undefined as number; +>x : number +>undefined as number : number +>undefined : undefined + +var y = (null as string).length; +>y : number +>(null as string).length : number +>(null as string) : string +>null as string : string +>null : null +>length : number + +var z = Date as any as string; +>z : string +>Date as any as string : string +>Date as any : any +>Date : DateConstructor + +// Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string' +var j = 32 as number|string; +>j : string | number +>32 as number|string : string | number +>32 : number + +j = ''; +>j = '' : string +>j : string | number +>'' : string + diff --git a/tests/baselines/reference/asOperator2.errors.txt b/tests/baselines/reference/asOperator2.errors.txt new file mode 100644 index 00000000000..3b074038c26 --- /dev/null +++ b/tests/baselines/reference/asOperator2.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/expressions/asOperator/asOperator2.ts(1,9): error TS2352: Neither type 'number' nor type 'string' is assignable to the other. + + +==== tests/cases/conformance/expressions/asOperator/asOperator2.ts (1 errors) ==== + var x = 23 as string; + ~~~~~~~~~~~~ +!!! error TS2352: Neither type 'number' nor type 'string' is assignable to the other. + \ No newline at end of file diff --git a/tests/baselines/reference/asOperator2.js b/tests/baselines/reference/asOperator2.js new file mode 100644 index 00000000000..32962555d51 --- /dev/null +++ b/tests/baselines/reference/asOperator2.js @@ -0,0 +1,6 @@ +//// [asOperator2.ts] +var x = 23 as string; + + +//// [asOperator2.js] +var x = 23; diff --git a/tests/baselines/reference/asOperator3.js b/tests/baselines/reference/asOperator3.js new file mode 100644 index 00000000000..406eae1c9d6 --- /dev/null +++ b/tests/baselines/reference/asOperator3.js @@ -0,0 +1,22 @@ +//// [asOperator3.ts] +declare function tag(...x: any[]): any; + +var a = `${123 + 456 as number}`; +var b = `leading ${123 + 456 as number}`; +var c = `${123 + 456 as number} trailing`; +var d = `Hello ${123} World` as string; +var e = `Hello` as string; +var f = 1 + `${1} end of string` as string; +var g = tag `Hello ${123} World` as string; +var h = tag `Hello` as string; + +//// [asOperator3.js] +var a = "" + 123 + 456; +var b = "leading " + 123 + 456; +var c = 123 + 456 + " trailing"; +var d = ("Hello " + 123 + " World"); +var e = "Hello"; +var f = 1 + (1 + " end of string"); +var g = (_a = ["Hello ", " World"], _a.raw = ["Hello ", " World"], tag(_a, 123)); +var h = (_b = ["Hello"], _b.raw = ["Hello"], tag(_b)); +var _a, _b; diff --git a/tests/baselines/reference/asOperator3.symbols b/tests/baselines/reference/asOperator3.symbols new file mode 100644 index 00000000000..d29a64d3c3a --- /dev/null +++ b/tests/baselines/reference/asOperator3.symbols @@ -0,0 +1,31 @@ +=== tests/cases/conformance/expressions/asOperator/asOperator3.ts === +declare function tag(...x: any[]): any; +>tag : Symbol(tag, Decl(asOperator3.ts, 0, 0)) +>x : Symbol(x, Decl(asOperator3.ts, 0, 21)) + +var a = `${123 + 456 as number}`; +>a : Symbol(a, Decl(asOperator3.ts, 2, 3)) + +var b = `leading ${123 + 456 as number}`; +>b : Symbol(b, Decl(asOperator3.ts, 3, 3)) + +var c = `${123 + 456 as number} trailing`; +>c : Symbol(c, Decl(asOperator3.ts, 4, 3)) + +var d = `Hello ${123} World` as string; +>d : Symbol(d, Decl(asOperator3.ts, 5, 3)) + +var e = `Hello` as string; +>e : Symbol(e, Decl(asOperator3.ts, 6, 3)) + +var f = 1 + `${1} end of string` as string; +>f : Symbol(f, Decl(asOperator3.ts, 7, 3)) + +var g = tag `Hello ${123} World` as string; +>g : Symbol(g, Decl(asOperator3.ts, 8, 3)) +>tag : Symbol(tag, Decl(asOperator3.ts, 0, 0)) + +var h = tag `Hello` as string; +>h : Symbol(h, Decl(asOperator3.ts, 9, 3)) +>tag : Symbol(tag, Decl(asOperator3.ts, 0, 0)) + diff --git a/tests/baselines/reference/asOperator3.types b/tests/baselines/reference/asOperator3.types new file mode 100644 index 00000000000..507dfd8b572 --- /dev/null +++ b/tests/baselines/reference/asOperator3.types @@ -0,0 +1,63 @@ +=== tests/cases/conformance/expressions/asOperator/asOperator3.ts === +declare function tag(...x: any[]): any; +>tag : (...x: any[]) => any +>x : any[] + +var a = `${123 + 456 as number}`; +>a : string +>`${123 + 456 as number}` : string +>123 + 456 as number : number +>123 + 456 : number +>123 : number +>456 : number + +var b = `leading ${123 + 456 as number}`; +>b : string +>`leading ${123 + 456 as number}` : string +>123 + 456 as number : number +>123 + 456 : number +>123 : number +>456 : number + +var c = `${123 + 456 as number} trailing`; +>c : string +>`${123 + 456 as number} trailing` : string +>123 + 456 as number : number +>123 + 456 : number +>123 : number +>456 : number + +var d = `Hello ${123} World` as string; +>d : string +>`Hello ${123} World` as string : string +>`Hello ${123} World` : string +>123 : number + +var e = `Hello` as string; +>e : string +>`Hello` as string : string +>`Hello` : string + +var f = 1 + `${1} end of string` as string; +>f : string +>1 + `${1} end of string` as string : string +>1 + `${1} end of string` : string +>1 : number +>`${1} end of string` : string +>1 : number + +var g = tag `Hello ${123} World` as string; +>g : string +>tag `Hello ${123} World` as string : string +>tag `Hello ${123} World` : any +>tag : (...x: any[]) => any +>`Hello ${123} World` : string +>123 : number + +var h = tag `Hello` as string; +>h : string +>tag `Hello` as string : string +>tag `Hello` : any +>tag : (...x: any[]) => any +>`Hello` : string + diff --git a/tests/baselines/reference/asOperatorASI.js b/tests/baselines/reference/asOperatorASI.js new file mode 100644 index 00000000000..1df39b36e50 --- /dev/null +++ b/tests/baselines/reference/asOperatorASI.js @@ -0,0 +1,26 @@ +//// [asOperatorASI.ts] +class Foo { } +declare function as(...args: any[]); + +// Example 1 +var x = 10 +as `Hello world`; // should not error + +// Example 2 +var y = 20 +as(Foo); // should emit + + +//// [asOperatorASI.js] +var Foo = (function () { + function Foo() { + } + return Foo; +})(); +// Example 1 +var x = 10; +(_a = ["Hello world"], _a.raw = ["Hello world"], as(_a)); // should not error +// Example 2 +var y = 20; +as(Foo); // should emit +var _a; diff --git a/tests/baselines/reference/asOperatorASI.symbols b/tests/baselines/reference/asOperatorASI.symbols new file mode 100644 index 00000000000..7def6d460c1 --- /dev/null +++ b/tests/baselines/reference/asOperatorASI.symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/expressions/asOperator/asOperatorASI.ts === +class Foo { } +>Foo : Symbol(Foo, Decl(asOperatorASI.ts, 0, 0)) + +declare function as(...args: any[]); +>as : Symbol(as, Decl(asOperatorASI.ts, 0, 13)) +>args : Symbol(args, Decl(asOperatorASI.ts, 1, 20)) + +// Example 1 +var x = 10 +>x : Symbol(x, Decl(asOperatorASI.ts, 4, 3)) + +as `Hello world`; // should not error +>as : Symbol(as, Decl(asOperatorASI.ts, 0, 13)) + +// Example 2 +var y = 20 +>y : Symbol(y, Decl(asOperatorASI.ts, 8, 3)) + +as(Foo); // should emit +>as : Symbol(as, Decl(asOperatorASI.ts, 0, 13)) +>Foo : Symbol(Foo, Decl(asOperatorASI.ts, 0, 0)) + diff --git a/tests/baselines/reference/asOperatorASI.types b/tests/baselines/reference/asOperatorASI.types new file mode 100644 index 00000000000..61c2d115cf4 --- /dev/null +++ b/tests/baselines/reference/asOperatorASI.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/expressions/asOperator/asOperatorASI.ts === +class Foo { } +>Foo : Foo + +declare function as(...args: any[]); +>as : (...args: any[]) => any +>args : any[] + +// Example 1 +var x = 10 +>x : number +>10 : number + +as `Hello world`; // should not error +>as `Hello world` : any +>as : (...args: any[]) => any +>`Hello world` : string + +// Example 2 +var y = 20 +>y : number +>20 : number + +as(Foo); // should emit +>as(Foo) : any +>as : (...args: any[]) => any +>Foo : typeof Foo + diff --git a/tests/baselines/reference/asOperatorAmbiguity.errors.txt b/tests/baselines/reference/asOperatorAmbiguity.errors.txt new file mode 100644 index 00000000000..cb7c6d4132c --- /dev/null +++ b/tests/baselines/reference/asOperatorAmbiguity.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/expressions/asOperator/asOperatorAmbiguity.ts(7,14): error TS2339: Property 'm' does not exist on type 'A'. + + +==== tests/cases/conformance/expressions/asOperator/asOperatorAmbiguity.ts (1 errors) ==== + interface A { x: T; } + interface B { m: string; } + + // Make sure this is a type assertion to an array type, and not nested comparison operators. + var x: any; + var y = x as A[]; + var z = y[0].m; // z should be string + ~ +!!! error TS2339: Property 'm' does not exist on type 'A'. + + \ No newline at end of file diff --git a/tests/baselines/reference/asOperatorAmbiguity.js b/tests/baselines/reference/asOperatorAmbiguity.js new file mode 100644 index 00000000000..6c336970b65 --- /dev/null +++ b/tests/baselines/reference/asOperatorAmbiguity.js @@ -0,0 +1,16 @@ +//// [asOperatorAmbiguity.ts] +interface A { x: T; } +interface B { m: string; } + +// Make sure this is a type assertion to an array type, and not nested comparison operators. +var x: any; +var y = x as A[]; +var z = y[0].m; // z should be string + + + +//// [asOperatorAmbiguity.js] +// Make sure this is a type assertion to an array type, and not nested comparison operators. +var x; +var y = x; +var z = y[0].m; // z should be string diff --git a/tests/baselines/reference/asOperatorContextualType.errors.txt b/tests/baselines/reference/asOperatorContextualType.errors.txt new file mode 100644 index 00000000000..c53b407b5cf --- /dev/null +++ b/tests/baselines/reference/asOperatorContextualType.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts(2,9): error TS2352: Neither type '(v: number) => number' nor type '(x: number) => string' is assignable to the other. + Type 'number' is not assignable to type 'string'. + + +==== tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts (1 errors) ==== + // should error + var x = (v => v) as (x: number) => string; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2352: Neither type '(v: number) => number' nor type '(x: number) => string' is assignable to the other. +!!! error TS2352: Type 'number' is not assignable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/asOperatorContextualType.js b/tests/baselines/reference/asOperatorContextualType.js new file mode 100644 index 00000000000..7b495ada8f4 --- /dev/null +++ b/tests/baselines/reference/asOperatorContextualType.js @@ -0,0 +1,7 @@ +//// [asOperatorContextualType.ts] +// should error +var x = (v => v) as (x: number) => string; + +//// [asOperatorContextualType.js] +// should error +var x = (function (v) { return v; }); diff --git a/tests/baselines/reference/asOperatorNames.errors.txt b/tests/baselines/reference/asOperatorNames.errors.txt new file mode 100644 index 00000000000..e3dfaab9884 --- /dev/null +++ b/tests/baselines/reference/asOperatorNames.errors.txt @@ -0,0 +1,11 @@ +tests/cases/conformance/expressions/asOperator/asOperatorNames.ts(2,9): error TS2352: Neither type 'number' nor type 'string' is assignable to the other. + + +==== tests/cases/conformance/expressions/asOperator/asOperatorNames.ts (1 errors) ==== + var a = 20; + var b = a as string; + ~~~~~~~~~~~ +!!! error TS2352: Neither type 'number' nor type 'string' is assignable to the other. + var as = "hello"; + var as1 = as as string; + \ No newline at end of file diff --git a/tests/baselines/reference/asOperatorNames.js b/tests/baselines/reference/asOperatorNames.js new file mode 100644 index 00000000000..35e80d080e3 --- /dev/null +++ b/tests/baselines/reference/asOperatorNames.js @@ -0,0 +1,12 @@ +//// [asOperatorNames.ts] +var a = 20; +var b = a as string; +var as = "hello"; +var as1 = as as string; + + +//// [asOperatorNames.js] +var a = 20; +var b = a; +var as = "hello"; +var as1 = as; diff --git a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt new file mode 100644 index 00000000000..8e7132007d8 --- /dev/null +++ b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt @@ -0,0 +1,125 @@ +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,13): error TS2304: Cannot find name 'test'. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,17): error TS1005: '}' expected. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,19): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(9,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(9,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,17): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,32): error TS1005: '}' expected. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(13,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(13,16): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(13,36): error TS1005: '}' expected. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,16): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,31): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,45): error TS1005: '}' expected. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(17,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(17,23): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,7): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,12): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,34): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,39): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,53): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,58): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS1005: ':' expected. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expected corresponding JSX closing tag for 'any'. +tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expected corresponding JSX closing tag for 'foo'. + + +==== tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx (28 errors) ==== + + declare var createElement: any; + + class foo {} + + var x: any; + x = { test: }; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~ +!!! error TS2304: Cannot find name 'test'. + ~ +!!! error TS1005: '}' expected. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + x = ; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + x = hello {{}} ; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1005: '}' expected. + + x = {}}>hello; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1005: '}' expected. + + + x = {}}>hello{{}}; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1005: '}' expected. + + + + x = x, x = ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + + + {{/foo/.test(x) ? : }} + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + + + + ~~~~ + ~~~~ + + +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +!!! error TS1005: ':' expected. + +!!! error TS17002: Expected corresponding JSX closing tag for 'any'. + +!!! error TS17002: Expected corresponding JSX closing tag for 'foo'. \ No newline at end of file diff --git a/tests/baselines/reference/jsxAndTypeAssertion.js b/tests/baselines/reference/jsxAndTypeAssertion.js new file mode 100644 index 00000000000..26af23a2051 --- /dev/null +++ b/tests/baselines/reference/jsxAndTypeAssertion.js @@ -0,0 +1,47 @@ +//// [jsxAndTypeAssertion.tsx] + +declare var createElement: any; + +class foo {} + +var x: any; +x = { test: }; + +x = ; + +x = hello {{}} ; + +x = {}}>hello; + +x = {}}>hello{{}}; + +x = x, x = ; + +{{/foo/.test(x) ? : }} + + + + +//// [jsxAndTypeAssertion.jsx] +var foo = (function () { + function foo() { + } + return foo; +})(); +var x; +x = {test}: }; + +x = ; + +x = hello {} }; + +x = }>hello} x=}>hello{}}; + +x = x, x = ; + +{{/foo/.test(x) ? : }} + : +} + + +}}>>; diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt b/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt new file mode 100644 index 00000000000..b6c083e3309 --- /dev/null +++ b/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt @@ -0,0 +1,131 @@ +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(9,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(15,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(17,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(18,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(21,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(23,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(29,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(29,11): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(29,19): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(31,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(33,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(35,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(37,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(37,6): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,17): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,29): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(41,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(43,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(45,2): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(47,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(49,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(51,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(53,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. + + +==== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx (24 errors) ==== + declare var React: any; + declare var 日本語; + declare var AbC_def; + declare var LeftRight; + declare var x; + declare var a; + declare var props; + + ; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + //; Namespace unsuported + + // {value} ; Namespace unsuported + + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ; + ~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + <日本語>; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + bar + baz + ; + + : } />; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + {}; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + {/* this is a comment */}; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +
@test content
; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +

7x invalid-js-identifier
; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + right=monkeys /> gorillas />; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + (
) < x; + ~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +
; + ~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +
; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +
; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + \ No newline at end of file diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.js b/tests/baselines/reference/jsxEsprimaFbTestSuite.js new file mode 100644 index 00000000000..2050c39972c --- /dev/null +++ b/tests/baselines/reference/jsxEsprimaFbTestSuite.js @@ -0,0 +1,81 @@ +//// [jsxEsprimaFbTestSuite.tsx] +declare var React: any; +declare var 日本語; +declare var AbC_def; +declare var LeftRight; +declare var x; +declare var a; +declare var props; + +; + +//; Namespace unsuported + +// {value} ; Namespace unsuported + +; + +; +; + +<日本語>; + + +bar +baz +; + + : } />; + +{}; + +{/* this is a comment */}; + +
@test content
; + +

7x invalid-js-identifier
; + + right=monkeys /> gorillas />; + +; + +; + +(
) < x; + +
; + +
; + +
; + + ; + + +//// [jsxEsprimaFbTestSuite.jsx] +; +//; Namespace unsuported +// {value} ; Namespace unsuported +; +; +; +<日本語>; + +bar +baz +; + : }/>; +; +; +
@test content
; +

7x invalid-js-identifier
; + right=monkeys /> gorillas/>; +; +; +(
) < x; +
; +
; +
; + ; diff --git a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt new file mode 100644 index 00000000000..7f3d60f8361 --- /dev/null +++ b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt @@ -0,0 +1,283 @@ +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,2): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,3): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,2): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,6): error TS1005: '{' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,6): error TS2304: Cannot find name 'd'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,9): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,10): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,1): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(8,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(8,4): error TS17002: Expected corresponding JSX closing tag for 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(9,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(9,13): error TS1002: Unterminated string literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,1): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,3): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,6): error TS17002: Expected corresponding JSX closing tag for 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,3): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,5): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,11): error TS1005: '>' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,5): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,13): error TS1005: '>' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,8): error TS17002: Expected corresponding JSX closing tag for 'a.b.c'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,2): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,7): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,4): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,9): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,3): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,12): error TS1005: '>' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,3): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,14): error TS1005: '>' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,4): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(19,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(20,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(20,23): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(21,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(21,50): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(22,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(22,10): error TS1005: '}' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(23,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(23,20): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(24,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(24,15): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(25,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(25,7): error TS1005: '...' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(25,7): error TS2304: Cannot find name 'props'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(27,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(27,17): error TS1005: '>' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(27,18): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,10): error TS2304: Cannot find name 'props'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,28): error TS1005: '>' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,29): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(30,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(31,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(32,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(32,6): error TS1005: '{' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,6): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,7): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(34,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,4): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS1005: '; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. + ; + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. + <:a />; + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. + ; + ~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1005: '{' expected. + ~ +!!! error TS2304: Cannot find name 'd'. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1109: Expression expected. + ; + ~ +!!! error TS1003: Identifier expected. + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~ +!!! error TS17002: Expected corresponding JSX closing tag for 'a'. + ; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1005: '}' expected. + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. +
; + ~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS1003: Identifier expected. +
; + ~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS1005: '...' expected. + ~~~~~ +!!! error TS2304: Cannot find name 'props'. + +
stuff
; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1005: '>' expected. + ~~~ +!!! error TS1109: Expression expected. +
stuff
; + ~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~ +!!! error TS2304: Cannot find name 'props'. + ~ +!!! error TS1005: '>' expected. + ~~~ +!!! error TS1109: Expression expected. + + >; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + >; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ; + ~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1005: '{' expected. + ; + ~~~~~~~~~ + ~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. + }; + ~~~~~~~~~ + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ; + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~ +!!! error TS1003: Identifier expected. + +!!! error TS1005: '; +; +<:a />; +; +; +; +; +; +
; +
; + +
stuff
; +
stuff
; + +>; + >; +; +; +}; +; + +//// [jsxInvalidEsprimaTestSuite.jsx] +< />; +; +< a=/>; + }> +; +; +; +; +
"app">; +
; + +
stuff
{}...props}>; +
stuff
{}...props}>; + +>; + >; +; +}>; +}; +;>; diff --git a/tests/baselines/reference/jsxReactTestSuite.errors.txt b/tests/baselines/reference/jsxReactTestSuite.errors.txt new file mode 100644 index 00000000000..4e9e5c42492 --- /dev/null +++ b/tests/baselines/reference/jsxReactTestSuite.errors.txt @@ -0,0 +1,246 @@ +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(15,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(17,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(21,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(22,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(22,8): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(23,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(23,19): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(24,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(28,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(32,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(33,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(37,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(55,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(58,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(62,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(69,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(73,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(79,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(81,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(83,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(85,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(87,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(89,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(91,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(94,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(97,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(99,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(101,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(103,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(105,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(107,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(109,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(112,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(112,38): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxReactTestSuite.tsx(114,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. + + +==== tests/cases/conformance/jsx/jsxReactTestSuite.tsx (35 errors) ==== + + declare var React: any; + declare var Component:any; + declare var Composite:any; + declare var Composite2:any; + declare var Child:any; + declare var Namespace:any; + declare var foo: any; + declare var bar: any; + declare var y:any; + declare var x:any; + declare var z:any; + declare var hasOwnProperty:any; + +
text
; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +
+ ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + {this.props.children} +
; + +
+ ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. +

+ ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + {foo}
{bar} + ~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. +
+ ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. +
; + + + + ~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + {this.props.children} + ; + + + ~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ; + + var x = +
+ ~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. +
; + + ( +
+ ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + {/* A comment at the beginning */} + {/* A second comment at the beginning */} + + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + {/* A nested comment */} + + {/* A sandwiched comment */} +
+ ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + {/* A comment at the end */} + {/* A second comment at the end */} +
+ ); + + ( +
+ ~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. +
+ ); + +
 
; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + +
 
; + ~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + testing; + ~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + + ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + Text; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + + \ No newline at end of file diff --git a/tests/baselines/reference/jsxReactTestSuite.js b/tests/baselines/reference/jsxReactTestSuite.js new file mode 100644 index 00000000000..300274a1614 --- /dev/null +++ b/tests/baselines/reference/jsxReactTestSuite.js @@ -0,0 +1,171 @@ +//// [jsxReactTestSuite.tsx] + +declare var React: any; +declare var Component:any; +declare var Composite:any; +declare var Composite2:any; +declare var Child:any; +declare var Namespace:any; +declare var foo: any; +declare var bar: any; +declare var y:any; +declare var x:any; +declare var z:any; +declare var hasOwnProperty:any; + +
text
; + +
+ {this.props.children} +
; + +
+

+ {foo}
{bar} +
+
; + + + + {this.props.children} +; + + + +; + +var x = +
+
; + +( +
+ {/* A comment at the beginning */} + {/* A second comment at the beginning */} + + {/* A nested comment */} + + {/* A sandwiched comment */} +
+ {/* A comment at the end */} + {/* A second comment at the end */} +
+); + +( +
+ +
+); + +
 
; + +
 
; + +testing; + +; + +; + +; + +; + +; + +; + +; + +; + +; + +; + +; + +; + + +; + +Text; + + + + +//// [jsxReactTestSuite.jsx] +
text
; +
+ {this.props.children} +
; +
+

+ {foo}
{bar} +
+
; + + {this.props.children} +; + + +; +var x =
+
; +(
+ + + + + + +
+ + +
); +(
+ +
); +
 
; +
 
; +testing; +; +; +; +; +; +; +; +; +; +; +; +; +; +Text; diff --git a/tests/baselines/reference/project/invalidRootFile/amd/invalidRootFile.errors.txt b/tests/baselines/reference/project/invalidRootFile/amd/invalidRootFile.errors.txt index 656b6e1f2a2..bafcc39f48d 100644 --- a/tests/baselines/reference/project/invalidRootFile/amd/invalidRootFile.errors.txt +++ b/tests/baselines/reference/project/invalidRootFile/amd/invalidRootFile.errors.txt @@ -1,6 +1,6 @@ error TS6053: File 'a.ts' not found. -error TS6054: File 'a.t' has unsupported extension. The only supported extensions are '.ts', '.d.ts'. +error TS6054: File 'a.t' has unsupported extension. The only supported extensions are '.tsx', '.ts', '.d.ts'. !!! error TS6053: File 'a.ts' not found. -!!! error TS6054: File 'a.t' has unsupported extension. The only supported extensions are '.ts', '.d.ts'. \ No newline at end of file +!!! error TS6054: File 'a.t' has unsupported extension. The only supported extensions are '.tsx', '.ts', '.d.ts'. \ No newline at end of file diff --git a/tests/baselines/reference/project/invalidRootFile/node/invalidRootFile.errors.txt b/tests/baselines/reference/project/invalidRootFile/node/invalidRootFile.errors.txt index 656b6e1f2a2..bafcc39f48d 100644 --- a/tests/baselines/reference/project/invalidRootFile/node/invalidRootFile.errors.txt +++ b/tests/baselines/reference/project/invalidRootFile/node/invalidRootFile.errors.txt @@ -1,6 +1,6 @@ error TS6053: File 'a.ts' not found. -error TS6054: File 'a.t' has unsupported extension. The only supported extensions are '.ts', '.d.ts'. +error TS6054: File 'a.t' has unsupported extension. The only supported extensions are '.tsx', '.ts', '.d.ts'. !!! error TS6053: File 'a.ts' not found. -!!! error TS6054: File 'a.t' has unsupported extension. The only supported extensions are '.ts', '.d.ts'. \ No newline at end of file +!!! error TS6054: File 'a.t' has unsupported extension. The only supported extensions are '.tsx', '.ts', '.d.ts'. \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeErrors.errors.txt b/tests/baselines/reference/tsxAttributeErrors.errors.txt new file mode 100644 index 00000000000..30a897c5163 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeErrors.errors.txt @@ -0,0 +1,40 @@ +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(15,6): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(18,6): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/jsx/tsxAttributeErrors.tsx(22,6): error TS2606: Property 'text' of JSX spread attribute is not assignable to target property. + Type 'number' is not assignable to type 'string'. + + +==== tests/cases/conformance/jsx/tsxAttributeErrors.tsx (3 errors) ==== + + declare namespace JSX { + interface Element { } + interface IntrinsicElements { + div: { + text?: string; + width?: number; + } + + span: any; + } + } + + // Error, number is not assignable to string +
; + ~~~~~~~~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + + // Error, string is not assignable to number +
; + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + + // Error, number is not assignable to string + var attribs = { text: 100 }; +
; + ~~~~~~~~~~~~ +!!! error TS2606: Property 'text' of JSX spread attribute is not assignable to target property. +!!! error TS2606: Type 'number' is not assignable to type 'string'. + + // No errors here + ; + \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeErrors.js b/tests/baselines/reference/tsxAttributeErrors.js new file mode 100644 index 00000000000..2ab862e0efe --- /dev/null +++ b/tests/baselines/reference/tsxAttributeErrors.js @@ -0,0 +1,38 @@ +//// [tsxAttributeErrors.tsx] + +declare namespace JSX { + interface Element { } + interface IntrinsicElements { + div: { + text?: string; + width?: number; + } + + span: any; + } +} + +// Error, number is not assignable to string +
; + +// Error, string is not assignable to number +
; + +// Error, number is not assignable to string +var attribs = { text: 100 }; +
; + +// No errors here +; + + +//// [tsxAttributeErrors.jsx] +// Error, number is not assignable to string +
; +// Error, string is not assignable to number +
; +// Error, number is not assignable to string +var attribs = { text: 100 }; +
; +// No errors here +; diff --git a/tests/baselines/reference/tsxAttributeInvalidNames.errors.txt b/tests/baselines/reference/tsxAttributeInvalidNames.errors.txt new file mode 100644 index 00000000000..055062237d8 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeInvalidNames.errors.txt @@ -0,0 +1,25 @@ +tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx(9,8): error TS1003: Identifier expected. +tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx(10,8): error TS1003: Identifier expected. +tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx(10,22): error TS1005: '; + ~~ +!!! error TS1003: Identifier expected. + ; + ~ +!!! error TS1003: Identifier expected. + +!!! error TS1005: '; +; + +//// [tsxAttributeInvalidNames.jsx] +// Invalid names + 32data={32} />; + -data={32} />;; diff --git a/tests/baselines/reference/tsxAttributeResolution.js b/tests/baselines/reference/tsxAttributeResolution.js new file mode 100644 index 00000000000..3acd9b702e1 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution.js @@ -0,0 +1,14 @@ +//// [tsxAttributeResolution.tsx] +/// @jsx: preserve + +declare namespace JSX { + interface IntrinsicElements { + x: { y: number; z: string; }; + } +} + + + + +//// [tsxAttributeResolution.jsx] +/// @jsx: preserve diff --git a/tests/baselines/reference/tsxAttributeResolution.symbols b/tests/baselines/reference/tsxAttributeResolution.symbols new file mode 100644 index 00000000000..06a0b32f637 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/jsx/tsxAttributeResolution.tsx === +/// @jsx: preserve + +declare namespace JSX { +>JSX : Symbol(JSX, Decl(tsxAttributeResolution.tsx, 0, 0)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxAttributeResolution.tsx, 2, 23)) + + x: { y: number; z: string; }; +>x : Symbol(x, Decl(tsxAttributeResolution.tsx, 3, 30)) +>y : Symbol(y, Decl(tsxAttributeResolution.tsx, 4, 6)) +>z : Symbol(z, Decl(tsxAttributeResolution.tsx, 4, 17)) + } +} + + + diff --git a/tests/baselines/reference/tsxAttributeResolution.types b/tests/baselines/reference/tsxAttributeResolution.types new file mode 100644 index 00000000000..5e54c43bf80 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/jsx/tsxAttributeResolution.tsx === +/// @jsx: preserve + +declare namespace JSX { +>JSX : any + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + x: { y: number; z: string; }; +>x : { y: number; z: string; } +>y : number +>z : string + } +} + + + diff --git a/tests/baselines/reference/tsxAttributeResolution1.errors.txt b/tests/baselines/reference/tsxAttributeResolution1.errors.txt new file mode 100644 index 00000000000..54666f46aba --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution1.errors.txt @@ -0,0 +1,53 @@ +tests/cases/conformance/jsx/tsxAttributeResolution1.tsx(22,8): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/jsx/tsxAttributeResolution1.tsx(23,8): error TS2339: Property 'y' does not exist on type 'Attribs1'. +tests/cases/conformance/jsx/tsxAttributeResolution1.tsx(24,8): error TS2339: Property 'y' does not exist on type 'Attribs1'. +tests/cases/conformance/jsx/tsxAttributeResolution1.tsx(25,8): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/jsx/tsxAttributeResolution1.tsx(29,1): error TS2324: Property 'reqd' is missing in type '{ reqd: string; }'. +tests/cases/conformance/jsx/tsxAttributeResolution1.tsx(30,8): error TS2322: Type 'number' is not assignable to type 'string'. + + +==== tests/cases/conformance/jsx/tsxAttributeResolution1.tsx (6 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + test2: { reqd: string }; + } + } + interface Attribs1 { + x?: number; + s?: string; + } + + // OK + ; // OK + ; // OK + ; // OK + + ; // OK + ; // OK + + // Errors + ; // Error, '0' is not number + ~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ; // Error, no property "y" + ~ +!!! error TS2339: Property 'y' does not exist on type 'Attribs1'. + ; // Error, no property "y" + ~ +!!! error TS2339: Property 'y' does not exist on type 'Attribs1'. + ; // Error, "32" is not number + ~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + // TODO attribute 'var' should be parseable + // ; // Error, no 'var' property + + ; // Error, missing reqd + ~~~~~~~~~ +!!! error TS2324: Property 'reqd' is missing in type '{ reqd: string; }'. + ; // Error, reqd is not string + ~~~~~~~~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + + \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeResolution1.js b/tests/baselines/reference/tsxAttributeResolution1.js new file mode 100644 index 00000000000..011ac8034e2 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution1.js @@ -0,0 +1,50 @@ +//// [tsxAttributeResolution1.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + test2: { reqd: string }; + } +} +interface Attribs1 { + x?: number; + s?: string; +} + +// OK +; // OK +; // OK +; // OK + +; // OK +; // OK + +// Errors +; // Error, '0' is not number +; // Error, no property "y" +; // Error, no property "y" +; // Error, "32" is not number +// TODO attribute 'var' should be parseable +// ; // Error, no 'var' property + +; // Error, missing reqd +; // Error, reqd is not string + + + +//// [tsxAttributeResolution1.jsx] +// OK +; // OK +; // OK +; // OK +; // OK +; // OK +// Errors +; // Error, '0' is not number +; // Error, no property "y" +; // Error, no property "y" +; // Error, "32" is not number +// TODO attribute 'var' should be parseable +// ; // Error, no 'var' property +; // Error, missing reqd +; // Error, reqd is not string diff --git a/tests/baselines/reference/tsxAttributeResolution2.errors.txt b/tests/baselines/reference/tsxAttributeResolution2.errors.txt new file mode 100644 index 00000000000..d213ccaf54e --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution2.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/jsx/tsxAttributeResolution2.tsx(17,21): error TS2339: Property 'leng' does not exist on type 'string'. + + +==== tests/cases/conformance/jsx/tsxAttributeResolution2.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } + } + interface Attribs1 { + c1?: (x: string) => void; + } + + // OK + x.length} />; // OK + x.leng} />; // OK + + + // Errors + x.leng} />; // Error, no leng on 'string' + ~~~~ +!!! error TS2339: Property 'leng' does not exist on type 'string'. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeResolution2.js b/tests/baselines/reference/tsxAttributeResolution2.js new file mode 100644 index 00000000000..564767e6169 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution2.js @@ -0,0 +1,26 @@ +//// [tsxAttributeResolution2.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } +} +interface Attribs1 { + c1?: (x: string) => void; +} + +// OK + x.length} />; // OK + x.leng} />; // OK + + +// Errors + x.leng} />; // Error, no leng on 'string' + + +//// [tsxAttributeResolution2.jsx] +// OK +; // OK +; // OK +// Errors +; // Error, no leng on 'string' diff --git a/tests/baselines/reference/tsxAttributeResolution3.errors.txt b/tests/baselines/reference/tsxAttributeResolution3.errors.txt new file mode 100644 index 00000000000..c797362e8d7 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution3.errors.txt @@ -0,0 +1,59 @@ +tests/cases/conformance/jsx/tsxAttributeResolution3.tsx(19,8): error TS2606: Property 'x' of JSX spread attribute is not assignable to target property. + Type 'number' is not assignable to type 'string'. +tests/cases/conformance/jsx/tsxAttributeResolution3.tsx(23,1): error TS2324: Property 'x' is missing in type 'Attribs1'. +tests/cases/conformance/jsx/tsxAttributeResolution3.tsx(31,15): error TS2606: Property 'x' of JSX spread attribute is not assignable to target property. + Type 'number' is not assignable to type 'string'. +tests/cases/conformance/jsx/tsxAttributeResolution3.tsx(39,8): error TS2322: Type 'number' is not assignable to type 'string'. + + +==== tests/cases/conformance/jsx/tsxAttributeResolution3.tsx (4 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } + } + interface Attribs1 { + x: string; + y?: number; + z?: string; + } + + // OK + var obj1 = { x: 'foo' }; + + + // Error, x is not string + var obj2 = { x: 32 }; + + ~~~~~~~~~ +!!! error TS2606: Property 'x' of JSX spread attribute is not assignable to target property. +!!! error TS2606: Type 'number' is not assignable to type 'string'. + + // Error, x is missing + var obj3 = { y: 32 }; + + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2324: Property 'x' is missing in type 'Attribs1'. + + // OK + var obj4 = { x: 32, y: 32 }; + + + // Error + var obj5 = { x: 32, y: 32 }; + + ~~~~~~~~~ +!!! error TS2606: Property 'x' of JSX spread attribute is not assignable to target property. +!!! error TS2606: Type 'number' is not assignable to type 'string'. + + // OK + var obj6 = { x: 'ok', y: 32, extra: 100 }; + + + // Error + var obj7 = { x: 'foo' }; + + ~~~~~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeResolution3.js b/tests/baselines/reference/tsxAttributeResolution3.js new file mode 100644 index 00000000000..8cf853820e1 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution3.js @@ -0,0 +1,64 @@ +//// [tsxAttributeResolution3.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } +} +interface Attribs1 { + x: string; + y?: number; + z?: string; +} + +// OK +var obj1 = { x: 'foo' }; + + +// Error, x is not string +var obj2 = { x: 32 }; + + +// Error, x is missing +var obj3 = { y: 32 }; + + +// OK +var obj4 = { x: 32, y: 32 }; + + +// Error +var obj5 = { x: 32, y: 32 }; + + +// OK +var obj6 = { x: 'ok', y: 32, extra: 100 }; + + +// Error +var obj7 = { x: 'foo' }; + + + +//// [tsxAttributeResolution3.jsx] +// OK +var obj1 = { x: 'foo' }; +; +// Error, x is not string +var obj2 = { x: 32 }; +; +// Error, x is missing +var obj3 = { y: 32 }; +; +// OK +var obj4 = { x: 32, y: 32 }; +; +// Error +var obj5 = { x: 32, y: 32 }; +; +// OK +var obj6 = { x: 'ok', y: 32, extra: 100 }; +; +// Error +var obj7 = { x: 'foo' }; +; diff --git a/tests/baselines/reference/tsxAttributeResolution4.errors.txt b/tests/baselines/reference/tsxAttributeResolution4.errors.txt new file mode 100644 index 00000000000..211a349b304 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution4.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/jsx/tsxAttributeResolution4.tsx(15,26): error TS2339: Property 'len' does not exist on type 'string'. + + +==== tests/cases/conformance/jsx/tsxAttributeResolution4.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } + } + interface Attribs1 { + x(n: string): void; + } + + // OK + 0} } />; + + // Error, no member 'len' on 'string' + n.len} } />; + ~~~ +!!! error TS2339: Property 'len' does not exist on type 'string'. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeResolution4.js b/tests/baselines/reference/tsxAttributeResolution4.js new file mode 100644 index 00000000000..d56cb4cc2e8 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution4.js @@ -0,0 +1,23 @@ +//// [tsxAttributeResolution4.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + } +} +interface Attribs1 { + x(n: string): void; +} + +// OK + 0} } />; + +// Error, no member 'len' on 'string' + n.len} } />; + + +//// [tsxAttributeResolution4.jsx] +// OK +; +// Error, no member 'len' on 'string' +; diff --git a/tests/baselines/reference/tsxAttributeResolution5.errors.txt b/tests/baselines/reference/tsxAttributeResolution5.errors.txt new file mode 100644 index 00000000000..1b42dd01465 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution5.errors.txt @@ -0,0 +1,45 @@ +tests/cases/conformance/jsx/tsxAttributeResolution5.tsx(21,16): error TS2606: Property 'x' of JSX spread attribute is not assignable to target property. + Type 'number' is not assignable to type 'string'. +tests/cases/conformance/jsx/tsxAttributeResolution5.tsx(25,9): error TS2324: Property 'x' is missing in type 'Attribs1'. +tests/cases/conformance/jsx/tsxAttributeResolution5.tsx(29,1): error TS2324: Property 'x' is missing in type 'Attribs1'. + + +==== tests/cases/conformance/jsx/tsxAttributeResolution5.tsx (3 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + test2: Attribs2; + } + } + interface Attribs1 { + x: string; + } + + interface Attribs2 { + toString(): string; + } + + function make1 (obj: T) { + return ; // OK + } + + function make2 (obj: T) { + return ; // Error (x is number, not string) + ~~~~~~~~ +!!! error TS2606: Property 'x' of JSX spread attribute is not assignable to target property. +!!! error TS2606: Type 'number' is not assignable to type 'string'. + } + + function make3 (obj: T) { + return ; // Error, missing x + ~~~~~~~~~~~~~~~~~~ +!!! error TS2324: Property 'x' is missing in type 'Attribs1'. + } + + + ; // Error, missing x + ~~~~~~~~~~~~~~~~~ +!!! error TS2324: Property 'x' is missing in type 'Attribs1'. + ; // OK + \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeResolution5.js b/tests/baselines/reference/tsxAttributeResolution5.js new file mode 100644 index 00000000000..34fe9a3bfb6 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution5.js @@ -0,0 +1,45 @@ +//// [tsxAttributeResolution5.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: Attribs1; + test2: Attribs2; + } +} +interface Attribs1 { + x: string; +} + +interface Attribs2 { + toString(): string; +} + +function make1 (obj: T) { + return ; // OK +} + +function make2 (obj: T) { + return ; // Error (x is number, not string) +} + +function make3 (obj: T) { + return ; // Error, missing x +} + + +; // Error, missing x +; // OK + + +//// [tsxAttributeResolution5.jsx] +function make1(obj) { + return ; // OK +} +function make2(obj) { + return ; // Error (x is number, not string) +} +function make3(obj) { + return ; // Error, missing x +} +; // Error, missing x +; // OK diff --git a/tests/baselines/reference/tsxAttributeResolution6.errors.txt b/tests/baselines/reference/tsxAttributeResolution6.errors.txt new file mode 100644 index 00000000000..4f1960358a5 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution6.errors.txt @@ -0,0 +1,30 @@ +tests/cases/conformance/jsx/tsxAttributeResolution6.tsx(10,8): error TS2322: Type 'boolean' is not assignable to type 'string'. +tests/cases/conformance/jsx/tsxAttributeResolution6.tsx(11,8): error TS2322: Type 'string' is not assignable to type 'boolean'. +tests/cases/conformance/jsx/tsxAttributeResolution6.tsx(12,1): error TS2324: Property 'n' is missing in type '{ n: boolean; }'. + + +==== tests/cases/conformance/jsx/tsxAttributeResolution6.tsx (3 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: { n?: boolean; s?: string}; + test2: { n: boolean; }; + } + } + + // Error + ; + ~ +!!! error TS2322: Type 'boolean' is not assignable to type 'string'. + ; + ~~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'boolean'. + ; + ~~~~~~~~~ +!!! error TS2324: Property 'n' is missing in type '{ n: boolean; }'. + + // OK + ; + ; + ; + \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeResolution6.js b/tests/baselines/reference/tsxAttributeResolution6.js new file mode 100644 index 00000000000..f4af0ba875a --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution6.js @@ -0,0 +1,29 @@ +//// [tsxAttributeResolution6.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: { n?: boolean; s?: string}; + test2: { n: boolean; }; + } +} + +// Error +; +; +; + +// OK +; +; +; + + +//// [tsxAttributeResolution6.jsx] +// Error +; +; +; +// OK +; +; +; diff --git a/tests/baselines/reference/tsxAttributeResolution7.errors.txt b/tests/baselines/reference/tsxAttributeResolution7.errors.txt new file mode 100644 index 00000000000..4d05254ace8 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution7.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/jsx/tsxAttributeResolution7.tsx(9,8): error TS2322: Type 'number' is not assignable to type 'string'. + + +==== tests/cases/conformance/jsx/tsxAttributeResolution7.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: { "data-foo"?: string }; + } + } + + // Error + ; + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + + // OK + ; + ; + ; + \ No newline at end of file diff --git a/tests/baselines/reference/tsxAttributeResolution7.js b/tests/baselines/reference/tsxAttributeResolution7.js new file mode 100644 index 00000000000..7ebd2e8f4db --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution7.js @@ -0,0 +1,24 @@ +//// [tsxAttributeResolution7.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: { "data-foo"?: string }; + } +} + +// Error +; + +// OK +; +; +; + + +//// [tsxAttributeResolution7.jsx] +// Error +; +// OK +; +; +; diff --git a/tests/baselines/reference/tsxElementResolution.errors.txt b/tests/baselines/reference/tsxElementResolution.errors.txt new file mode 100644 index 00000000000..4e5cb93b007 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution.errors.txt @@ -0,0 +1,40 @@ +tests/cases/conformance/jsx/tsxElementResolution.tsx(18,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxElementResolution.tsx(19,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxElementResolution.tsx(23,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxElementResolution.tsx(24,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. + + +==== tests/cases/conformance/jsx/tsxElementResolution.tsx (4 errors) ==== + + declare namespace JSX { + interface IntrinsicElements { + foundFirst: { x: string }; + 'string_named'; + 'var'; + } + } + + class foundFirst { } + class Other {} + + module Dotted { + export class Name { } + } + + // Should find the intrinsic element, not the class element + var a = ; + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + var b = ; + ~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + // TODO: This should not be a parse error (should + // parse a property name here, not identifier) + // var c = ; + var d = ; + ~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + var e = ; + ~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution.js b/tests/baselines/reference/tsxElementResolution.js new file mode 100644 index 00000000000..e7a4ae95e94 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution.js @@ -0,0 +1,55 @@ +//// [tsxElementResolution.tsx] + +declare namespace JSX { + interface IntrinsicElements { + foundFirst: { x: string }; + 'string_named'; + 'var'; + } +} + +class foundFirst { } +class Other {} + +module Dotted { + export class Name { } +} + +// Should find the intrinsic element, not the class element +var a = ; +var b = ; +// TODO: This should not be a parse error (should +// parse a property name here, not identifier) +// var c = ; +var d = ; +var e = ; + + +//// [tsxElementResolution.jsx] +var foundFirst = (function () { + function foundFirst() { + } + return foundFirst; +})(); +var Other = (function () { + function Other() { + } + return Other; +})(); +var Dotted; +(function (Dotted) { + var Name = (function () { + function Name() { + } + return Name; + })(); + Dotted.Name = Name; +})(Dotted || (Dotted = {})); +// Should find the intrinsic element, not the class element +var a = ; +var b = ; +// TODO: This should not be a parse error (should +// parse a property name here, not identifier) +// var c = ; +var d = ; +var e = ; diff --git a/tests/baselines/reference/tsxElementResolution1.errors.txt b/tests/baselines/reference/tsxElementResolution1.errors.txt new file mode 100644 index 00000000000..b54430bd106 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution1.errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/jsx/tsxElementResolution1.tsx(12,1): error TS2339: Property 'span' does not exist on type 'JSX.IntrinsicElements'. + + +==== tests/cases/conformance/jsx/tsxElementResolution1.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + div: any + } + } + + // OK +
; + + // Fail + ; + ~~~~~~~~ +!!! error TS2339: Property 'span' does not exist on type 'JSX.IntrinsicElements'. \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution1.js b/tests/baselines/reference/tsxElementResolution1.js new file mode 100644 index 00000000000..c7e0536bde2 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution1.js @@ -0,0 +1,19 @@ +//// [tsxElementResolution1.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + div: any + } +} + +// OK +
; + +// Fail +; + +//// [tsxElementResolution1.jsx] +// OK +
; +// Fail +; diff --git a/tests/baselines/reference/tsxElementResolution10.errors.txt b/tests/baselines/reference/tsxElementResolution10.errors.txt new file mode 100644 index 00000000000..987851191c5 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution10.errors.txt @@ -0,0 +1,28 @@ +tests/cases/conformance/jsx/tsxElementResolution10.tsx(13,1): error TS2605: JSX element '{ x: number; }' is not a constructor function for JSX elements. + Property 'render' is missing in type '{ x: number; }'. + + +==== tests/cases/conformance/jsx/tsxElementResolution10.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface ElementClass { + render: any; + } + interface IntrinsicElements { } + } + + interface Obj1type { + new(n: string): { x: number }; + } + var Obj1: Obj1type; + ; // Error, no render member + ~~~~~~~~~~~~~~~ +!!! error TS2605: JSX element '{ x: number; }' is not a constructor function for JSX elements. +!!! error TS2605: Property 'render' is missing in type '{ x: number; }'. + + interface Obj2type { + (n: string): { x: number; render: any; }; + } + var Obj2: Obj2type; + ; // OK + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution10.js b/tests/baselines/reference/tsxElementResolution10.js new file mode 100644 index 00000000000..84c8619ab96 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution10.js @@ -0,0 +1,27 @@ +//// [tsxElementResolution10.tsx] +declare module JSX { + interface Element { } + interface ElementClass { + render: any; + } + interface IntrinsicElements { } +} + +interface Obj1type { + new(n: string): { x: number }; +} +var Obj1: Obj1type; +; // Error, no render member + +interface Obj2type { + (n: string): { x: number; render: any; }; +} +var Obj2: Obj2type; +; // OK + + +//// [tsxElementResolution10.jsx] +var Obj1; +; // Error, no render member +var Obj2; +; // OK diff --git a/tests/baselines/reference/tsxElementResolution11.errors.txt b/tests/baselines/reference/tsxElementResolution11.errors.txt new file mode 100644 index 00000000000..4f3ee00d82f --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution11.errors.txt @@ -0,0 +1,30 @@ +tests/cases/conformance/jsx/tsxElementResolution11.tsx(17,7): error TS2339: Property 'x' does not exist on type '{ q?: number; }'. + + +==== tests/cases/conformance/jsx/tsxElementResolution11.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface ElementAttributesProperty { } + interface IntrinsicElements { } + } + + interface Obj1type { + new(n: string): any; + } + var Obj1: Obj1type; + ; // OK + + interface Obj2type { + new(n: string): { q?: number }; + } + var Obj2: Obj2type; + ; // Error + ~ +!!! error TS2339: Property 'x' does not exist on type '{ q?: number; }'. + + interface Obj3type { + new(n: string): { x: number; }; + } + var Obj3: Obj3type; + ; // OK + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution11.js b/tests/baselines/reference/tsxElementResolution11.js new file mode 100644 index 00000000000..fb8572116b1 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution11.js @@ -0,0 +1,33 @@ +//// [tsxElementResolution11.tsx] +declare module JSX { + interface Element { } + interface ElementAttributesProperty { } + interface IntrinsicElements { } +} + +interface Obj1type { + new(n: string): any; +} +var Obj1: Obj1type; +; // OK + +interface Obj2type { + new(n: string): { q?: number }; +} +var Obj2: Obj2type; +; // Error + +interface Obj3type { + new(n: string): { x: number; }; +} +var Obj3: Obj3type; +; // OK + + +//// [tsxElementResolution11.jsx] +var Obj1; +; // OK +var Obj2; +; // Error +var Obj3; +; // OK diff --git a/tests/baselines/reference/tsxElementResolution12.errors.txt b/tests/baselines/reference/tsxElementResolution12.errors.txt new file mode 100644 index 00000000000..71a22b502aa --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution12.errors.txt @@ -0,0 +1,43 @@ +tests/cases/conformance/jsx/tsxElementResolution12.tsx(17,2): error TS2304: Cannot find name 'Obj2'. +tests/cases/conformance/jsx/tsxElementResolution12.tsx(23,1): error TS2607: JSX element class does not support attributes because it does not have a 'pr' property +tests/cases/conformance/jsx/tsxElementResolution12.tsx(30,7): error TS2322: Type 'string' is not assignable to type 'number'. + + +==== tests/cases/conformance/jsx/tsxElementResolution12.tsx (3 errors) ==== + declare module JSX { + interface Element { } + interface ElementAttributesProperty { pr: any; } + interface IntrinsicElements { } + } + + interface Obj1type { + new(n: string): any; + } + var Obj1: Obj1type; + ; // OK + + interface Obj2type { + new(n: string): { q?: number; pr: any }; + } + var obj2: Obj2type; + ; // OK + ~~~~ +!!! error TS2304: Cannot find name 'Obj2'. + + interface Obj3type { + new(n: string): { x: number; }; + } + var Obj3: Obj3type; + ; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2607: JSX element class does not support attributes because it does not have a 'pr' property + + interface Obj4type { + new(n: string): { x: number; pr: { x: number; } }; + } + var Obj4: Obj4type; + ; // OK + ; // Error + ~~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution12.js b/tests/baselines/reference/tsxElementResolution12.js new file mode 100644 index 00000000000..12973efdda7 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution12.js @@ -0,0 +1,43 @@ +//// [tsxElementResolution12.tsx] +declare module JSX { + interface Element { } + interface ElementAttributesProperty { pr: any; } + interface IntrinsicElements { } +} + +interface Obj1type { + new(n: string): any; +} +var Obj1: Obj1type; +; // OK + +interface Obj2type { + new(n: string): { q?: number; pr: any }; +} +var obj2: Obj2type; +; // OK + +interface Obj3type { + new(n: string): { x: number; }; +} +var Obj3: Obj3type; +; // Error + +interface Obj4type { + new(n: string): { x: number; pr: { x: number; } }; +} +var Obj4: Obj4type; +; // OK +; // Error + + +//// [tsxElementResolution12.jsx] +var Obj1; +; // OK +var obj2; +; // OK +var Obj3; +; // Error +var Obj4; +; // OK +; // Error diff --git a/tests/baselines/reference/tsxElementResolution13.js b/tests/baselines/reference/tsxElementResolution13.js new file mode 100644 index 00000000000..f8631bdec0c --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution13.js @@ -0,0 +1,16 @@ +//// [tsxElementResolution13.tsx] +declare module JSX { + interface Element { } + interface ElementAttributesProperty { pr1: any; pr2: any; } +} + +interface Obj1 { + new(n: string): any; +} +var obj1: Obj1; +; // Error + + +//// [tsxElementResolution13.jsx] +var obj1; +; // Error diff --git a/tests/baselines/reference/tsxElementResolution13.symbols b/tests/baselines/reference/tsxElementResolution13.symbols new file mode 100644 index 00000000000..4022602e53a --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution13.symbols @@ -0,0 +1,26 @@ +=== tests/cases/conformance/jsx/tsxElementResolution13.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxElementResolution13.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxElementResolution13.tsx, 0, 20)) + + interface ElementAttributesProperty { pr1: any; pr2: any; } +>ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(tsxElementResolution13.tsx, 1, 22)) +>pr1 : Symbol(pr1, Decl(tsxElementResolution13.tsx, 2, 38)) +>pr2 : Symbol(pr2, Decl(tsxElementResolution13.tsx, 2, 48)) +} + +interface Obj1 { +>Obj1 : Symbol(Obj1, Decl(tsxElementResolution13.tsx, 3, 1)) + + new(n: string): any; +>n : Symbol(n, Decl(tsxElementResolution13.tsx, 6, 5)) +} +var obj1: Obj1; +>obj1 : Symbol(obj1, Decl(tsxElementResolution13.tsx, 8, 3)) +>Obj1 : Symbol(Obj1, Decl(tsxElementResolution13.tsx, 3, 1)) + +; // Error +>x : Symbol(unknown) + diff --git a/tests/baselines/reference/tsxElementResolution13.types b/tests/baselines/reference/tsxElementResolution13.types new file mode 100644 index 00000000000..cd6265de091 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution13.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/jsx/tsxElementResolution13.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface ElementAttributesProperty { pr1: any; pr2: any; } +>ElementAttributesProperty : ElementAttributesProperty +>pr1 : any +>pr2 : any +} + +interface Obj1 { +>Obj1 : Obj1 + + new(n: string): any; +>n : string +} +var obj1: Obj1; +>obj1 : Obj1 +>Obj1 : Obj1 + +; // Error +> : JSX.Element +>obj1 : Obj1 +>x : any + diff --git a/tests/baselines/reference/tsxElementResolution14.js b/tests/baselines/reference/tsxElementResolution14.js new file mode 100644 index 00000000000..e1e440db5f3 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution14.js @@ -0,0 +1,15 @@ +//// [tsxElementResolution14.tsx] +declare module JSX { + interface Element { } +} + +interface Obj1 { + new(n: string): {}; +} +var obj1: Obj1; +; // OK + + +//// [tsxElementResolution14.jsx] +var obj1; +; // OK diff --git a/tests/baselines/reference/tsxElementResolution14.symbols b/tests/baselines/reference/tsxElementResolution14.symbols new file mode 100644 index 00000000000..58236a4e462 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution14.symbols @@ -0,0 +1,21 @@ +=== tests/cases/conformance/jsx/tsxElementResolution14.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxElementResolution14.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxElementResolution14.tsx, 0, 20)) +} + +interface Obj1 { +>Obj1 : Symbol(Obj1, Decl(tsxElementResolution14.tsx, 2, 1)) + + new(n: string): {}; +>n : Symbol(n, Decl(tsxElementResolution14.tsx, 5, 5)) +} +var obj1: Obj1; +>obj1 : Symbol(obj1, Decl(tsxElementResolution14.tsx, 7, 3)) +>Obj1 : Symbol(Obj1, Decl(tsxElementResolution14.tsx, 2, 1)) + +; // OK +>x : Symbol(unknown) + diff --git a/tests/baselines/reference/tsxElementResolution14.types b/tests/baselines/reference/tsxElementResolution14.types new file mode 100644 index 00000000000..ef03187d28e --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution14.types @@ -0,0 +1,23 @@ +=== tests/cases/conformance/jsx/tsxElementResolution14.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element +} + +interface Obj1 { +>Obj1 : Obj1 + + new(n: string): {}; +>n : string +} +var obj1: Obj1; +>obj1 : Obj1 +>Obj1 : Obj1 + +; // OK +> : JSX.Element +>obj1 : Obj1 +>x : any + diff --git a/tests/baselines/reference/tsxElementResolution15.errors.txt b/tests/baselines/reference/tsxElementResolution15.errors.txt new file mode 100644 index 00000000000..24480ab7f2b --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution15.errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/jsx/tsxElementResolution15.tsx(3,12): error TS2608: The global type 'JSX.ElementAttributesProperty' may not have more than one property + + +==== tests/cases/conformance/jsx/tsxElementResolution15.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface ElementAttributesProperty { pr1: any; pr2: any; } + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2608: The global type 'JSX.ElementAttributesProperty' may not have more than one property + interface IntrinsicElements { } + } + + interface Obj1type { + new(n: string): {}; + } + var Obj1: Obj1type; + ; // Error + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution15.js b/tests/baselines/reference/tsxElementResolution15.js new file mode 100644 index 00000000000..831b3a54b41 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution15.js @@ -0,0 +1,17 @@ +//// [tsxElementResolution15.tsx] +declare module JSX { + interface Element { } + interface ElementAttributesProperty { pr1: any; pr2: any; } + interface IntrinsicElements { } +} + +interface Obj1type { + new(n: string): {}; +} +var Obj1: Obj1type; +; // Error + + +//// [tsxElementResolution15.jsx] +var Obj1; +; // Error diff --git a/tests/baselines/reference/tsxElementResolution16.errors.txt b/tests/baselines/reference/tsxElementResolution16.errors.txt new file mode 100644 index 00000000000..3bdc9286c56 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution16.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/jsx/tsxElementResolution16.tsx(8,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. + + +==== tests/cases/conformance/jsx/tsxElementResolution16.tsx (1 errors) ==== + declare module JSX { + } + + interface Obj1 { + new(n: string): {}; + } + var obj1: Obj1; + ; // Error (JSX.Element is missing) + ~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution16.js b/tests/baselines/reference/tsxElementResolution16.js new file mode 100644 index 00000000000..c63c3b7f83a --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution16.js @@ -0,0 +1,14 @@ +//// [tsxElementResolution16.tsx] +declare module JSX { +} + +interface Obj1 { + new(n: string): {}; +} +var obj1: Obj1; +; // Error (JSX.Element is missing) + + +//// [tsxElementResolution16.jsx] +var obj1; +; // Error (JSX.Element is missing) diff --git a/tests/baselines/reference/tsxElementResolution17.js b/tests/baselines/reference/tsxElementResolution17.js new file mode 100644 index 00000000000..cd8d7e13beb --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution17.js @@ -0,0 +1,34 @@ +//// [tests/cases/conformance/jsx/tsxElementResolution17.tsx] //// + +//// [file.tsx] + +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +declare module 'elements1' { + class MyElement { + + } +} + +declare module 'elements2' { + class MyElement { + + } +} + +//// [consumer.tsx] +/// +// Should keep s1 and elide s2 +import s1 = require('elements1'); +import s2 = require('elements2'); +; + + +//// [file.jsx] +//// [consumer.jsx] +define(["require", "exports", 'elements1'], function (require, exports, s1) { + ; +}); diff --git a/tests/baselines/reference/tsxElementResolution17.symbols b/tests/baselines/reference/tsxElementResolution17.symbols new file mode 100644 index 00000000000..0b4459552de --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution17.symbols @@ -0,0 +1,38 @@ +=== tests/cases/conformance/jsx/consumer.tsx === +/// +// Should keep s1 and elide s2 +import s1 = require('elements1'); +>s1 : Symbol(s1, Decl(consumer.tsx, 0, 0)) + +import s2 = require('elements2'); +>s2 : Symbol(s2, Decl(consumer.tsx, 2, 33)) + +; +>MyElement : Symbol(s1.MyElement, Decl(file.tsx, 6, 28)) + +=== tests/cases/conformance/jsx/file.tsx === + +declare module JSX { +>JSX : Symbol(JSX, Decl(file.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(file.tsx, 1, 20)) + + interface IntrinsicElements { } +>IntrinsicElements : Symbol(IntrinsicElements, Decl(file.tsx, 2, 22)) +} + +declare module 'elements1' { + class MyElement { +>MyElement : Symbol(MyElement, Decl(file.tsx, 6, 28)) + + } +} + +declare module 'elements2' { + class MyElement { +>MyElement : Symbol(MyElement, Decl(file.tsx, 12, 28)) + + } +} + diff --git a/tests/baselines/reference/tsxElementResolution17.types b/tests/baselines/reference/tsxElementResolution17.types new file mode 100644 index 00000000000..e6396a9a60b --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution17.types @@ -0,0 +1,40 @@ +=== tests/cases/conformance/jsx/consumer.tsx === +/// +// Should keep s1 and elide s2 +import s1 = require('elements1'); +>s1 : typeof s1 + +import s2 = require('elements2'); +>s2 : typeof s2 + +; +> : JSX.Element +>s1 : any +>MyElement : any + +=== tests/cases/conformance/jsx/file.tsx === + +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { } +>IntrinsicElements : IntrinsicElements +} + +declare module 'elements1' { + class MyElement { +>MyElement : MyElement + + } +} + +declare module 'elements2' { + class MyElement { +>MyElement : MyElement + + } +} + diff --git a/tests/baselines/reference/tsxElementResolution18.errors.txt b/tests/baselines/reference/tsxElementResolution18.errors.txt new file mode 100644 index 00000000000..75d28616bf0 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution18.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/jsx/tsxElementResolution18.tsx(6,1): error TS2609: JSX element implicitly has type 'any' because no interface JSX.IntrinsicElements exists + + +==== tests/cases/conformance/jsx/tsxElementResolution18.tsx (1 errors) ==== + declare module JSX { + interface Element { } + } + + // Error under implicit any +
; + ~~~~~~~~~~~~~ +!!! error TS2609: JSX element implicitly has type 'any' because no interface JSX.IntrinsicElements exists + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution18.js b/tests/baselines/reference/tsxElementResolution18.js new file mode 100644 index 00000000000..0b5138b7b49 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution18.js @@ -0,0 +1,12 @@ +//// [tsxElementResolution18.tsx] +declare module JSX { + interface Element { } +} + +// Error under implicit any +
; + + +//// [tsxElementResolution18.jsx] +// Error under implicit any +
; diff --git a/tests/baselines/reference/tsxElementResolution2.js b/tests/baselines/reference/tsxElementResolution2.js new file mode 100644 index 00000000000..1d06656d529 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution2.js @@ -0,0 +1,19 @@ +//// [tsxElementResolution2.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + [x: string]: any; + } +} + +// OK +
; + +// OK +; + +//// [tsxElementResolution2.jsx] +// OK +
; +// OK +; diff --git a/tests/baselines/reference/tsxElementResolution2.symbols b/tests/baselines/reference/tsxElementResolution2.symbols new file mode 100644 index 00000000000..2935bcd4f63 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution2.symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/jsx/tsxElementResolution2.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxElementResolution2.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxElementResolution2.tsx, 0, 20)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxElementResolution2.tsx, 1, 22)) + + [x: string]: any; +>x : Symbol(x, Decl(tsxElementResolution2.tsx, 3, 6)) + } +} + +// OK +
; +>div : Symbol(JSX.IntrinsicElements, Decl(tsxElementResolution2.tsx, 1, 22)) + +// OK +; +>span : Symbol(JSX.IntrinsicElements, Decl(tsxElementResolution2.tsx, 1, 22)) + diff --git a/tests/baselines/reference/tsxElementResolution2.types b/tests/baselines/reference/tsxElementResolution2.types new file mode 100644 index 00000000000..56ea5158253 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution2.types @@ -0,0 +1,25 @@ +=== tests/cases/conformance/jsx/tsxElementResolution2.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + [x: string]: any; +>x : string + } +} + +// OK +
; +>
: JSX.Element +>div : any + +// OK +; +> : JSX.Element +>span : any + diff --git a/tests/baselines/reference/tsxElementResolution3.errors.txt b/tests/baselines/reference/tsxElementResolution3.errors.txt new file mode 100644 index 00000000000..bc3c7c5ebfc --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution3.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/jsx/tsxElementResolution3.tsx(12,1): error TS2324: Property 'n' is missing in type '{ n: string; }'. +tests/cases/conformance/jsx/tsxElementResolution3.tsx(12,7): error TS2339: Property 'w' does not exist on type '{ n: string; }'. + + +==== tests/cases/conformance/jsx/tsxElementResolution3.tsx (2 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + [x: string]: { n: string; }; + } + } + + // OK +
; + + // Error + ; + ~~~~~~~~~~~~~~~~ +!!! error TS2324: Property 'n' is missing in type '{ n: string; }'. + ~ +!!! error TS2339: Property 'w' does not exist on type '{ n: string; }'. \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution3.js b/tests/baselines/reference/tsxElementResolution3.js new file mode 100644 index 00000000000..607d1c5ec66 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution3.js @@ -0,0 +1,19 @@ +//// [tsxElementResolution3.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + [x: string]: { n: string; }; + } +} + +// OK +
; + +// Error +; + +//// [tsxElementResolution3.jsx] +// OK +
; +// Error +; diff --git a/tests/baselines/reference/tsxElementResolution4.errors.txt b/tests/baselines/reference/tsxElementResolution4.errors.txt new file mode 100644 index 00000000000..0e383af5e7b --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution4.errors.txt @@ -0,0 +1,26 @@ +tests/cases/conformance/jsx/tsxElementResolution4.tsx(16,1): error TS2324: Property 'm' is missing in type '{ m: string; }'. +tests/cases/conformance/jsx/tsxElementResolution4.tsx(16,7): error TS2339: Property 'q' does not exist on type '{ m: string; }'. + + +==== tests/cases/conformance/jsx/tsxElementResolution4.tsx (2 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + div: { n: string; }; + span: { m: string; }; + } + } + + // OK +
; + + // OK + ; + + // Error + ; + ~~~~~~~~~~~~~ +!!! error TS2324: Property 'm' is missing in type '{ m: string; }'. + ~ +!!! error TS2339: Property 'q' does not exist on type '{ m: string; }'. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution4.js b/tests/baselines/reference/tsxElementResolution4.js new file mode 100644 index 00000000000..ea395cb5077 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution4.js @@ -0,0 +1,26 @@ +//// [tsxElementResolution4.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + div: { n: string; }; + span: { m: string; }; + } +} + +// OK +
; + +// OK +; + +// Error +; + + +//// [tsxElementResolution4.jsx] +// OK +
; +// OK +; +// Error +; diff --git a/tests/baselines/reference/tsxElementResolution5.js b/tests/baselines/reference/tsxElementResolution5.js new file mode 100644 index 00000000000..8aadfec0f78 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution5.js @@ -0,0 +1,12 @@ +//// [tsxElementResolution5.tsx] +declare module JSX { + interface Element { } +} + +// OK, but implicit any +
; + + +//// [tsxElementResolution5.jsx] +// OK, but implicit any +
; diff --git a/tests/baselines/reference/tsxElementResolution5.symbols b/tests/baselines/reference/tsxElementResolution5.symbols new file mode 100644 index 00000000000..8bbbfaaeb68 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution5.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/jsx/tsxElementResolution5.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxElementResolution5.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxElementResolution5.tsx, 0, 20)) +} + +// OK, but implicit any +
; +>n : Symbol(unknown) + diff --git a/tests/baselines/reference/tsxElementResolution5.types b/tests/baselines/reference/tsxElementResolution5.types new file mode 100644 index 00000000000..ba3509f4fa1 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution5.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/jsx/tsxElementResolution5.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element +} + +// OK, but implicit any +
; +>
: JSX.Element +>div : any +>n : any + diff --git a/tests/baselines/reference/tsxElementResolution6.errors.txt b/tests/baselines/reference/tsxElementResolution6.errors.txt new file mode 100644 index 00000000000..1336cc6df0c --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution6.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/jsx/tsxElementResolution6.tsx(8,1): error TS2339: Property 'div' does not exist on type 'JSX.IntrinsicElements'. + + +==== tests/cases/conformance/jsx/tsxElementResolution6.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { } + } + + var div: any; + // Still an error +
; + ~~~~~~~~~~~~~ +!!! error TS2339: Property 'div' does not exist on type 'JSX.IntrinsicElements'. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution6.js b/tests/baselines/reference/tsxElementResolution6.js new file mode 100644 index 00000000000..1b6d174fea8 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution6.js @@ -0,0 +1,15 @@ +//// [tsxElementResolution6.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +var div: any; +// Still an error +
; + + +//// [tsxElementResolution6.jsx] +var div; +// Still an error +
; diff --git a/tests/baselines/reference/tsxElementResolution7.errors.txt b/tests/baselines/reference/tsxElementResolution7.errors.txt new file mode 100644 index 00000000000..b8549e19535 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution7.errors.txt @@ -0,0 +1,30 @@ +tests/cases/conformance/jsx/tsxElementResolution7.tsx(12,5): error TS2339: Property 'other' does not exist on type 'typeof my'. +tests/cases/conformance/jsx/tsxElementResolution7.tsx(19,11): error TS2339: Property 'non' does not exist on type 'typeof my'. + + +==== tests/cases/conformance/jsx/tsxElementResolution7.tsx (2 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { } + } + + module my { + export var div: any; + } + // OK + ; + // Error + ; + ~~~~~ +!!! error TS2339: Property 'other' does not exist on type 'typeof my'. + + module q { + import mine = my; + // OK + ; + // Error + ; + ~~~ +!!! error TS2339: Property 'non' does not exist on type 'typeof my'. + } + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution7.js b/tests/baselines/reference/tsxElementResolution7.js new file mode 100644 index 00000000000..7df44b052a2 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution7.js @@ -0,0 +1,39 @@ +//// [tsxElementResolution7.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +module my { + export var div: any; +} +// OK +; +// Error +; + +module q { + import mine = my; + // OK + ; + // Error + ; +} + + +//// [tsxElementResolution7.jsx] +var my; +(function (my) { +})(my || (my = {})); +// OK +; +// Error +; +var q; +(function (q) { + var mine = my; + // OK + ; + // Error + ; +})(q || (q = {})); diff --git a/tests/baselines/reference/tsxElementResolution8.errors.txt b/tests/baselines/reference/tsxElementResolution8.errors.txt new file mode 100644 index 00000000000..644b43b471b --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution8.errors.txt @@ -0,0 +1,50 @@ +tests/cases/conformance/jsx/tsxElementResolution8.tsx(8,2): error TS2604: JSX element 'Div' is not a constructor function. +tests/cases/conformance/jsx/tsxElementResolution8.tsx(16,2): error TS2601: The return type of a JSX element constructor must return an object type. +tests/cases/conformance/jsx/tsxElementResolution8.tsx(29,2): error TS2601: The return type of a JSX element constructor must return an object type. +tests/cases/conformance/jsx/tsxElementResolution8.tsx(34,2): error TS2604: JSX element 'Obj3' is not a constructor function. + + +==== tests/cases/conformance/jsx/tsxElementResolution8.tsx (4 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { } + } + + // Error + var Div = 3; +
; + ~~~ +!!! error TS2604: JSX element 'Div' is not a constructor function. + + // OK + function Fact(): any { return null; } + + + // Error + function Fnum(): number{ return 42; } + + ~~~~ +!!! error TS2601: The return type of a JSX element constructor must return an object type. + + interface Obj1 { + new(): {}; + (): number; + } + var Obj1: Obj1; + ; // OK, prefer construct signatures + + interface Obj2 { + (): number; + } + var Obj2: Obj2; + ; // Error + ~~~~ +!!! error TS2601: The return type of a JSX element constructor must return an object type. + + interface Obj3 { + } + var Obj3: Obj3; + ; // Error + ~~~~ +!!! error TS2604: JSX element 'Obj3' is not a constructor function. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution8.js b/tests/baselines/reference/tsxElementResolution8.js new file mode 100644 index 00000000000..4217761c402 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution8.js @@ -0,0 +1,53 @@ +//// [tsxElementResolution8.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +// Error +var Div = 3; +
; + +// OK +function Fact(): any { return null; } + + +// Error +function Fnum(): number{ return 42; } + + +interface Obj1 { + new(): {}; + (): number; +} +var Obj1: Obj1; +; // OK, prefer construct signatures + +interface Obj2 { + (): number; +} +var Obj2: Obj2; +; // Error + +interface Obj3 { +} +var Obj3: Obj3; +; // Error + + +//// [tsxElementResolution8.jsx] +// Error +var Div = 3; +
; +// OK +function Fact() { return null; } +; +// Error +function Fnum() { return 42; } +; +var Obj1; +; // OK, prefer construct signatures +var Obj2; +; // Error +var Obj3; +; // Error diff --git a/tests/baselines/reference/tsxElementResolution9.errors.txt b/tests/baselines/reference/tsxElementResolution9.errors.txt new file mode 100644 index 00000000000..f4412719b33 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution9.errors.txt @@ -0,0 +1,35 @@ +tests/cases/conformance/jsx/tsxElementResolution9.tsx(11,2): error TS2601: The return type of a JSX element constructor must return an object type. +tests/cases/conformance/jsx/tsxElementResolution9.tsx(18,2): error TS2601: The return type of a JSX element constructor must return an object type. + + +==== tests/cases/conformance/jsx/tsxElementResolution9.tsx (2 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { } + } + + interface Obj1 { + new(n: string): { x: number }; + new(n: number): { y: string }; + } + var Obj1: Obj1; + ; // Error, return type is not an object type + ~~~~ +!!! error TS2601: The return type of a JSX element constructor must return an object type. + + interface Obj2 { + (n: string): { x: number }; + (n: number): { y: string }; + } + var Obj2: Obj2; + ; // Error, return type is not an object type + ~~~~ +!!! error TS2601: The return type of a JSX element constructor must return an object type. + + interface Obj3 { + (n: string): { x: number }; + (n: number): { x: number; y: string }; + } + var Obj3: Obj3; + ; // OK + \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution9.js b/tests/baselines/reference/tsxElementResolution9.js new file mode 100644 index 00000000000..c897a51eaeb --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution9.js @@ -0,0 +1,35 @@ +//// [tsxElementResolution9.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +interface Obj1 { + new(n: string): { x: number }; + new(n: number): { y: string }; +} +var Obj1: Obj1; +; // Error, return type is not an object type + +interface Obj2 { + (n: string): { x: number }; + (n: number): { y: string }; +} +var Obj2: Obj2; +; // Error, return type is not an object type + +interface Obj3 { + (n: string): { x: number }; + (n: number): { x: number; y: string }; +} +var Obj3: Obj3; +; // OK + + +//// [tsxElementResolution9.jsx] +var Obj1; +; // Error, return type is not an object type +var Obj2; +; // Error, return type is not an object type +var Obj3; +; // OK diff --git a/tests/baselines/reference/tsxEmit1.js b/tests/baselines/reference/tsxEmit1.js new file mode 100644 index 00000000000..baa75526dd7 --- /dev/null +++ b/tests/baselines/reference/tsxEmit1.js @@ -0,0 +1,75 @@ +//// [tsxEmit1.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p; +var selfClosed1 =
; +var selfClosed2 =
; +var selfClosed3 =
; +var selfClosed4 =
; +var selfClosed5 =
; +var selfClosed6 =
; +var selfClosed7 =
; + +var openClosed1 =
; +var openClosed2 =
foo
; +var openClosed3 =
{p}
; +var openClosed4 =
{p < p}
; +var openClosed5 =
{p > p}
; + +class SomeClass { + f() { + var rewrites1 =
{() => this}
; + var rewrites2 =
{[p, ...p, p]}
; + var rewrites3 =
{{p}}
; + + var rewrites4 =
this}>
; + var rewrites5 =
; + var rewrites6 =
; + } +} + +var whitespace1 =
; +var whitespace2 =
{p}
; +var whitespace3 =
+ {p} +
; + + +//// [tsxEmit1.jsx] +var p; +var selfClosed1 =
; +var selfClosed2 =
; +var selfClosed3 =
; +var selfClosed4 =
; +var selfClosed5 =
; +var selfClosed6 =
; +var selfClosed7 =
; +var openClosed1 =
; +var openClosed2 =
foo
; +var openClosed3 =
{p}
; +var openClosed4 =
{p < p}
; +var openClosed5 =
{p > p}
; +var SomeClass = (function () { + function SomeClass() { + } + SomeClass.prototype.f = function () { + var _this = this; + var rewrites1 =
{function () { return _this; }}
; + var rewrites2 =
{[p].concat(p, [p])}
; + var rewrites3 =
{{ p: p }}
; + var rewrites4 =
; + var rewrites5 =
; + var rewrites6 =
; + }; + return SomeClass; +})(); +var whitespace1 =
; +var whitespace2 =
{p}
; +var whitespace3 =
+ {p} +
; diff --git a/tests/baselines/reference/tsxEmit1.symbols b/tests/baselines/reference/tsxEmit1.symbols new file mode 100644 index 00000000000..284f6cd9ce7 --- /dev/null +++ b/tests/baselines/reference/tsxEmit1.symbols @@ -0,0 +1,144 @@ +=== tests/cases/conformance/jsx/tsxEmit1.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxEmit1.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxEmit1.tsx, 0, 20)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) + + [s: string]: any; +>s : Symbol(s, Decl(tsxEmit1.tsx, 3, 3)) + } +} + +var p; +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) + +var selfClosed1 =
; +>selfClosed1 : Symbol(selfClosed1, Decl(tsxEmit1.tsx, 8, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) + +var selfClosed2 =
; +>selfClosed2 : Symbol(selfClosed2, Decl(tsxEmit1.tsx, 9, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>x : Symbol(unknown) + +var selfClosed3 =
; +>selfClosed3 : Symbol(selfClosed3, Decl(tsxEmit1.tsx, 10, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>x : Symbol(unknown) + +var selfClosed4 =
; +>selfClosed4 : Symbol(selfClosed4, Decl(tsxEmit1.tsx, 11, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + +var selfClosed5 =
; +>selfClosed5 : Symbol(selfClosed5, Decl(tsxEmit1.tsx, 12, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + +var selfClosed6 =
; +>selfClosed6 : Symbol(selfClosed6, Decl(tsxEmit1.tsx, 13, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + +var selfClosed7 =
; +>selfClosed7 : Symbol(selfClosed7, Decl(tsxEmit1.tsx, 14, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + +var openClosed1 =
; +>openClosed1 : Symbol(openClosed1, Decl(tsxEmit1.tsx, 16, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) + +var openClosed2 =
foo
; +>openClosed2 : Symbol(openClosed2, Decl(tsxEmit1.tsx, 17, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>n : Symbol(unknown) + +var openClosed3 =
{p}
; +>openClosed3 : Symbol(openClosed3, Decl(tsxEmit1.tsx, 18, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>n : Symbol(unknown) + +var openClosed4 =
{p < p}
; +>openClosed4 : Symbol(openClosed4, Decl(tsxEmit1.tsx, 19, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>n : Symbol(unknown) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) + +var openClosed5 =
{p > p}
; +>openClosed5 : Symbol(openClosed5, Decl(tsxEmit1.tsx, 20, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>n : Symbol(unknown) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) + +class SomeClass { +>SomeClass : Symbol(SomeClass, Decl(tsxEmit1.tsx, 20, 43)) + + f() { +>f : Symbol(f, Decl(tsxEmit1.tsx, 22, 17)) + + var rewrites1 =
{() => this}
; +>rewrites1 : Symbol(rewrites1, Decl(tsxEmit1.tsx, 24, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>this : Symbol(SomeClass, Decl(tsxEmit1.tsx, 20, 43)) + + var rewrites2 =
{[p, ...p, p]}
; +>rewrites2 : Symbol(rewrites2, Decl(tsxEmit1.tsx, 25, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) + + var rewrites3 =
{{p}}
; +>rewrites3 : Symbol(rewrites3, Decl(tsxEmit1.tsx, 26, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>p : Symbol(p, Decl(tsxEmit1.tsx, 26, 25)) + + var rewrites4 =
this}>
; +>rewrites4 : Symbol(rewrites4, Decl(tsxEmit1.tsx, 28, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>a : Symbol(unknown) +>this : Symbol(SomeClass, Decl(tsxEmit1.tsx, 20, 43)) + + var rewrites5 =
; +>rewrites5 : Symbol(rewrites5, Decl(tsxEmit1.tsx, 29, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>a : Symbol(unknown) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxEmit1.tsx, 7, 3)) + + var rewrites6 =
; +>rewrites6 : Symbol(rewrites6, Decl(tsxEmit1.tsx, 30, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) +>a : Symbol(unknown) +>p : Symbol(p, Decl(tsxEmit1.tsx, 30, 27)) + } +} + +var whitespace1 =
; +>whitespace1 : Symbol(whitespace1, Decl(tsxEmit1.tsx, 34, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) + +var whitespace2 =
{p}
; +>whitespace2 : Symbol(whitespace2, Decl(tsxEmit1.tsx, 35, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) + +var whitespace3 =
+>whitespace3 : Symbol(whitespace3, Decl(tsxEmit1.tsx, 36, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit1.tsx, 1, 22)) + + {p} +
; + diff --git a/tests/baselines/reference/tsxEmit1.types b/tests/baselines/reference/tsxEmit1.types new file mode 100644 index 00000000000..667ec113337 --- /dev/null +++ b/tests/baselines/reference/tsxEmit1.types @@ -0,0 +1,194 @@ +=== tests/cases/conformance/jsx/tsxEmit1.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + [s: string]: any; +>s : string + } +} + +var p; +>p : any + +var selfClosed1 =
; +>selfClosed1 : JSX.Element +>
: JSX.Element +>div : any + +var selfClosed2 =
; +>selfClosed2 : JSX.Element +>
: JSX.Element +>div : any +>x : any + +var selfClosed3 =
; +>selfClosed3 : JSX.Element +>
: JSX.Element +>div : any +>x : any + +var selfClosed4 =
; +>selfClosed4 : JSX.Element +>
: JSX.Element +>div : any +>x : any +>y : any + +var selfClosed5 =
; +>selfClosed5 : JSX.Element +>
: JSX.Element +>div : any +>x : any +>y : any + +var selfClosed6 =
; +>selfClosed6 : JSX.Element +>
: JSX.Element +>div : any +>x : any +>y : any + +var selfClosed7 =
; +>selfClosed7 : JSX.Element +>
: JSX.Element +>div : any +>x : any +>p : any +>y : any + +var openClosed1 =
; +>openClosed1 : JSX.Element +>
: JSX.Element +>div : any +>div : any + +var openClosed2 =
foo
; +>openClosed2 : JSX.Element +>
foo
: JSX.Element +>div : any +>n : any +>div : any + +var openClosed3 =
{p}
; +>openClosed3 : JSX.Element +>
{p}
: JSX.Element +>div : any +>n : any +>p : any +>div : any + +var openClosed4 =
{p < p}
; +>openClosed4 : JSX.Element +>
{p < p}
: JSX.Element +>div : any +>n : any +>p < p : boolean +>p : any +>p : any +>div : any + +var openClosed5 =
{p > p}
; +>openClosed5 : JSX.Element +>
{p > p}
: JSX.Element +>div : any +>n : any +>p > p : boolean +>p : any +>p : any +>div : any + +class SomeClass { +>SomeClass : SomeClass + + f() { +>f : () => void + + var rewrites1 =
{() => this}
; +>rewrites1 : JSX.Element +>
{() => this}
: JSX.Element +>div : any +>() => this : () => SomeClass +>this : SomeClass +>div : any + + var rewrites2 =
{[p, ...p, p]}
; +>rewrites2 : JSX.Element +>
{[p, ...p, p]}
: JSX.Element +>div : any +>[p, ...p, p] : any[] +>p : any +>...p : any +>p : any +>p : any +>div : any + + var rewrites3 =
{{p}}
; +>rewrites3 : JSX.Element +>
{{p}}
: JSX.Element +>div : any +>{p} : { p: any; } +>p : any +>div : any + + var rewrites4 =
this}>
; +>rewrites4 : JSX.Element +>
this}>
: JSX.Element +>div : any +>a : any +>() => this : () => SomeClass +>this : SomeClass +>div : any + + var rewrites5 =
; +>rewrites5 : JSX.Element +>
: JSX.Element +>div : any +>a : any +>[p, ...p, p] : any[] +>p : any +>...p : any +>p : any +>p : any +>div : any + + var rewrites6 =
; +>rewrites6 : JSX.Element +>
: JSX.Element +>div : any +>a : any +>{p} : { p: any; } +>p : any +>div : any + } +} + +var whitespace1 =
; +>whitespace1 : JSX.Element +>
: JSX.Element +>div : any +>div : any + +var whitespace2 =
{p}
; +>whitespace2 : JSX.Element +>
{p}
: JSX.Element +>div : any +>p : any +>div : any + +var whitespace3 =
+>whitespace3 : JSX.Element +>
{p}
: JSX.Element +>div : any + + {p} +>p : any + +
; +>div : any + diff --git a/tests/baselines/reference/tsxEmit2.js b/tests/baselines/reference/tsxEmit2.js new file mode 100644 index 00000000000..1101df49a1c --- /dev/null +++ b/tests/baselines/reference/tsxEmit2.js @@ -0,0 +1,23 @@ +//// [tsxEmit2.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p1, p2, p3; +var spreads1 =
{p2}
; +var spreads2 =
{p2}
; +var spreads3 =
{p2}
; +var spreads4 =
{p2}
; +var spreads5 =
{p2}
; + + +//// [tsxEmit2.jsx] +var p1, p2, p3; +var spreads1 =
{p2}
; +var spreads2 =
{p2}
; +var spreads3 =
{p2}
; +var spreads4 =
{p2}
; +var spreads5 =
{p2}
; diff --git a/tests/baselines/reference/tsxEmit2.symbols b/tests/baselines/reference/tsxEmit2.symbols new file mode 100644 index 00000000000..28f6a9f5026 --- /dev/null +++ b/tests/baselines/reference/tsxEmit2.symbols @@ -0,0 +1,44 @@ +=== tests/cases/conformance/jsx/tsxEmit2.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxEmit2.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxEmit2.tsx, 0, 20)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) + + [s: string]: any; +>s : Symbol(s, Decl(tsxEmit2.tsx, 3, 3)) + } +} + +var p1, p2, p3; +>p1 : Symbol(p1, Decl(tsxEmit2.tsx, 7, 3)) +>p2 : Symbol(p2, Decl(tsxEmit2.tsx, 7, 7)) +>p3 : Symbol(p3, Decl(tsxEmit2.tsx, 7, 11)) + +var spreads1 =
{p2}
; +>spreads1 : Symbol(spreads1, Decl(tsxEmit2.tsx, 8, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) + +var spreads2 =
{p2}
; +>spreads2 : Symbol(spreads2, Decl(tsxEmit2.tsx, 9, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) + +var spreads3 =
{p2}
; +>spreads3 : Symbol(spreads3, Decl(tsxEmit2.tsx, 10, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) +>x : Symbol(unknown) + +var spreads4 =
{p2}
; +>spreads4 : Symbol(spreads4, Decl(tsxEmit2.tsx, 11, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) +>x : Symbol(unknown) + +var spreads5 =
{p2}
; +>spreads5 : Symbol(spreads5, Decl(tsxEmit2.tsx, 12, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + diff --git a/tests/baselines/reference/tsxEmit2.types b/tests/baselines/reference/tsxEmit2.types new file mode 100644 index 00000000000..f5633b739e3 --- /dev/null +++ b/tests/baselines/reference/tsxEmit2.types @@ -0,0 +1,68 @@ +=== tests/cases/conformance/jsx/tsxEmit2.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + [s: string]: any; +>s : string + } +} + +var p1, p2, p3; +>p1 : any +>p2 : any +>p3 : any + +var spreads1 =
{p2}
; +>spreads1 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>p1 : any +>p2 : any +>div : any + +var spreads2 =
{p2}
; +>spreads2 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>p1 : any +>p2 : any +>div : any + +var spreads3 =
{p2}
; +>spreads3 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>x : any +>p3 : any +>p1 : any +>p2 : any +>div : any + +var spreads4 =
{p2}
; +>spreads4 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>p1 : any +>x : any +>p3 : any +>p2 : any +>div : any + +var spreads5 =
{p2}
; +>spreads5 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>x : any +>p2 : any +>p1 : any +>y : any +>p3 : any +>p2 : any +>div : any + diff --git a/tests/baselines/reference/tsxEmit3.js b/tests/baselines/reference/tsxEmit3.js new file mode 100644 index 00000000000..beae73e2bf1 --- /dev/null +++ b/tests/baselines/reference/tsxEmit3.js @@ -0,0 +1,84 @@ +//// [tsxEmit3.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { } +} + +module M { + export class Foo { constructor() { } } + export module S { + export class Bar { } + + // Emit Foo + // Foo, ; + } +} + +module M { + // Emit M.Foo + Foo, ; + + export module S { + // Emit M.Foo + Foo, ; + + // Emit S.Bar + Bar, ; + } + +} + +module M { + // Emit M.S.Bar + S.Bar, ; +} + +module M { + var M = 100; + // Emit M_1.Foo + Foo, ; +} + + +//// [tsxEmit3.jsx] +var M; +(function (M) { + var Foo = (function () { + function Foo() { + } + return Foo; + })(); + M.Foo = Foo; + var S; + (function (S) { + var Bar = (function () { + function Bar() { + } + return Bar; + })(); + S.Bar = Bar; + })(S = M.S || (M.S = {})); +})(M || (M = {})); +var M; +(function (M) { + // Emit M.Foo + M.Foo, ; + var S; + (function (S) { + // Emit M.Foo + M.Foo, ; + // Emit S.Bar + S.Bar, ; + })(S = M.S || (M.S = {})); +})(M || (M = {})); +var M; +(function (M) { + // Emit M.S.Bar + M.S.Bar, ; +})(M || (M = {})); +var M; +(function (M_1) { + var M = 100; + // Emit M_1.Foo + M_1.Foo, ; +})(M || (M = {})); diff --git a/tests/baselines/reference/tsxEmit3.symbols b/tests/baselines/reference/tsxEmit3.symbols new file mode 100644 index 00000000000..4ceed0b9b1e --- /dev/null +++ b/tests/baselines/reference/tsxEmit3.symbols @@ -0,0 +1,75 @@ +=== tests/cases/conformance/jsx/tsxEmit3.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxEmit3.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxEmit3.tsx, 0, 20)) + + interface IntrinsicElements { } +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxEmit3.tsx, 1, 22)) +} + +module M { +>M : Symbol(M, Decl(tsxEmit3.tsx, 3, 1), Decl(tsxEmit3.tsx, 13, 1), Decl(tsxEmit3.tsx, 27, 1), Decl(tsxEmit3.tsx, 32, 1)) + + export class Foo { constructor() { } } +>Foo : Symbol(Foo, Decl(tsxEmit3.tsx, 5, 10)) + + export module S { +>S : Symbol(S, Decl(tsxEmit3.tsx, 6, 39), Decl(tsxEmit3.tsx, 17, 14)) + + export class Bar { } +>Bar : Symbol(Bar, Decl(tsxEmit3.tsx, 7, 18)) + + // Emit Foo + // Foo, ; + } +} + +module M { +>M : Symbol(M, Decl(tsxEmit3.tsx, 3, 1), Decl(tsxEmit3.tsx, 13, 1), Decl(tsxEmit3.tsx, 27, 1), Decl(tsxEmit3.tsx, 32, 1)) + + // Emit M.Foo + Foo, ; +>Foo : Symbol(Foo, Decl(tsxEmit3.tsx, 5, 10)) +>Foo : Symbol(Foo, Decl(tsxEmit3.tsx, 5, 10)) + + export module S { +>S : Symbol(S, Decl(tsxEmit3.tsx, 6, 39), Decl(tsxEmit3.tsx, 17, 14)) + + // Emit M.Foo + Foo, ; +>Foo : Symbol(Foo, Decl(tsxEmit3.tsx, 5, 10)) +>Foo : Symbol(Foo, Decl(tsxEmit3.tsx, 5, 10)) + + // Emit S.Bar + Bar, ; +>Bar : Symbol(Bar, Decl(tsxEmit3.tsx, 7, 18)) +>Bar : Symbol(Bar, Decl(tsxEmit3.tsx, 7, 18)) + } + +} + +module M { +>M : Symbol(M, Decl(tsxEmit3.tsx, 3, 1), Decl(tsxEmit3.tsx, 13, 1), Decl(tsxEmit3.tsx, 27, 1), Decl(tsxEmit3.tsx, 32, 1)) + + // Emit M.S.Bar + S.Bar, ; +>S.Bar : Symbol(S.Bar, Decl(tsxEmit3.tsx, 7, 18)) +>S : Symbol(S, Decl(tsxEmit3.tsx, 6, 39), Decl(tsxEmit3.tsx, 17, 14)) +>Bar : Symbol(S.Bar, Decl(tsxEmit3.tsx, 7, 18)) +>Bar : Symbol(S.Bar, Decl(tsxEmit3.tsx, 7, 18)) +} + +module M { +>M : Symbol(M, Decl(tsxEmit3.tsx, 3, 1), Decl(tsxEmit3.tsx, 13, 1), Decl(tsxEmit3.tsx, 27, 1), Decl(tsxEmit3.tsx, 32, 1)) + + var M = 100; +>M : Symbol(M, Decl(tsxEmit3.tsx, 35, 4)) + + // Emit M_1.Foo + Foo, ; +>Foo : Symbol(Foo, Decl(tsxEmit3.tsx, 5, 10)) +>Foo : Symbol(Foo, Decl(tsxEmit3.tsx, 5, 10)) +} + diff --git a/tests/baselines/reference/tsxEmit3.types b/tests/baselines/reference/tsxEmit3.types new file mode 100644 index 00000000000..4bb92d9aea5 --- /dev/null +++ b/tests/baselines/reference/tsxEmit3.types @@ -0,0 +1,87 @@ +=== tests/cases/conformance/jsx/tsxEmit3.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { } +>IntrinsicElements : IntrinsicElements +} + +module M { +>M : typeof M + + export class Foo { constructor() { } } +>Foo : Foo + + export module S { +>S : typeof S + + export class Bar { } +>Bar : Bar + + // Emit Foo + // Foo, ; + } +} + +module M { +>M : typeof M + + // Emit M.Foo + Foo, ; +>Foo, : JSX.Element +>Foo : typeof Foo +> : JSX.Element +>Foo : typeof Foo + + export module S { +>S : typeof S + + // Emit M.Foo + Foo, ; +>Foo, : JSX.Element +>Foo : typeof Foo +> : JSX.Element +>Foo : typeof Foo + + // Emit S.Bar + Bar, ; +>Bar, : JSX.Element +>Bar : typeof Bar +> : JSX.Element +>Bar : typeof Bar + } + +} + +module M { +>M : typeof M + + // Emit M.S.Bar + S.Bar, ; +>S.Bar, : JSX.Element +>S.Bar : typeof S.Bar +>S : typeof S +>Bar : typeof S.Bar +> : JSX.Element +>S : any +>Bar : any +} + +module M { +>M : typeof M + + var M = 100; +>M : number +>100 : number + + // Emit M_1.Foo + Foo, ; +>Foo, : JSX.Element +>Foo : typeof Foo +> : JSX.Element +>Foo : typeof Foo +} + diff --git a/tests/baselines/reference/tsxGenericArrowFunctionParsing.js b/tests/baselines/reference/tsxGenericArrowFunctionParsing.js new file mode 100644 index 00000000000..f493347ca9c --- /dev/null +++ b/tests/baselines/reference/tsxGenericArrowFunctionParsing.js @@ -0,0 +1,46 @@ +//// [tsxGenericArrowFunctionParsing.tsx] +declare module JSX { + interface Element { isElement; } +} + +var T, T1, T2; + +// This is an element +var x1 = () => {}; +x1.isElement; + +// This is a generic function +var x2 = () => {}; +x2(); + +// This is a generic function +var x3 = () => {}; +x3(); + +// This is an element +var x4 = () => {}; +x4.isElement; + +// This is an element +var x5 = () => {}; +x5.isElement; + + + +//// [tsxGenericArrowFunctionParsing.jsx] +var T, T1, T2; +// This is an element +var x1 = () => ; +x1.isElement; +// This is a generic function +var x2 = function () { }; +x2(); +// This is a generic function +var x3 = function () { }; +x3(); +// This is an element +var x4 = () => ; +x4.isElement; +// This is an element +var x5 = () => ; +x5.isElement; diff --git a/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols b/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols new file mode 100644 index 00000000000..8bd68b2e8e7 --- /dev/null +++ b/tests/baselines/reference/tsxGenericArrowFunctionParsing.symbols @@ -0,0 +1,64 @@ +=== tests/cases/conformance/jsx/tsxGenericArrowFunctionParsing.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxGenericArrowFunctionParsing.tsx, 0, 0)) + + interface Element { isElement; } +>Element : Symbol(Element, Decl(tsxGenericArrowFunctionParsing.tsx, 0, 20)) +>isElement : Symbol(isElement, Decl(tsxGenericArrowFunctionParsing.tsx, 1, 20)) +} + +var T, T1, T2; +>T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 4, 3)) +>T1 : Symbol(T1, Decl(tsxGenericArrowFunctionParsing.tsx, 4, 6)) +>T2 : Symbol(T2, Decl(tsxGenericArrowFunctionParsing.tsx, 4, 10)) + +// This is an element +var x1 = () => {}; +>x1 : Symbol(x1, Decl(tsxGenericArrowFunctionParsing.tsx, 7, 3)) +>T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 4, 3)) + +x1.isElement; +>x1.isElement : Symbol(JSX.Element.isElement, Decl(tsxGenericArrowFunctionParsing.tsx, 1, 20)) +>x1 : Symbol(x1, Decl(tsxGenericArrowFunctionParsing.tsx, 7, 3)) +>isElement : Symbol(JSX.Element.isElement, Decl(tsxGenericArrowFunctionParsing.tsx, 1, 20)) + +// This is a generic function +var x2 = () => {}; +>x2 : Symbol(x2, Decl(tsxGenericArrowFunctionParsing.tsx, 11, 3)) +>T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 11, 10)) + +x2(); +>x2 : Symbol(x2, Decl(tsxGenericArrowFunctionParsing.tsx, 11, 3)) + +// This is a generic function +var x3 = () => {}; +>x3 : Symbol(x3, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 3)) +>T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 10)) +>T1 : Symbol(T1, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 12)) + +x3(); +>x3 : Symbol(x3, Decl(tsxGenericArrowFunctionParsing.tsx, 15, 3)) + +// This is an element +var x4 = () => {}; +>x4 : Symbol(x4, Decl(tsxGenericArrowFunctionParsing.tsx, 19, 3)) +>T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 4, 3)) +>extends : Symbol(unknown) + +x4.isElement; +>x4.isElement : Symbol(JSX.Element.isElement, Decl(tsxGenericArrowFunctionParsing.tsx, 1, 20)) +>x4 : Symbol(x4, Decl(tsxGenericArrowFunctionParsing.tsx, 19, 3)) +>isElement : Symbol(JSX.Element.isElement, Decl(tsxGenericArrowFunctionParsing.tsx, 1, 20)) + +// This is an element +var x5 = () => {}; +>x5 : Symbol(x5, Decl(tsxGenericArrowFunctionParsing.tsx, 23, 3)) +>T : Symbol(T, Decl(tsxGenericArrowFunctionParsing.tsx, 4, 3)) +>extends : Symbol(unknown) + +x5.isElement; +>x5.isElement : Symbol(JSX.Element.isElement, Decl(tsxGenericArrowFunctionParsing.tsx, 1, 20)) +>x5 : Symbol(x5, Decl(tsxGenericArrowFunctionParsing.tsx, 23, 3)) +>isElement : Symbol(JSX.Element.isElement, Decl(tsxGenericArrowFunctionParsing.tsx, 1, 20)) + + diff --git a/tests/baselines/reference/tsxGenericArrowFunctionParsing.types b/tests/baselines/reference/tsxGenericArrowFunctionParsing.types new file mode 100644 index 00000000000..a7d98d35b64 --- /dev/null +++ b/tests/baselines/reference/tsxGenericArrowFunctionParsing.types @@ -0,0 +1,75 @@ +=== tests/cases/conformance/jsx/tsxGenericArrowFunctionParsing.tsx === +declare module JSX { +>JSX : any + + interface Element { isElement; } +>Element : Element +>isElement : any +} + +var T, T1, T2; +>T : any +>T1 : any +>T2 : any + +// This is an element +var x1 = () => {}; +>x1 : JSX.Element +>() => {} : JSX.Element +>T : any +>T : any + +x1.isElement; +>x1.isElement : any +>x1 : JSX.Element +>isElement : any + +// This is a generic function +var x2 = () => {}; +>x2 : () => void +>() => {} : () => void +>T : T + +x2(); +>x2() : void +>x2 : () => void + +// This is a generic function +var x3 = () => {}; +>x3 : () => void +>() => {} : () => void +>T : T +>T1 : T1 + +x3(); +>x3() : void +>x3 : () => void + +// This is an element +var x4 = () => {}; +>x4 : JSX.Element +>() => {} : JSX.Element +>T : any +>extends : any +>true : boolean +>T : any + +x4.isElement; +>x4.isElement : any +>x4 : JSX.Element +>isElement : any + +// This is an element +var x5 = () => {}; +>x5 : JSX.Element +>() => {} : JSX.Element +>T : any +>extends : any +>T : any + +x5.isElement; +>x5.isElement : any +>x5 : JSX.Element +>isElement : any + + diff --git a/tests/baselines/reference/tsxNoJsx.errors.txt b/tests/baselines/reference/tsxNoJsx.errors.txt new file mode 100644 index 00000000000..9e5c6762c9e --- /dev/null +++ b/tests/baselines/reference/tsxNoJsx.errors.txt @@ -0,0 +1,9 @@ +tests/cases/conformance/jsx/tsxNoJsx.tsx(2,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. + + +==== tests/cases/conformance/jsx/tsxNoJsx.tsx (1 errors) ==== + + ; + ~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + \ No newline at end of file diff --git a/tests/baselines/reference/tsxNoJsx.js b/tests/baselines/reference/tsxNoJsx.js new file mode 100644 index 00000000000..37663adf2a7 --- /dev/null +++ b/tests/baselines/reference/tsxNoJsx.js @@ -0,0 +1,7 @@ +//// [tsxNoJsx.tsx] + +; + + +//// [tsxNoJsx.jsx] +; diff --git a/tests/baselines/reference/tsxParseTests1.js b/tests/baselines/reference/tsxParseTests1.js new file mode 100644 index 00000000000..7ab98cab314 --- /dev/null +++ b/tests/baselines/reference/tsxParseTests1.js @@ -0,0 +1,11 @@ +//// [tsxParseTests1.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { div; span; } +} + +var x =
; + + +//// [tsxParseTests1.jsx] +var x =
; diff --git a/tests/baselines/reference/tsxParseTests1.symbols b/tests/baselines/reference/tsxParseTests1.symbols new file mode 100644 index 00000000000..dbe11dbcbba --- /dev/null +++ b/tests/baselines/reference/tsxParseTests1.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/jsx/tsxParseTests1.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxParseTests1.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxParseTests1.tsx, 0, 20)) + + interface IntrinsicElements { div; span; } +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxParseTests1.tsx, 1, 22)) +>div : Symbol(div, Decl(tsxParseTests1.tsx, 2, 30)) +>span : Symbol(span, Decl(tsxParseTests1.tsx, 2, 35)) +} + +var x =
; +>x : Symbol(x, Decl(tsxParseTests1.tsx, 5, 3)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxParseTests1.tsx, 2, 30)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxParseTests1.tsx, 2, 30)) +>span : Symbol(JSX.IntrinsicElements.span, Decl(tsxParseTests1.tsx, 2, 35)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxParseTests1.tsx, 2, 30)) + diff --git a/tests/baselines/reference/tsxParseTests1.types b/tests/baselines/reference/tsxParseTests1.types new file mode 100644 index 00000000000..78e49a227e2 --- /dev/null +++ b/tests/baselines/reference/tsxParseTests1.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/jsx/tsxParseTests1.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { div; span; } +>IntrinsicElements : IntrinsicElements +>div : any +>span : any +} + +var x =
; +>x : JSX.Element +>
: JSX.Element +>div : any +>
: JSX.Element +>div : any +>
 : JSX.Element +>span : any +>
: JSX.Element +>div : any +>div : any +>span : any +>div : any +>div : any + diff --git a/tests/baselines/reference/tsxReactEmit1.js b/tests/baselines/reference/tsxReactEmit1.js new file mode 100644 index 00000000000..c461987c77d --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit1.js @@ -0,0 +1,73 @@ +//// [tsxReactEmit1.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p; +var selfClosed1 =
; +var selfClosed2 =
; +var selfClosed3 =
; +var selfClosed4 =
; +var selfClosed5 =
; +var selfClosed6 =
; +var selfClosed7 =
; + +var openClosed1 =
; +var openClosed2 =
foo
; +var openClosed3 =
{p}
; +var openClosed4 =
{p < p}
; +var openClosed5 =
{p > p}
; + +class SomeClass { + f() { + var rewrites1 =
{() => this}
; + var rewrites2 =
{[p, ...p, p]}
; + var rewrites3 =
{{p}}
; + + var rewrites4 =
this}>
; + var rewrites5 =
; + var rewrites6 =
; + } +} + +var whitespace1 =
; +var whitespace2 =
{p}
; +var whitespace3 =
+ {p} +
; + + +//// [tsxReactEmit1.js] +var p; +var selfClosed1 = React.createElement("div", null); +var selfClosed2 = React.createElement("div", {x: "1"}); +var selfClosed3 = React.createElement("div", {x: '1'}); +var selfClosed4 = React.createElement("div", {x: "1", y: '0'}); +var selfClosed5 = React.createElement("div", {x: 0, y: '0'}); +var selfClosed6 = React.createElement("div", {x: "1", y: '0'}); +var selfClosed7 = React.createElement("div", {x: p, y: 'p'}); +var openClosed1 = React.createElement("div", null); +var openClosed2 = React.createElement("div", {n: 'm'}, "foo"); +var openClosed3 = React.createElement("div", {n: 'm'}, p); +var openClosed4 = React.createElement("div", {n: 'm'}, p < p); +var openClosed5 = React.createElement("div", {n: 'm'}, p > p); +var SomeClass = (function () { + function SomeClass() { + } + SomeClass.prototype.f = function () { + var _this = this; + var rewrites1 = React.createElement("div", null, function () { return _this; }); + var rewrites2 = React.createElement("div", null, [p].concat(p, [p])); + var rewrites3 = React.createElement("div", null, { p: p }); + var rewrites4 = React.createElement("div", {a: function () { return _this; }}); + var rewrites5 = React.createElement("div", {a: [p].concat(p, [p])}); + var rewrites6 = React.createElement("div", {a: { p: p }}); + }; + return SomeClass; +})(); +var whitespace1 = React.createElement("div", null, " "); +var whitespace2 = React.createElement("div", null, " ", p, " "); +var whitespace3 = React.createElement("div", null, p); diff --git a/tests/baselines/reference/tsxReactEmit1.symbols b/tests/baselines/reference/tsxReactEmit1.symbols new file mode 100644 index 00000000000..f35a7872915 --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit1.symbols @@ -0,0 +1,144 @@ +=== tests/cases/conformance/jsx/tsxReactEmit1.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxReactEmit1.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxReactEmit1.tsx, 0, 20)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) + + [s: string]: any; +>s : Symbol(s, Decl(tsxReactEmit1.tsx, 3, 3)) + } +} + +var p; +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) + +var selfClosed1 =
; +>selfClosed1 : Symbol(selfClosed1, Decl(tsxReactEmit1.tsx, 8, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) + +var selfClosed2 =
; +>selfClosed2 : Symbol(selfClosed2, Decl(tsxReactEmit1.tsx, 9, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>x : Symbol(unknown) + +var selfClosed3 =
; +>selfClosed3 : Symbol(selfClosed3, Decl(tsxReactEmit1.tsx, 10, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>x : Symbol(unknown) + +var selfClosed4 =
; +>selfClosed4 : Symbol(selfClosed4, Decl(tsxReactEmit1.tsx, 11, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + +var selfClosed5 =
; +>selfClosed5 : Symbol(selfClosed5, Decl(tsxReactEmit1.tsx, 12, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + +var selfClosed6 =
; +>selfClosed6 : Symbol(selfClosed6, Decl(tsxReactEmit1.tsx, 13, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + +var selfClosed7 =
; +>selfClosed7 : Symbol(selfClosed7, Decl(tsxReactEmit1.tsx, 14, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + +var openClosed1 =
; +>openClosed1 : Symbol(openClosed1, Decl(tsxReactEmit1.tsx, 16, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) + +var openClosed2 =
foo
; +>openClosed2 : Symbol(openClosed2, Decl(tsxReactEmit1.tsx, 17, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>n : Symbol(unknown) + +var openClosed3 =
{p}
; +>openClosed3 : Symbol(openClosed3, Decl(tsxReactEmit1.tsx, 18, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>n : Symbol(unknown) + +var openClosed4 =
{p < p}
; +>openClosed4 : Symbol(openClosed4, Decl(tsxReactEmit1.tsx, 19, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>n : Symbol(unknown) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) + +var openClosed5 =
{p > p}
; +>openClosed5 : Symbol(openClosed5, Decl(tsxReactEmit1.tsx, 20, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>n : Symbol(unknown) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) + +class SomeClass { +>SomeClass : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 43)) + + f() { +>f : Symbol(f, Decl(tsxReactEmit1.tsx, 22, 17)) + + var rewrites1 =
{() => this}
; +>rewrites1 : Symbol(rewrites1, Decl(tsxReactEmit1.tsx, 24, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 43)) + + var rewrites2 =
{[p, ...p, p]}
; +>rewrites2 : Symbol(rewrites2, Decl(tsxReactEmit1.tsx, 25, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) + + var rewrites3 =
{{p}}
; +>rewrites3 : Symbol(rewrites3, Decl(tsxReactEmit1.tsx, 26, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 26, 25)) + + var rewrites4 =
this}>
; +>rewrites4 : Symbol(rewrites4, Decl(tsxReactEmit1.tsx, 28, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>a : Symbol(unknown) +>this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 43)) + + var rewrites5 =
; +>rewrites5 : Symbol(rewrites5, Decl(tsxReactEmit1.tsx, 29, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>a : Symbol(unknown) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) + + var rewrites6 =
; +>rewrites6 : Symbol(rewrites6, Decl(tsxReactEmit1.tsx, 30, 5)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) +>a : Symbol(unknown) +>p : Symbol(p, Decl(tsxReactEmit1.tsx, 30, 27)) + } +} + +var whitespace1 =
; +>whitespace1 : Symbol(whitespace1, Decl(tsxReactEmit1.tsx, 34, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) + +var whitespace2 =
{p}
; +>whitespace2 : Symbol(whitespace2, Decl(tsxReactEmit1.tsx, 35, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) + +var whitespace3 =
+>whitespace3 : Symbol(whitespace3, Decl(tsxReactEmit1.tsx, 36, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) + + {p} +
; + diff --git a/tests/baselines/reference/tsxReactEmit1.types b/tests/baselines/reference/tsxReactEmit1.types new file mode 100644 index 00000000000..d58316b14cf --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit1.types @@ -0,0 +1,194 @@ +=== tests/cases/conformance/jsx/tsxReactEmit1.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + [s: string]: any; +>s : string + } +} + +var p; +>p : any + +var selfClosed1 =
; +>selfClosed1 : JSX.Element +>
: JSX.Element +>div : any + +var selfClosed2 =
; +>selfClosed2 : JSX.Element +>
: JSX.Element +>div : any +>x : any + +var selfClosed3 =
; +>selfClosed3 : JSX.Element +>
: JSX.Element +>div : any +>x : any + +var selfClosed4 =
; +>selfClosed4 : JSX.Element +>
: JSX.Element +>div : any +>x : any +>y : any + +var selfClosed5 =
; +>selfClosed5 : JSX.Element +>
: JSX.Element +>div : any +>x : any +>y : any + +var selfClosed6 =
; +>selfClosed6 : JSX.Element +>
: JSX.Element +>div : any +>x : any +>y : any + +var selfClosed7 =
; +>selfClosed7 : JSX.Element +>
: JSX.Element +>div : any +>x : any +>p : any +>y : any + +var openClosed1 =
; +>openClosed1 : JSX.Element +>
: JSX.Element +>div : any +>div : any + +var openClosed2 =
foo
; +>openClosed2 : JSX.Element +>
foo
: JSX.Element +>div : any +>n : any +>div : any + +var openClosed3 =
{p}
; +>openClosed3 : JSX.Element +>
{p}
: JSX.Element +>div : any +>n : any +>p : any +>div : any + +var openClosed4 =
{p < p}
; +>openClosed4 : JSX.Element +>
{p < p}
: JSX.Element +>div : any +>n : any +>p < p : boolean +>p : any +>p : any +>div : any + +var openClosed5 =
{p > p}
; +>openClosed5 : JSX.Element +>
{p > p}
: JSX.Element +>div : any +>n : any +>p > p : boolean +>p : any +>p : any +>div : any + +class SomeClass { +>SomeClass : SomeClass + + f() { +>f : () => void + + var rewrites1 =
{() => this}
; +>rewrites1 : JSX.Element +>
{() => this}
: JSX.Element +>div : any +>() => this : () => SomeClass +>this : SomeClass +>div : any + + var rewrites2 =
{[p, ...p, p]}
; +>rewrites2 : JSX.Element +>
{[p, ...p, p]}
: JSX.Element +>div : any +>[p, ...p, p] : any[] +>p : any +>...p : any +>p : any +>p : any +>div : any + + var rewrites3 =
{{p}}
; +>rewrites3 : JSX.Element +>
{{p}}
: JSX.Element +>div : any +>{p} : { p: any; } +>p : any +>div : any + + var rewrites4 =
this}>
; +>rewrites4 : JSX.Element +>
this}>
: JSX.Element +>div : any +>a : any +>() => this : () => SomeClass +>this : SomeClass +>div : any + + var rewrites5 =
; +>rewrites5 : JSX.Element +>
: JSX.Element +>div : any +>a : any +>[p, ...p, p] : any[] +>p : any +>...p : any +>p : any +>p : any +>div : any + + var rewrites6 =
; +>rewrites6 : JSX.Element +>
: JSX.Element +>div : any +>a : any +>{p} : { p: any; } +>p : any +>div : any + } +} + +var whitespace1 =
; +>whitespace1 : JSX.Element +>
: JSX.Element +>div : any +>div : any + +var whitespace2 =
{p}
; +>whitespace2 : JSX.Element +>
{p}
: JSX.Element +>div : any +>p : any +>div : any + +var whitespace3 =
+>whitespace3 : JSX.Element +>
{p}
: JSX.Element +>div : any + + {p} +>p : any + +
; +>div : any + diff --git a/tests/baselines/reference/tsxReactEmit2.js b/tests/baselines/reference/tsxReactEmit2.js new file mode 100644 index 00000000000..c19d9958ad4 --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit2.js @@ -0,0 +1,23 @@ +//// [tsxReactEmit2.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p1, p2, p3; +var spreads1 =
{p2}
; +var spreads2 =
{p2}
; +var spreads3 =
{p2}
; +var spreads4 =
{p2}
; +var spreads5 =
{p2}
; + + +//// [tsxReactEmit2.js] +var p1, p2, p3; +var spreads1 = React.createElement("div", React.__spread(p1), p2); +var spreads2 = React.createElement("div", React.__spread(p1), p2); +var spreads3 = React.createElement("div", React.__spread({x: p3}, p1), p2); +var spreads4 = React.createElement("div", React.__spread(p1, {x: p3}), p2); +var spreads5 = React.createElement("div", React.__spread({x: p2}, p1, {y: p3}), p2); diff --git a/tests/baselines/reference/tsxReactEmit2.symbols b/tests/baselines/reference/tsxReactEmit2.symbols new file mode 100644 index 00000000000..9607d9330da --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit2.symbols @@ -0,0 +1,44 @@ +=== tests/cases/conformance/jsx/tsxReactEmit2.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxReactEmit2.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxReactEmit2.tsx, 0, 20)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) + + [s: string]: any; +>s : Symbol(s, Decl(tsxReactEmit2.tsx, 3, 3)) + } +} + +var p1, p2, p3; +>p1 : Symbol(p1, Decl(tsxReactEmit2.tsx, 7, 3)) +>p2 : Symbol(p2, Decl(tsxReactEmit2.tsx, 7, 7)) +>p3 : Symbol(p3, Decl(tsxReactEmit2.tsx, 7, 11)) + +var spreads1 =
{p2}
; +>spreads1 : Symbol(spreads1, Decl(tsxReactEmit2.tsx, 8, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) + +var spreads2 =
{p2}
; +>spreads2 : Symbol(spreads2, Decl(tsxReactEmit2.tsx, 9, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) + +var spreads3 =
{p2}
; +>spreads3 : Symbol(spreads3, Decl(tsxReactEmit2.tsx, 10, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) +>x : Symbol(unknown) + +var spreads4 =
{p2}
; +>spreads4 : Symbol(spreads4, Decl(tsxReactEmit2.tsx, 11, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) +>x : Symbol(unknown) + +var spreads5 =
{p2}
; +>spreads5 : Symbol(spreads5, Decl(tsxReactEmit2.tsx, 12, 3)) +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) +>x : Symbol(unknown) +>y : Symbol(unknown) + diff --git a/tests/baselines/reference/tsxReactEmit2.types b/tests/baselines/reference/tsxReactEmit2.types new file mode 100644 index 00000000000..9f8d6e494d0 --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit2.types @@ -0,0 +1,68 @@ +=== tests/cases/conformance/jsx/tsxReactEmit2.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + [s: string]: any; +>s : string + } +} + +var p1, p2, p3; +>p1 : any +>p2 : any +>p3 : any + +var spreads1 =
{p2}
; +>spreads1 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>p1 : any +>p2 : any +>div : any + +var spreads2 =
{p2}
; +>spreads2 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>p1 : any +>p2 : any +>div : any + +var spreads3 =
{p2}
; +>spreads3 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>x : any +>p3 : any +>p1 : any +>p2 : any +>div : any + +var spreads4 =
{p2}
; +>spreads4 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>p1 : any +>x : any +>p3 : any +>p2 : any +>div : any + +var spreads5 =
{p2}
; +>spreads5 : JSX.Element +>
{p2}
: JSX.Element +>div : any +>x : any +>p2 : any +>p1 : any +>y : any +>p3 : any +>p2 : any +>div : any + diff --git a/tests/baselines/reference/tsxReactEmit3.js b/tests/baselines/reference/tsxReactEmit3.js new file mode 100644 index 00000000000..9885effa48f --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit3.js @@ -0,0 +1,10 @@ +//// [tsxReactEmit3.tsx] + +declare module JSX { interface Element { } } + +declare var Foo, Bar, baz; + + q s ; + +//// [tsxReactEmit3.js] +React.createElement(Foo, null, " ", React.createElement(Bar, null, " q "), " ", React.createElement(Bar, null), " s ", React.createElement(Bar, null), React.createElement(Bar, null)); diff --git a/tests/baselines/reference/tsxReactEmit3.symbols b/tests/baselines/reference/tsxReactEmit3.symbols new file mode 100644 index 00000000000..8ef0ccab241 --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit3.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/jsx/tsxReactEmit3.tsx === + +declare module JSX { interface Element { } } +>JSX : Symbol(JSX, Decl(tsxReactEmit3.tsx, 0, 0)) +>Element : Symbol(Element, Decl(tsxReactEmit3.tsx, 1, 20)) + +declare var Foo, Bar, baz; +>Foo : Symbol(Foo, Decl(tsxReactEmit3.tsx, 3, 11)) +>Bar : Symbol(Bar, Decl(tsxReactEmit3.tsx, 3, 16)) +>baz : Symbol(baz, Decl(tsxReactEmit3.tsx, 3, 21)) + + q s ; +>Foo : Symbol(Foo, Decl(tsxReactEmit3.tsx, 3, 11)) +>Bar : Symbol(Bar, Decl(tsxReactEmit3.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(tsxReactEmit3.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(tsxReactEmit3.tsx, 3, 16)) +>Bar : Symbol(Bar, Decl(tsxReactEmit3.tsx, 3, 16)) + diff --git a/tests/baselines/reference/tsxReactEmit3.types b/tests/baselines/reference/tsxReactEmit3.types new file mode 100644 index 00000000000..9e5d9fece56 --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit3.types @@ -0,0 +1,25 @@ +=== tests/cases/conformance/jsx/tsxReactEmit3.tsx === + +declare module JSX { interface Element { } } +>JSX : any +>Element : Element + +declare var Foo, Bar, baz; +>Foo : any +>Bar : any +>baz : any + + q s ; +> q s : JSX.Element +>Foo : any +> q : JSX.Element +>Bar : any +>Bar : any +> : JSX.Element +>Bar : any +> : JSX.Element +>Bar : any +> : JSX.Element +>Bar : any +>Foo : any + diff --git a/tests/baselines/reference/tsxReactEmit4.errors.txt b/tests/baselines/reference/tsxReactEmit4.errors.txt new file mode 100644 index 00000000000..82cacd39e28 --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit4.errors.txt @@ -0,0 +1,20 @@ +tests/cases/conformance/jsx/tsxReactEmit4.tsx(11,5): error TS2304: Cannot find name 'blah'. + + +==== tests/cases/conformance/jsx/tsxReactEmit4.tsx (1 errors) ==== + declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } + } + + var p; + var openClosed1 =
+ + {blah} + ~~~~ +!!! error TS2304: Cannot find name 'blah'. + +
; + \ No newline at end of file diff --git a/tests/baselines/reference/tsxReactEmit4.js b/tests/baselines/reference/tsxReactEmit4.js new file mode 100644 index 00000000000..b162b17ad7f --- /dev/null +++ b/tests/baselines/reference/tsxReactEmit4.js @@ -0,0 +1,19 @@ +//// [tsxReactEmit4.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +var p; +var openClosed1 =
+ + {blah} + +
; + + +//// [tsxReactEmit4.js] +var p; +var openClosed1 = React.createElement("div", null, blah); diff --git a/tests/baselines/reference/tsxReactEmitWhitespace.js b/tests/baselines/reference/tsxReactEmitWhitespace.js new file mode 100644 index 00000000000..69bceb7a0e9 --- /dev/null +++ b/tests/baselines/reference/tsxReactEmitWhitespace.js @@ -0,0 +1,75 @@ +//// [tsxReactEmitWhitespace.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + [s: string]: any; + } +} + +// THIS FILE HAS TEST-SIGNIFICANT LEADING/TRAILING +// WHITESPACE, DO NOT RUN 'FORMAT DOCUMENT' ON IT + +var p = 0; +// Emit " " +
; +// Emit " ", p, " " +
{p}
; +// Emit only p +
+ {p} +
; + +// Emit only p +
+ {p} +
; + +// Emit " 3" +
3 +
; + +// Emit " 3 " +
3
; + +// Emit "3" +
+ 3 +
; + +// Emit no args +
+
; + +// Emit "foo" + ' ' + "bar" +
+ + foo + + bar + +
; + + + +//// [tsxReactEmitWhitespace.js] +// THIS FILE HAS TEST-SIGNIFICANT LEADING/TRAILING +// WHITESPACE, DO NOT RUN 'FORMAT DOCUMENT' ON IT +var p = 0; +// Emit " " +React.createElement("div", null, " "); +// Emit " ", p, " " +React.createElement("div", null, " ", p, " "); +// Emit only p +React.createElement("div", null, p); +// Emit only p +React.createElement("div", null, p); +// Emit " 3" +React.createElement("div", null, " 3"); +// Emit " 3 " +React.createElement("div", null, " 3 "); +// Emit "3" +React.createElement("div", null, "3"); +// Emit no args +React.createElement("div", null); +// Emit "foo" + ' ' + "bar" +React.createElement("div", null, "foo" + ' ' + "bar"); diff --git a/tests/baselines/reference/tsxReactEmitWhitespace.symbols b/tests/baselines/reference/tsxReactEmitWhitespace.symbols new file mode 100644 index 00000000000..afbb6944981 --- /dev/null +++ b/tests/baselines/reference/tsxReactEmitWhitespace.symbols @@ -0,0 +1,77 @@ +=== tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxReactEmitWhitespace.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxReactEmitWhitespace.tsx, 0, 20)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + + [s: string]: any; +>s : Symbol(s, Decl(tsxReactEmitWhitespace.tsx, 3, 3)) + } +} + +// THIS FILE HAS TEST-SIGNIFICANT LEADING/TRAILING +// WHITESPACE, DO NOT RUN 'FORMAT DOCUMENT' ON IT + +var p = 0; +>p : Symbol(p, Decl(tsxReactEmitWhitespace.tsx, 10, 3)) + +// Emit " " +
; +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + +// Emit " ", p, " " +
{p}
; +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + +// Emit only p +
+>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + + {p} +
; + +// Emit only p +
+>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + + {p} +
; + +// Emit " 3" +
3 +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + +
; + +// Emit " 3 " +
3
; +>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + +// Emit "3" +
+>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + + 3 +
; + +// Emit no args +
+>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + +
; + +// Emit "foo" + ' ' + "bar" +
+>div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmitWhitespace.tsx, 1, 22)) + + foo + + bar + +
; + + diff --git a/tests/baselines/reference/tsxReactEmitWhitespace.types b/tests/baselines/reference/tsxReactEmitWhitespace.types new file mode 100644 index 00000000000..e0e3639fa9b --- /dev/null +++ b/tests/baselines/reference/tsxReactEmitWhitespace.types @@ -0,0 +1,101 @@ +=== tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + [s: string]: any; +>s : string + } +} + +// THIS FILE HAS TEST-SIGNIFICANT LEADING/TRAILING +// WHITESPACE, DO NOT RUN 'FORMAT DOCUMENT' ON IT + +var p = 0; +>p : number +>0 : number + +// Emit " " +
; +>
: JSX.Element +>div : any +>div : any + +// Emit " ", p, " " +
{p}
; +>
{p}
: JSX.Element +>div : any +>p : any +>div : any + +// Emit only p +
+>
{p}
: JSX.Element +>div : any + + {p} +>p : any + +
; +>div : any + +// Emit only p +
+>
{p}
: JSX.Element +>div : any + + {p} +>p : any + +
; +>div : any + +// Emit " 3" +
3 +>
3
: JSX.Element +>div : any + +
; +>div : any + +// Emit " 3 " +
3
; +>
3
: JSX.Element +>div : any +>div : any + +// Emit "3" +
+>
3
: JSX.Element +>div : any + + 3 +
; +>div : any + +// Emit no args +
+>
: JSX.Element +>div : any + +
; +>div : any + +// Emit "foo" + ' ' + "bar" +
+>
foo bar
: JSX.Element +>div : any + + foo + + bar + +
; +>div : any + + diff --git a/tests/baselines/reference/tsxTypeErrors.errors.txt b/tests/baselines/reference/tsxTypeErrors.errors.txt new file mode 100644 index 00000000000..42959efe6fe --- /dev/null +++ b/tests/baselines/reference/tsxTypeErrors.errors.txt @@ -0,0 +1,55 @@ +tests/cases/conformance/jsx/tsxTypeErrors.tsx(3,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxTypeErrors.tsx(6,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxTypeErrors.tsx(10,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxTypeErrors.tsx(13,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxTypeErrors.tsx(26,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxTypeErrors.tsx(32,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. + + +==== tests/cases/conformance/jsx/tsxTypeErrors.tsx (6 errors) ==== + + // A built-in element (OK) + var a1 =
; + ~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + // A built-in element with a mistyped property (error) + var a2 = + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + // A built-in element with a badly-typed attribute value (error) + var thing = { oops: 100 }; + var a3 =
+ ~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + // Mistyped html name (error) + var e1 = + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + // A custom type + class MyClass { + props: { + pt?: { x: number; y: number; }; + name?: string; + reqd: boolean; + } + } + + // Let's use it + // TODO: Error on missing 'reqd' + var b1 = ; + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + // Mistyped attribute member + // sample.tsx(23,22): error TS2322: Type '{ x: number; y: string; }' is not assignable to type '{ x: number; y: number; }'. + // Types of property 'y' are incompatible. + // Type 'string' is not assignable to type 'number'. + var b2 = ; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + + \ No newline at end of file diff --git a/tests/baselines/reference/tsxTypeErrors.js b/tests/baselines/reference/tsxTypeErrors.js new file mode 100644 index 00000000000..f195a459747 --- /dev/null +++ b/tests/baselines/reference/tsxTypeErrors.js @@ -0,0 +1,60 @@ +//// [tsxTypeErrors.tsx] + +// A built-in element (OK) +var a1 =
; + +// A built-in element with a mistyped property (error) +var a2 = + +// A built-in element with a badly-typed attribute value (error) +var thing = { oops: 100 }; +var a3 =
+ +// Mistyped html name (error) +var e1 = + +// A custom type +class MyClass { + props: { + pt?: { x: number; y: number; }; + name?: string; + reqd: boolean; + } +} + +// Let's use it +// TODO: Error on missing 'reqd' +var b1 = ; + +// Mistyped attribute member +// sample.tsx(23,22): error TS2322: Type '{ x: number; y: string; }' is not assignable to type '{ x: number; y: number; }'. +// Types of property 'y' are incompatible. +// Type 'string' is not assignable to type 'number'. +var b2 = ; + + + +//// [tsxTypeErrors.jsx] +// A built-in element (OK) +var a1 =
; +// A built-in element with a mistyped property (error) +var a2 = ; +// A built-in element with a badly-typed attribute value (error) +var thing = { oops: 100 }; +var a3 =
; +// Mistyped html name (error) +var e1 = ; +// A custom type +var MyClass = (function () { + function MyClass() { + } + return MyClass; +})(); +// Let's use it +// TODO: Error on missing 'reqd' +var b1 = ; +// Mistyped attribute member +// sample.tsx(23,22): error TS2322: Type '{ x: number; y: string; }' is not assignable to type '{ x: number; y: number; }'. +// Types of property 'y' are incompatible. +// Type 'string' is not assignable to type 'number'. +var b2 = ; From 38a54bc0b90f7145abd45e186e74e4dc78ad705c Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 18 Jun 2015 14:16:00 -0700 Subject: [PATCH 131/309] Fix incremental parsing issue. We were moving a method-declaration called "constructor" into a class. This is incorrect as that same code should be parsed as a constructor-declaration now that it is in the class context. --- src/compiler/parser.ts | 10 +++++++++- tests/cases/unittests/incrementalParser.ts | 18 ++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index a507125d4bb..a94341dd9c4 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1491,12 +1491,20 @@ namespace ts { switch (node.kind) { case SyntaxKind.Constructor: case SyntaxKind.IndexSignature: - case SyntaxKind.MethodDeclaration: case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: case SyntaxKind.PropertyDeclaration: case SyntaxKind.SemicolonClassElement: return true; + case SyntaxKind.MethodDeclaration: + // Method declarations are not necessarily reusable. An object-literal + // may have a method calls "constructor(...)" and we must reparse that + // into an actual .ConstructorDeclaration. + let methodDeclaration = node; + let nameIsConstructor = methodDeclaration.name.kind === SyntaxKind.Identifier && + (methodDeclaration.name).originalKeywordKind === SyntaxKind.ConstructorKeyword; + + return !nameIsConstructor; } } diff --git a/tests/cases/unittests/incrementalParser.ts b/tests/cases/unittests/incrementalParser.ts index a0b361a87f4..1ef10eaa712 100644 --- a/tests/cases/unittests/incrementalParser.ts +++ b/tests/cases/unittests/incrementalParser.ts @@ -713,6 +713,24 @@ module m3 { }\ compareTrees(oldText, newTextAndChange.text, newTextAndChange.textChangeRange, 4); }); + it('Do not move constructors from class to object-literal.', () => { + var source = "class C { public constructor() { } public constructor() { } public constructor() { } }" + + var oldText = ScriptSnapshot.fromString(source); + var newTextAndChange = withChange(oldText, 0, "class C".length, "var v ="); + + compareTrees(oldText, newTextAndChange.text, newTextAndChange.textChangeRange, 0); + }); + + it('Do not move methods called "constructor" from object literal to class', () => { + var source = "var v = { public constructor() { } public constructor() { } public constructor() { } }" + + var oldText = ScriptSnapshot.fromString(source); + var newTextAndChange = withChange(oldText, 0, "var v =".length, "class C"); + + compareTrees(oldText, newTextAndChange.text, newTextAndChange.textChangeRange, 0); + }); + it('Moving index signatures from class to interface',() => { var source = "class C { public [a: number]: string; public [a: number]: string; public [a: number]: string }" From 413f27842472e5b8ad9c2fc5787a9740abadebe0 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 18 Jun 2015 14:17:13 -0700 Subject: [PATCH 132/309] Generate names of form class_N for anonymous classes --- src/compiler/emitter.ts | 7 ++++++- tests/baselines/reference/anonymousClassExpression1.js | 4 ++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 469b13294ad..8e4a038dde4 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -264,6 +264,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return makeUniqueName("default"); } + function generateNameForClassExpression() { + return makeUniqueName("class"); + } + function generateNameForNode(node: Node) { switch (node.kind) { case SyntaxKind.Identifier: @@ -276,9 +280,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return generateNameForImportOrExportDeclaration(node); case SyntaxKind.FunctionDeclaration: case SyntaxKind.ClassDeclaration: - case SyntaxKind.ClassExpression: case SyntaxKind.ExportAssignment: return generateNameForExportDefault(); + case SyntaxKind.ClassExpression: + return generateNameForClassExpression(); } } diff --git a/tests/baselines/reference/anonymousClassExpression1.js b/tests/baselines/reference/anonymousClassExpression1.js index 78cf5b05c51..5ced5120979 100644 --- a/tests/baselines/reference/anonymousClassExpression1.js +++ b/tests/baselines/reference/anonymousClassExpression1.js @@ -6,8 +6,8 @@ function f() { //// [anonymousClassExpression1.js] function f() { return typeof (function () { - function default_1() { + function class_1() { } - return default_1; + return class_1; })() === "function"; } From 6dc430d8926868f23f8ac11cf3fe4d658a02ff04 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 14:18:10 -0700 Subject: [PATCH 133/309] constructor cannot have modifier 'abstract' --- src/compiler/checker.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 2f7a66ad78c..e9977c9cd42 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12853,6 +12853,9 @@ namespace ts { if (flags & NodeFlags.Static) { return grammarErrorOnNode(lastStatic, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } + if (flags & NodeFlags.Abstract) { + return grammarErrorOnNode(lastStatic, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract"); + } else if (flags & NodeFlags.Protected) { return grammarErrorOnNode(lastProtected, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected"); } From c4876d53fd461cd7842396e0e1faa5de34c11c04 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 18 Jun 2015 14:26:22 -0700 Subject: [PATCH 134/309] Add support for awaiting union types with mixed promise and non-promise constituents. --- src/compiler/checker.ts | 176 ++++++++++-------- tests/baselines/reference/awaitUnion_es6.js | 24 +++ .../reference/awaitUnion_es6.symbols | 39 ++++ .../baselines/reference/awaitUnion_es6.types | 44 +++++ .../conformance/async/es6/awaitUnion_es6.ts | 14 ++ 5 files changed, 219 insertions(+), 78 deletions(-) create mode 100644 tests/baselines/reference/awaitUnion_es6.js create mode 100644 tests/baselines/reference/awaitUnion_es6.symbols create mode 100644 tests/baselines/reference/awaitUnion_es6.types create mode 100644 tests/cases/conformance/async/es6/awaitUnion_es6.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 70ca1172ccb..83e5d3de18c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7653,7 +7653,7 @@ namespace ts { // Promise/A+ compatible implementation will always assimilate any foreign promise, so the // return type of the body should be unwrapped to its awaited type, which we will wrap in // the native Promise type later in this function. - type = getAwaitedType(type, func, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + type = checkAwaitedType(type, func, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); } } else { @@ -7762,7 +7762,7 @@ namespace ts { // Promise/A+ compatible implementation will always assimilate any foreign promise, so the // return type of the body should be unwrapped to its awaited type, which should be wrapped in // the native Promise type by the caller. - type = getAwaitedType(type, body.parent, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + type = checkAwaitedType(type, body.parent, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); } if (!contains(aggregatedTypes, type)) { @@ -7914,7 +7914,7 @@ namespace ts { let exprType = checkExpression(node.body); if (returnType) { if (isAsync) { - let awaitedType = getAwaitedType(exprType, node.body, Diagnostics.Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member); + let awaitedType = checkAwaitedType(exprType, node.body, Diagnostics.Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member); checkTypeAssignableTo(awaitedType, promisedType, node.body); } else { @@ -8041,7 +8041,7 @@ namespace ts { } let operandType = checkExpression(node.expression); - return getAwaitedType(operandType, node); + return checkAwaitedType(operandType, node); } function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type { @@ -9474,10 +9474,10 @@ namespace ts { error(location, message); } - return false; + return unknownType; } - return true; + return type; } /** @@ -9537,7 +9537,7 @@ namespace ts { return getTypeAtPosition(signature, 0); } - let alreadySeenTypesForAwait: boolean[] = []; + let awaitedTypeStack: number[] = []; /** * Gets the "awaited type" of a type. @@ -9546,76 +9546,96 @@ namespace ts { * Promise-like type; otherwise, it is the type of the expression. This is used to reflect * The runtime behavior of the `await` keyword. */ - function getAwaitedType(type: Type, location?: Node, message?: DiagnosticMessage): Type { - // reset the set of visited types - alreadySeenTypesForAwait.length = 0; - while (true) { - let promisedType = getPromisedType(type); - if (promisedType === undefined) { - // The type was not a PromiseLike, so it could not be unwrapped any further. - // As long as the type does not have a callable "then" property, then it is - // safe to return the type; otherwise, an error will have been reported in - // the call to checkNonThenableType and we will return unknownType. - // - // An example of a non-promise "thenable" might be: - // - // await { then(): void {} } - // - // The "thenable" does not match the minimal definition for a PromiseLike. When - // a Promise/A+-compatible or ES6 promise tries to adopt this value, the promise - // will never settle. We treat this as an error to help flag an early indicator - // of a runtime problem. If the user wants to return this value from an async - // function, they would need to wrap it in some other value. If they want it to - // be treated as a promise, they can cast to . - if (!checkNonThenableType(type, location, message)) { - type = unknownType; - } - - break; - } - - // Keep track of the type we're about to unwrap to avoid bad recursive promise types. - // See the comments below for more information. - alreadySeenTypesForAwait[type.id] = true; - - if (alreadySeenTypesForAwait[promisedType.id]) { - // We have a bad actor in the form of a promise whose promised type is the same - // promise type, or a mutually recursive promise. Return the unknown type as we cannot guess - // the shape. If this were the actual case in the JavaScript, this Promise would never resolve. - // - // An example of a bad actor with a singly-recursive promise type might be: - // - // interface BadPromise { - // then(onfulfilled: (value: BadPromise) => any, onrejected: (error: any) => any): BadPromise; - // } - // - // The above interface will pass the PromiseLike check, and return a promised type of `BadPromise`. - // Since this is a self reference, we don't want to keep recursing ad infinitum. - // - // An example of a bad actor in the form of a mutually-recursive promise type might be: - // - // interface BadPromiseA { - // then(onfulfilled: (value: BadPromiseB) => any, onrejected: (error: any) => any): BadPromiseB; - // } - // - // interface BadPromiseB { - // then(onfulfilled: (value: BadPromiseA) => any, onrejected: (error: any) => any): BadPromiseA; - // } - // - if (location) { - error(location, Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, symbolToString(type.symbol)); - } - - type = unknownType; - break; - } - - type = promisedType; - } + function getAwaitedType(type: Type) { + return checkAwaitedType(type, /*location*/ undefined, /*message*/ undefined); + } + + function checkAwaitedType(type: Type, location?: Node, message?: DiagnosticMessage) { + return getAwaitedTypeWorker(type); - // Cleanup, reset the set of visited types - alreadySeenTypesForAwait.length = 0; - return type; + function getAwaitedTypeWorker(type: Type): Type { + if (type.flags & TypeFlags.Union) { + let types: Type[] = []; + for (let constituentType of (type).types) { + types.push(getAwaitedTypeWorker(constituentType)); + } + + return getUnionType(types); + } + else { + let promisedType = getPromisedType(type); + if (promisedType === undefined) { + // The type was not a PromiseLike, so it could not be unwrapped any further. + // As long as the type does not have a callable "then" property, it is + // safe to return the type; otherwise, an error will have been reported in + // the call to checkNonThenableType and we will return unknownType. + // + // An example of a non-promise "thenable" might be: + // + // await { then(): void {} } + // + // The "thenable" does not match the minimal definition for a PromiseLike. When + // a Promise/A+-compatible or ES6 promise tries to adopt this value, the promise + // will never settle. We treat this as an error to help flag an early indicator + // of a runtime problem. If the user wants to return this value from an async + // function, they would need to wrap it in some other value. If they want it to + // be treated as a promise, they can cast to . + return checkNonThenableType(type, location, message); + } + else { + if (type.id === promisedType.id || awaitedTypeStack.indexOf(promisedType.id) >= 0) { + // We have a bad actor in the form of a promise whose promised type is + // the same promise type, or a mutually recursive promise. Return the + // unknown type as we cannot guess the shape. If this were the actual + // case in the JavaScript, this Promise would never resolve. + // + // An example of a bad actor with a singly-recursive promise type might + // be: + // + // interface BadPromise { + // then( + // onfulfilled: (value: BadPromise) => any, + // onrejected: (error: any) => any): BadPromise; + // } + // + // The above interface will pass the PromiseLike check, and return a + // promised type of `BadPromise`. Since this is a self reference, we + // don't want to keep recursing ad infinitum. + // + // An example of a bad actor in the form of a mutually-recursive + // promise type might be: + // + // interface BadPromiseA { + // then( + // onfulfilled: (value: BadPromiseB) => any, + // onrejected: (error: any) => any): BadPromiseB; + // } + // + // interface BadPromiseB { + // then( + // onfulfilled: (value: BadPromiseA) => any, + // onrejected: (error: any) => any): BadPromiseA; + // } + // + if (location) { + error( + location, + Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, + symbolToString(type.symbol)); + } + + return unknownType; + } + + // Keep track of the type we're about to unwrap to avoid bad recursive promise types. + // See the comments above for more information. + awaitedTypeStack.push(type.id); + let awaitedType = getAwaitedTypeWorker(promisedType); + awaitedTypeStack.pop(); + return awaitedType; + } + } + } } /** @@ -9691,7 +9711,7 @@ namespace ts { } // Get and return the awaited type of the return type. - return getAwaitedType(promiseType, node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); + return checkAwaitedType(promiseType, node, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); } /** Check a decorator */ @@ -10664,7 +10684,7 @@ namespace ts { else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) { if (isAsyncFunctionLike(func)) { let promisedType = getPromisedType(returnType); - let awaitedType = getAwaitedType(exprType, node.expression, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + let awaitedType = checkAwaitedType(exprType, node.expression, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); checkTypeAssignableTo(awaitedType, promisedType, node.expression); } else { diff --git a/tests/baselines/reference/awaitUnion_es6.js b/tests/baselines/reference/awaitUnion_es6.js new file mode 100644 index 00000000000..7ac556b01bc --- /dev/null +++ b/tests/baselines/reference/awaitUnion_es6.js @@ -0,0 +1,24 @@ +//// [awaitUnion_es6.ts] +declare let a: number | string; +declare let b: PromiseLike | PromiseLike; +declare let c: PromiseLike; +declare let d: number | PromiseLike; +declare let e: number | PromiseLike; +async function f() { + let await_a = await a; + let await_b = await b; + let await_c = await c; + let await_d = await d; + let await_e = await e; +} + +//// [awaitUnion_es6.js] +function f() { + return __awaiter([this], function* () { + let await_a = yield a; + let await_b = yield b; + let await_c = yield c; + let await_d = yield d; + let await_e = yield e; + }); +} diff --git a/tests/baselines/reference/awaitUnion_es6.symbols b/tests/baselines/reference/awaitUnion_es6.symbols new file mode 100644 index 00000000000..ca0b9afaf92 --- /dev/null +++ b/tests/baselines/reference/awaitUnion_es6.symbols @@ -0,0 +1,39 @@ +=== tests/cases/conformance/async/es6/awaitUnion_es6.ts === +declare let a: number | string; +>a : Symbol(a, Decl(awaitUnion_es6.ts, 0, 11)) + +declare let b: PromiseLike | PromiseLike; +>b : Symbol(b, Decl(awaitUnion_es6.ts, 1, 11)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) + +declare let c: PromiseLike; +>c : Symbol(c, Decl(awaitUnion_es6.ts, 2, 11)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) + +declare let d: number | PromiseLike; +>d : Symbol(d, Decl(awaitUnion_es6.ts, 3, 11)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) + +declare let e: number | PromiseLike; +>e : Symbol(e, Decl(awaitUnion_es6.ts, 4, 11)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) + +async function f() { +>f : Symbol(f, Decl(awaitUnion_es6.ts, 4, 53)) + + let await_a = await a; +>await_a : Symbol(await_a, Decl(awaitUnion_es6.ts, 6, 4)) + + let await_b = await b; +>await_b : Symbol(await_b, Decl(awaitUnion_es6.ts, 7, 4)) + + let await_c = await c; +>await_c : Symbol(await_c, Decl(awaitUnion_es6.ts, 8, 4)) + + let await_d = await d; +>await_d : Symbol(await_d, Decl(awaitUnion_es6.ts, 9, 4)) + + let await_e = await e; +>await_e : Symbol(await_e, Decl(awaitUnion_es6.ts, 10, 4)) +} diff --git a/tests/baselines/reference/awaitUnion_es6.types b/tests/baselines/reference/awaitUnion_es6.types new file mode 100644 index 00000000000..fc7bef8a28c --- /dev/null +++ b/tests/baselines/reference/awaitUnion_es6.types @@ -0,0 +1,44 @@ +=== tests/cases/conformance/async/es6/awaitUnion_es6.ts === +declare let a: number | string; +>a : string | number + +declare let b: PromiseLike | PromiseLike; +>b : PromiseLike | PromiseLike +>PromiseLike : PromiseLike +>PromiseLike : PromiseLike + +declare let c: PromiseLike; +>c : PromiseLike +>PromiseLike : PromiseLike + +declare let d: number | PromiseLike; +>d : number | PromiseLike +>PromiseLike : PromiseLike + +declare let e: number | PromiseLike; +>e : number | PromiseLike +>PromiseLike : PromiseLike + +async function f() { +>f : () => Promise + + let await_a = await a; +>await_a : string | number +>a : any + + let await_b = await b; +>await_b : string | number +>b : any + + let await_c = await c; +>await_c : string | number +>c : any + + let await_d = await d; +>await_d : string | number +>d : any + + let await_e = await e; +>await_e : string | number +>e : any +} diff --git a/tests/cases/conformance/async/es6/awaitUnion_es6.ts b/tests/cases/conformance/async/es6/awaitUnion_es6.ts new file mode 100644 index 00000000000..a132ae01dfd --- /dev/null +++ b/tests/cases/conformance/async/es6/awaitUnion_es6.ts @@ -0,0 +1,14 @@ +// @target: ES6 +// @noEmitHelpers: true +declare let a: number | string; +declare let b: PromiseLike | PromiseLike; +declare let c: PromiseLike; +declare let d: number | PromiseLike; +declare let e: number | PromiseLike; +async function f() { + let await_a = await a; + let await_b = await b; + let await_c = await c; + let await_d = await d; + let await_e = await e; +} \ No newline at end of file From 379d74a1bfa49acdc616846dc02e21a4f2d25891 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 18 Jun 2015 14:27:20 -0700 Subject: [PATCH 135/309] Minor function rename --- src/compiler/checker.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 83e5d3de18c..13c0aa89a9f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9551,13 +9551,13 @@ namespace ts { } function checkAwaitedType(type: Type, location?: Node, message?: DiagnosticMessage) { - return getAwaitedTypeWorker(type); + return checkAwaitedTypeWorker(type); - function getAwaitedTypeWorker(type: Type): Type { + function checkAwaitedTypeWorker(type: Type): Type { if (type.flags & TypeFlags.Union) { let types: Type[] = []; for (let constituentType of (type).types) { - types.push(getAwaitedTypeWorker(constituentType)); + types.push(checkAwaitedTypeWorker(constituentType)); } return getUnionType(types); @@ -9630,7 +9630,7 @@ namespace ts { // Keep track of the type we're about to unwrap to avoid bad recursive promise types. // See the comments above for more information. awaitedTypeStack.push(type.id); - let awaitedType = getAwaitedTypeWorker(promisedType); + let awaitedType = checkAwaitedTypeWorker(promisedType); awaitedTypeStack.pop(); return awaitedType; } From 46eb5216ffc851c4ee214f773872829a3209ab8d Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 14:32:14 -0700 Subject: [PATCH 136/309] Missed a few files in baseline-accept --- tests/baselines/reference/tsxReactEmit1.js | 4 ++-- tests/baselines/reference/tsxReactEmit3.js | 2 +- tests/baselines/reference/tsxReactEmitWhitespace.js | 8 ++++---- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/tests/baselines/reference/tsxReactEmit1.js b/tests/baselines/reference/tsxReactEmit1.js index c461987c77d..c8be861e8f1 100644 --- a/tests/baselines/reference/tsxReactEmit1.js +++ b/tests/baselines/reference/tsxReactEmit1.js @@ -68,6 +68,6 @@ var SomeClass = (function () { }; return SomeClass; })(); -var whitespace1 = React.createElement("div", null, " "); -var whitespace2 = React.createElement("div", null, " ", p, " "); +var whitespace1 = React.createElement("div", null); +var whitespace2 = React.createElement("div", null, p); var whitespace3 = React.createElement("div", null, p); diff --git a/tests/baselines/reference/tsxReactEmit3.js b/tests/baselines/reference/tsxReactEmit3.js index 9885effa48f..d31fec1c550 100644 --- a/tests/baselines/reference/tsxReactEmit3.js +++ b/tests/baselines/reference/tsxReactEmit3.js @@ -7,4 +7,4 @@ declare var Foo, Bar, baz; q s ; //// [tsxReactEmit3.js] -React.createElement(Foo, null, " ", React.createElement(Bar, null, " q "), " ", React.createElement(Bar, null), " s ", React.createElement(Bar, null), React.createElement(Bar, null)); +React.createElement(Foo, null, React.createElement(Bar, null, "q "), React.createElement(Bar, null), "s ", React.createElement(Bar, null), React.createElement(Bar, null)); diff --git a/tests/baselines/reference/tsxReactEmitWhitespace.js b/tests/baselines/reference/tsxReactEmitWhitespace.js index 69bceb7a0e9..2f32295c279 100644 --- a/tests/baselines/reference/tsxReactEmitWhitespace.js +++ b/tests/baselines/reference/tsxReactEmitWhitespace.js @@ -56,17 +56,17 @@ var p = 0; // WHITESPACE, DO NOT RUN 'FORMAT DOCUMENT' ON IT var p = 0; // Emit " " -React.createElement("div", null, " "); +React.createElement("div", null); // Emit " ", p, " " -React.createElement("div", null, " ", p, " "); +React.createElement("div", null, p); // Emit only p React.createElement("div", null, p); // Emit only p React.createElement("div", null, p); // Emit " 3" -React.createElement("div", null, " 3"); +React.createElement("div", null, "3"); // Emit " 3 " -React.createElement("div", null, " 3 "); +React.createElement("div", null, "3 "); // Emit "3" React.createElement("div", null, "3"); // Emit no args From 3db5bbf93ffc06afe707a0a9a5cb016b061404a7 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Fri, 5 Jun 2015 12:00:53 -0700 Subject: [PATCH 137/309] wrap host.getCanonicalFileName in arrow function --- src/compiler/program.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 5c40230484a..1cfe4d77b6f 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -152,7 +152,7 @@ module ts { let start = new Date().getTime(); host = host || createCompilerHost(options); - let filesByName = createFileMap(host.getCanonicalFileName); + let filesByName = createFileMap(fileName => host.getCanonicalFileName(fileName)); forEach(rootNames, name => processRootFile(name, false)); if (!seenNoDefaultLib) { From 4c1002e96beec84b24797da614bae697dc43356c Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 14:39:16 -0700 Subject: [PATCH 138/309] removed premature parser check --- src/compiler/parser.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 79ba59b94b8..28bc103e4c1 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1082,11 +1082,11 @@ namespace ts { } return token !== SyntaxKind.AsteriskToken && token !== SyntaxKind.OpenBraceToken && canFollowModifier(); } - if (token === SyntaxKind.AbstractKeyword) { - nextToken(); - // 'abstract' can precede class declarations and member function declarations. - return token === SyntaxKind.ClassKeyword || token === SyntaxKind.Identifier; - } + // if (token === SyntaxKind.AbstractKeyword) { + // nextToken(); + // // 'abstract' can precede class declarations and member function declarations. + // return token === SyntaxKind.ClassKeyword || token === SyntaxKind.Identifier; + // } if (token === SyntaxKind.DefaultKeyword) { return nextTokenIsClassOrFunction(); } From 10c8b6a089cca98c2680beba09c91b45e409f886 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 14:44:01 -0700 Subject: [PATCH 139/309] removed comment --- src/compiler/parser.ts | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 28bc103e4c1..886b73f3044 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1082,11 +1082,6 @@ namespace ts { } return token !== SyntaxKind.AsteriskToken && token !== SyntaxKind.OpenBraceToken && canFollowModifier(); } - // if (token === SyntaxKind.AbstractKeyword) { - // nextToken(); - // // 'abstract' can precede class declarations and member function declarations. - // return token === SyntaxKind.ClassKeyword || token === SyntaxKind.Identifier; - // } if (token === SyntaxKind.DefaultKeyword) { return nextTokenIsClassOrFunction(); } From 326036dbe5b7493338856b8e3f62bb4ac7df7fd2 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 15:04:05 -0700 Subject: [PATCH 140/309] write to declaration file --- src/compiler/declarationEmitter.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index 8e9f3e5c352..649e9b69a76 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -589,6 +589,9 @@ namespace ts { if (node.flags & NodeFlags.Static) { write("static "); } + if (node.flags & NodeFlags.Abstract) { + write("abstract "); + } } function writeImportEqualsDeclaration(node: ImportEqualsDeclaration) { From f578ee8e05b949fc384d81997b2b1dce6aa87f2b Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 18 Jun 2015 15:07:49 -0700 Subject: [PATCH 141/309] Adding a few tests --- tests/baselines/reference/classExpression3.js | 38 +++++++++++++++++++ .../reference/classExpression3.symbols | 26 +++++++++++++ .../reference/classExpression3.types | 33 ++++++++++++++++ tests/baselines/reference/classExpression4.js | 19 ++++++++++ .../reference/classExpression4.symbols | 17 +++++++++ .../reference/classExpression4.types | 22 +++++++++++ .../classExpressions/classExpression3.ts | 5 +++ .../classExpressions/classExpression4.ts | 6 +++ 8 files changed, 166 insertions(+) create mode 100644 tests/baselines/reference/classExpression3.js create mode 100644 tests/baselines/reference/classExpression3.symbols create mode 100644 tests/baselines/reference/classExpression3.types create mode 100644 tests/baselines/reference/classExpression4.js create mode 100644 tests/baselines/reference/classExpression4.symbols create mode 100644 tests/baselines/reference/classExpression4.types create mode 100644 tests/cases/conformance/classes/classExpressions/classExpression3.ts create mode 100644 tests/cases/conformance/classes/classExpressions/classExpression4.ts diff --git a/tests/baselines/reference/classExpression3.js b/tests/baselines/reference/classExpression3.js new file mode 100644 index 00000000000..ec9581eaf39 --- /dev/null +++ b/tests/baselines/reference/classExpression3.js @@ -0,0 +1,38 @@ +//// [classExpression3.ts] +let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; +let c = new C(); +c.a; +c.b; +c.c; + + +//// [classExpression3.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var C = (function (_super) { + __extends(class_1, _super); + function class_1() { + _super.apply(this, arguments); + this.c = 3; + } + return class_1; +})((function (_super) { + __extends(class_2, _super); + function class_2() { + _super.apply(this, arguments); + this.b = 2; + } + return class_2; +})((function () { + function class_3() { + this.a = 1; + } + return class_3; +})())); +var c = new C(); +c.a; +c.b; +c.c; diff --git a/tests/baselines/reference/classExpression3.symbols b/tests/baselines/reference/classExpression3.symbols new file mode 100644 index 00000000000..bc1b263a000 --- /dev/null +++ b/tests/baselines/reference/classExpression3.symbols @@ -0,0 +1,26 @@ +=== tests/cases/conformance/classes/classExpressions/classExpression3.ts === +let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; +>C : Symbol(C, Decl(classExpression3.ts, 0, 3)) +>a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43)) +>b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53)) +>c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63)) + +let c = new C(); +>c : Symbol(c, Decl(classExpression3.ts, 1, 3)) +>C : Symbol(C, Decl(classExpression3.ts, 0, 3)) + +c.a; +>c.a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43)) +>c : Symbol(c, Decl(classExpression3.ts, 1, 3)) +>a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43)) + +c.b; +>c.b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53)) +>c : Symbol(c, Decl(classExpression3.ts, 1, 3)) +>b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53)) + +c.c; +>c.c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63)) +>c : Symbol(c, Decl(classExpression3.ts, 1, 3)) +>c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63)) + diff --git a/tests/baselines/reference/classExpression3.types b/tests/baselines/reference/classExpression3.types new file mode 100644 index 00000000000..87423ecf0bd --- /dev/null +++ b/tests/baselines/reference/classExpression3.types @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/classExpressions/classExpression3.ts === +let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; +>C : typeof (Anonymous class) +>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof (Anonymous class) +>class extends class { a = 1 } { b = 2 } : (Anonymous class) +>class { a = 1 } : (Anonymous class) +>a : number +>1 : number +>b : number +>2 : number +>c : number +>3 : number + +let c = new C(); +>c : (Anonymous class) +>new C() : (Anonymous class) +>C : typeof (Anonymous class) + +c.a; +>c.a : number +>c : (Anonymous class) +>a : number + +c.b; +>c.b : number +>c : (Anonymous class) +>b : number + +c.c; +>c.c : number +>c : (Anonymous class) +>c : number + diff --git a/tests/baselines/reference/classExpression4.js b/tests/baselines/reference/classExpression4.js new file mode 100644 index 00000000000..c2ead0474e2 --- /dev/null +++ b/tests/baselines/reference/classExpression4.js @@ -0,0 +1,19 @@ +//// [classExpression4.ts] +let C = class { + foo() { + return new C(); + } +}; +let x = (new C).foo(); + + +//// [classExpression4.js] +var C = (function () { + function class_1() { + } + class_1.prototype.foo = function () { + return new C(); + }; + return class_1; +})(); +var x = (new C).foo(); diff --git a/tests/baselines/reference/classExpression4.symbols b/tests/baselines/reference/classExpression4.symbols new file mode 100644 index 00000000000..4df5302cecc --- /dev/null +++ b/tests/baselines/reference/classExpression4.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/classExpressions/classExpression4.ts === +let C = class { +>C : Symbol(C, Decl(classExpression4.ts, 0, 3)) + + foo() { +>foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15)) + + return new C(); +>C : Symbol(C, Decl(classExpression4.ts, 0, 3)) + } +}; +let x = (new C).foo(); +>x : Symbol(x, Decl(classExpression4.ts, 5, 3)) +>(new C).foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15)) +>C : Symbol(C, Decl(classExpression4.ts, 0, 3)) +>foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15)) + diff --git a/tests/baselines/reference/classExpression4.types b/tests/baselines/reference/classExpression4.types new file mode 100644 index 00000000000..066f169ae74 --- /dev/null +++ b/tests/baselines/reference/classExpression4.types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/classes/classExpressions/classExpression4.ts === +let C = class { +>C : typeof (Anonymous class) +>class { foo() { return new C(); }} : typeof (Anonymous class) + + foo() { +>foo : () => (Anonymous class) + + return new C(); +>new C() : (Anonymous class) +>C : typeof (Anonymous class) + } +}; +let x = (new C).foo(); +>x : (Anonymous class) +>(new C).foo() : (Anonymous class) +>(new C).foo : () => (Anonymous class) +>(new C) : (Anonymous class) +>new C : (Anonymous class) +>C : typeof (Anonymous class) +>foo : () => (Anonymous class) + diff --git a/tests/cases/conformance/classes/classExpressions/classExpression3.ts b/tests/cases/conformance/classes/classExpressions/classExpression3.ts new file mode 100644 index 00000000000..4267429f759 --- /dev/null +++ b/tests/cases/conformance/classes/classExpressions/classExpression3.ts @@ -0,0 +1,5 @@ +let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; +let c = new C(); +c.a; +c.b; +c.c; diff --git a/tests/cases/conformance/classes/classExpressions/classExpression4.ts b/tests/cases/conformance/classes/classExpressions/classExpression4.ts new file mode 100644 index 00000000000..9365475fd87 --- /dev/null +++ b/tests/cases/conformance/classes/classExpressions/classExpression4.ts @@ -0,0 +1,6 @@ +let C = class { + foo() { + return new C(); + } +}; +let x = (new C).foo(); From 053be425c708e8fe59169d0c554160fbcb6d3b6c Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Thu, 18 Jun 2015 15:25:08 -0700 Subject: [PATCH 142/309] Add tests. --- src/harness/runner.ts | 1 - .../semanticClassificationsCancellation1.ts | 15 +++++++++++++ .../syntacticClassificationsCancellation1.ts | 21 +++++++++++++++++++ 3 files changed, 36 insertions(+), 1 deletion(-) create mode 100644 tests/cases/fourslash/semanticClassificationsCancellation1.ts create mode 100644 tests/cases/fourslash/syntacticClassificationsCancellation1.ts diff --git a/src/harness/runner.ts b/src/harness/runner.ts index 42c2d5667c4..1e9c6470421 100644 --- a/src/harness/runner.ts +++ b/src/harness/runner.ts @@ -49,7 +49,6 @@ if (testConfigFile !== '') { if (!option) { continue; } - ts.sys.write("Option: " + option + "\r\n"); switch (option) { case 'compiler': runners.push(new CompilerBaselineRunner(CompilerTestType.Conformance)); diff --git a/tests/cases/fourslash/semanticClassificationsCancellation1.ts b/tests/cases/fourslash/semanticClassificationsCancellation1.ts new file mode 100644 index 00000000000..9381bef5e86 --- /dev/null +++ b/tests/cases/fourslash/semanticClassificationsCancellation1.ts @@ -0,0 +1,15 @@ +/// + +////module M { +////} +////module N { +////} + +var c = classification; +cancellation.setCancelled(1); +verifyOperationIsCancelled(() => verify.semanticClassificationsAre()); +cancellation.resetCancelled(); + +verify.semanticClassificationsAre( + c.moduleName("M"), + c.moduleName("N")); diff --git a/tests/cases/fourslash/syntacticClassificationsCancellation1.ts b/tests/cases/fourslash/syntacticClassificationsCancellation1.ts new file mode 100644 index 00000000000..f15ce5f9984 --- /dev/null +++ b/tests/cases/fourslash/syntacticClassificationsCancellation1.ts @@ -0,0 +1,21 @@ +/// + +////module M { +////} +////module N { +////} + +var c = classification; +cancellation.setCancelled(1); +verifyOperationIsCancelled(() => verify.syntacticClassificationsAre()); +cancellation.resetCancelled(); + +verify.syntacticClassificationsAre( + c.keyword("module"), + c.moduleName("M"), + c.punctuation("{"), + c.punctuation("}"), + c.keyword("module"), + c.moduleName("N"), + c.punctuation("{"), + c.punctuation("}")); From eb03ae8e7c66f32326eb2e32c5defae17455bb74 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 18 Jun 2015 15:41:19 -0700 Subject: [PATCH 143/309] Added shortcut in checkAwaitedType for isolatedModules --- src/compiler/checker.ts | 6 + .../asyncAwaitIsolatedModules_es6.errors.txt | 45 +++++++ .../asyncAwaitIsolatedModules_es6.js | 119 ++++++++++++++++++ .../es6/asyncAwaitIsolatedModules_es6.ts | 41 ++++++ 4 files changed, 211 insertions(+) create mode 100644 tests/baselines/reference/asyncAwaitIsolatedModules_es6.errors.txt create mode 100644 tests/baselines/reference/asyncAwaitIsolatedModules_es6.js create mode 100644 tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 13c0aa89a9f..5445c7f919e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9687,6 +9687,12 @@ namespace ts { // side of the `Promise` class, which would be `{ new (...): Promise }`. let promiseType = getTypeFromTypeNode(node.type); + if (promiseType === unknownType && compilerOptions.isolatedModules) { + // If we are compiling with isolatedModules, we may not be able to resolve the + // type as a value. As such, we will just return unknownType; + return unknownType; + } + let promiseConstructor = getMergedSymbol(promiseType.symbol); if (!promiseConstructor || !symbolIsValue(promiseConstructor)) { error(node, Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType)); diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.errors.txt b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.errors.txt new file mode 100644 index 00000000000..068fbb604e1 --- /dev/null +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.errors.txt @@ -0,0 +1,45 @@ +tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts(1,27): error TS2307: Cannot find module 'missing'. + + +==== tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts (1 errors) ==== + import { MyPromise } from "missing"; + ~~~~~~~~~ +!!! error TS2307: Cannot find module 'missing'. + + declare var p: Promise; + declare var mp: MyPromise; + + async function f0() { } + async function f1(): Promise { } + async function f3(): MyPromise { } + + let f4 = async function() { } + let f5 = async function(): Promise { } + let f6 = async function(): MyPromise { } + + let f7 = async () => { }; + let f8 = async (): Promise => { }; + let f9 = async (): MyPromise => { }; + let f10 = async () => p; + let f11 = async () => mp; + let f12 = async (): Promise => mp; + let f13 = async (): MyPromise => p; + + let o = { + async m1() { }, + async m2(): Promise { }, + async m3(): MyPromise { } + }; + + class C { + async m1() { } + async m2(): Promise { } + async m3(): MyPromise { } + static async m4() { } + static async m5(): Promise { } + static async m6(): MyPromise { } + } + + module M { + export async function f1() { } + } \ No newline at end of file diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js new file mode 100644 index 00000000000..7fb55df0eae --- /dev/null +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js @@ -0,0 +1,119 @@ +//// [asyncAwaitIsolatedModules_es6.ts] +import { MyPromise } from "missing"; + +declare var p: Promise; +declare var mp: MyPromise; + +async function f0() { } +async function f1(): Promise { } +async function f3(): MyPromise { } + +let f4 = async function() { } +let f5 = async function(): Promise { } +let f6 = async function(): MyPromise { } + +let f7 = async () => { }; +let f8 = async (): Promise => { }; +let f9 = async (): MyPromise => { }; +let f10 = async () => p; +let f11 = async () => mp; +let f12 = async (): Promise => mp; +let f13 = async (): MyPromise => p; + +let o = { + async m1() { }, + async m2(): Promise { }, + async m3(): MyPromise { } +}; + +class C { + async m1() { } + async m2(): Promise { } + async m3(): MyPromise { } + static async m4() { } + static async m5(): Promise { } + static async m6(): MyPromise { } +} + +module M { + export async function f1() { } +} + +//// [asyncAwaitIsolatedModules_es6.js] +var __awaiter = (this && this.__awaiter) || function (args, generator) { + var PromiseConstructor = args[1] || Promise; + return new PromiseConstructor(function (resolve, reject) { + generator = generator.call(args[0], args[2]); + function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); } + function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } } + function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } } + function step(verb, value) { + var result = generator[verb](value); + result.done ? resolve(result.value) : cast(result.value).then(onfulfill, onreject); + } + step("next", void 0); + }); +}; +function f0() { + return __awaiter([this], function* () { }); +} +function f1() { + return __awaiter([this, Promise], function* () { }); +} +function f3() { + return __awaiter([this, MyPromise], function* () { }); +} +let f4 = function () { + return __awaiter([this], function* () { }); +}; +let f5 = function () { + return __awaiter([this, Promise], function* () { }); +}; +let f6 = function () { + return __awaiter([this, MyPromise], function* () { }); +}; +let f7 = () => __awaiter([this], function* () { }); +let f8 = () => __awaiter([this, Promise], function* () { }); +let f9 = () => __awaiter([this, MyPromise], function* () { }); +let f10 = () => __awaiter([this], function* () { return p; }); +let f11 = () => __awaiter([this], function* () { return mp; }); +let f12 = () => __awaiter([this, Promise], function* () { return mp; }); +let f13 = () => __awaiter([this, MyPromise], function* () { return p; }); +let o = { + m1() { + return __awaiter([this], function* () { }); + }, + m2() { + return __awaiter([this, Promise], function* () { }); + }, + m3() { + return __awaiter([this, MyPromise], function* () { }); + } +}; +class C { + m1() { + return __awaiter([this], function* () { }); + } + m2() { + return __awaiter([this, Promise], function* () { }); + } + m3() { + return __awaiter([this, MyPromise], function* () { }); + } + static m4() { + return __awaiter([this], function* () { }); + } + static m5() { + return __awaiter([this, Promise], function* () { }); + } + static m6() { + return __awaiter([this, MyPromise], function* () { }); + } +} +var M; +(function (M) { + function f1() { + return __awaiter([this], function* () { }); + } + M.f1 = f1; +})(M || (M = {})); diff --git a/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts b/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts new file mode 100644 index 00000000000..8e2cfd8c6c5 --- /dev/null +++ b/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts @@ -0,0 +1,41 @@ +// @target: ES6 +// @isolatedModules: true +import { MyPromise } from "missing"; + +declare var p: Promise; +declare var mp: MyPromise; + +async function f0() { } +async function f1(): Promise { } +async function f3(): MyPromise { } + +let f4 = async function() { } +let f5 = async function(): Promise { } +let f6 = async function(): MyPromise { } + +let f7 = async () => { }; +let f8 = async (): Promise => { }; +let f9 = async (): MyPromise => { }; +let f10 = async () => p; +let f11 = async () => mp; +let f12 = async (): Promise => mp; +let f13 = async (): MyPromise => p; + +let o = { + async m1() { }, + async m2(): Promise { }, + async m3(): MyPromise { } +}; + +class C { + async m1() { } + async m2(): Promise { } + async m3(): MyPromise { } + static async m4() { } + static async m5(): Promise { } + static async m6(): MyPromise { } +} + +module M { + export async function f1() { } +} \ No newline at end of file From d596bb750f10e75eb8f24c6694b9ba7073fa9c98 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 16:06:50 -0700 Subject: [PATCH 144/309] declarations of abstract methods must be consecutive --- src/compiler/checker.ts | 14 +++++++++----- src/compiler/diagnosticInformationMap.generated.ts | 1 + src/compiler/diagnosticMessages.json | 4 ++++ 3 files changed, 14 insertions(+), 5 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e9977c9cd42..cb0016c9496 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9191,9 +9191,6 @@ namespace ts { return; } - // Abstract methods can't have an implementation -- in particular, they don't need one. - if (node.flags & NodeFlags.Abstract) { return; } - let seen = false; let subsequentNode = forEachChild(node.parent, c => { if (seen) { @@ -9226,7 +9223,13 @@ namespace ts { error(errorNode, Diagnostics.Constructor_implementation_is_missing); } else { - error(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); + // Report different errors regarding non-consecutive blocks of declarations depending on whether + // the node in question is abstract. + if (node.flags & NodeFlags.Abstract) { + error(errorNode, Diagnostics.All_declarations_of_an_abstract_member_function_must_be_consecutive); + } else { + error(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); + } } } @@ -9303,7 +9306,8 @@ namespace ts { }); } - if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body) { + // Abstract methods can't have an implementation -- in particular, they don't need one. + if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract) ) { reportImplementationExpectedError(lastSeenNonAmbientDeclaration); } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index a29aed6615f..e89a4e03c03 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -398,6 +398,7 @@ namespace ts { Abstract_member_function_0_on_type_1_cannot_be_called_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract member function '{0}' on type '{1}' cannot be called via super expression." }, Classes_containing_abstract_functions_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract functions must be marked abstract." }, Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'." }, + All_declarations_of_an_abstract_member_function_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract member function must be consecutive." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 859565c181a..10ff7cbae35 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1579,6 +1579,10 @@ "category": "Error", "code": 2515 }, + "All declarations of an abstract member function must be consecutive.": { + "category": "Error", + "code": 2516 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 From 868138834bdef7434a4b3fd52cfb075115b747ec Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 18 Jun 2015 16:07:10 -0700 Subject: [PATCH 145/309] added tests --- .../classAbstractConstructor.ts | 3 +++ .../classAbstractDeclarations.d.ts | 25 +++++++++++++++++ .../classAbstractInheritance.ts | 21 +++++++++++++++ .../classAbstractMethodWithImplementation.ts | 3 +++ .../classAbstractMixedWithModifiers.ts | 15 +++++++++++ .../classAbstractOverloads.ts | 24 +++++++++++++++++ .../classAbstractProperties.ts | 11 ++++++++ .../classAbstractSuperCalls.ts | 26 ++++++++++++++++++ .../classInstantiatingAbstractClass.ts | 18 +++++++++++++ .../classWithAbstractMethods.ts | 27 +++++++++++++++++++ 10 files changed, 173 insertions(+) create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractConstructor.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractDeclarations.d.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractInheritance.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractMethodWithImplementation.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractMixedWithModifiers.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractOverloads.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractProperties.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractSuperCalls.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classInstantiatingAbstractClass.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractConstructor.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractConstructor.ts new file mode 100644 index 00000000000..f53b1a3a937 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractConstructor.ts @@ -0,0 +1,3 @@ +abstract class A { + abstract constructor() {} +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractDeclarations.d.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractDeclarations.d.ts new file mode 100644 index 00000000000..14dfd1d86d8 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractDeclarations.d.ts @@ -0,0 +1,25 @@ +declare abstract class A { + abstract constructor() {} +} + +declare abstract class AA { + abstract foo(); +} + +declare abstract class BB extends AA {} + +declare class CC extends AA {} + +declare class DD extends BB {} + +declare abstract class EE extends BB {} + +declare class FF extends CC {} + +declare abstract class GG extends CC {} + +declare abstract class AAA {} + +declare abstract class BBB extends AAA {} + +declare class CCC extends AAA {} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractInheritance.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractInheritance.ts new file mode 100644 index 00000000000..ced15607f84 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractInheritance.ts @@ -0,0 +1,21 @@ +abstract class A {} + +abstract class B extends A {} + +class C extends A {} + +abstract class AA { + abstract foo(); +} + +abstract class BB extends AA {} + +class CC extends AA {} + +class DD extends BB {} + +abstract class EE extends BB {} + +class FF extends CC {} + +abstract class GG extends CC {} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractMethodWithImplementation.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractMethodWithImplementation.ts new file mode 100644 index 00000000000..432613ca04b --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractMethodWithImplementation.ts @@ -0,0 +1,3 @@ +abstract class A { + abstract foo() {} +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractMixedWithModifiers.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractMixedWithModifiers.ts new file mode 100644 index 00000000000..d3c2546ac90 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractMixedWithModifiers.ts @@ -0,0 +1,15 @@ +abstract class A { + abstract foo_a(); + + public abstract foo_b(); + protected abstract foo_c(); + private abstract foo_d(); + + abstract public foo_bb(); + abstract protected foo_cc(); + abstract private foo_dd(); + + abstract static foo_d(); + + static abstract foo_e(); +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractOverloads.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractOverloads.ts new file mode 100644 index 00000000000..c30a03f8217 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractOverloads.ts @@ -0,0 +1,24 @@ +abstract class A { + abstract foo(); + abstract foo() : number; + abstract foo(); + + abstract bar(); + bar(); + abstract bar(); + + abstract baz(); + baz(); + abstract baz(); + baz() {} + + qux(); +} + +abstract class B { + abstract foo() : number; + abstract foo(); + x : number; + abstract foo(); + abstract foo(); +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractProperties.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractProperties.ts new file mode 100644 index 00000000000..3349e878e03 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractProperties.ts @@ -0,0 +1,11 @@ +abstract class A { + abstract x : number; + public abstract y : number; + protected abstract z : number; + private abstract w : number; + + abstract foo_x() : number; + public abstract foo_y() : number; + protected abstract foo_z() : number; + private abstract foo_w() : number; +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractSuperCalls.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractSuperCalls.ts new file mode 100644 index 00000000000..90fdc5cc389 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractSuperCalls.ts @@ -0,0 +1,26 @@ + +class A { + foo() { return 1; } +} + +abstract class B extends A { + abstract foo(); + bar() { super.foo(); } + baz() { return this.foo; } +} + +class C extends B { + foo() { return 2; } + qux() { return super.foo(); } // error, super is abstract + norf() { return super.bar(); } +} + +class AA { + foo() { return 1; } + bar() { return this.foo(); } +} + +abstract class BB extends AA { + abstract foo(); + // inherits bar. But BB is abstract, so this is OK. +} diff --git a/tests/cases/conformance/classes/classDeclarations/classInstantiatingAbstractClass.ts b/tests/cases/conformance/classes/classDeclarations/classInstantiatingAbstractClass.ts new file mode 100644 index 00000000000..beb44cc7894 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classInstantiatingAbstractClass.ts @@ -0,0 +1,18 @@ + +abstract class A {} + +class B extends A {} + +abstract class C extends B {} + +new A; +new B; +new C; + +var a : A; +var b : B; +var c : C; + +a = new B; +b = new B; +c = new B; \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts b/tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts new file mode 100644 index 00000000000..e333811c67f --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts @@ -0,0 +1,27 @@ +class A { + abstract foo(); +} + +class B extends A {} + +abstract class C extends A {} + +class D extends A { + foo() {} +} + +abstract class E extends A { + foo() {} +} + +abstract class AA { + abstract foo(); +} + +class BB extends AA {} + +abstract class CC extends AA {} + +class DD extends AA { + foo() {} +} \ No newline at end of file From b0750c25b2ff5750c48db44e7e11e7a62d50d365 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 18 Jun 2015 18:37:32 -0700 Subject: [PATCH 146/309] Fix emit for boolean attributes --- src/compiler/emitter.ts | 7 ++++++- tests/baselines/reference/tsxReactEmit1.js | 8 ++++---- tests/baselines/reference/tsxReactEmit1.symbols | 12 +++++++----- tests/baselines/reference/tsxReactEmit1.types | 10 ++++++---- tests/cases/conformance/jsx/tsxReactEmit1.tsx | 4 ++-- 5 files changed, 25 insertions(+), 16 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 265690cd680..588375febc5 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1148,7 +1148,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { function emitJsxAttribute(node: JsxAttribute) { emitAttributeName(node.name); write(': '); - emit(node.initializer); + if (node.initializer) { + emit(node.initializer); + } + else { + write('true'); + } } function emitJsxElement(openingNode: JsxOpeningElement|JsxSelfClosingElement, children?: JsxChild[]) { diff --git a/tests/baselines/reference/tsxReactEmit1.js b/tests/baselines/reference/tsxReactEmit1.js index c8be861e8f1..b6c5fd96183 100644 --- a/tests/baselines/reference/tsxReactEmit1.js +++ b/tests/baselines/reference/tsxReactEmit1.js @@ -13,13 +13,13 @@ var selfClosed3 =
; var selfClosed4 =
; var selfClosed5 =
; var selfClosed6 =
; -var selfClosed7 =
; +var selfClosed7 =
; var openClosed1 =
; var openClosed2 =
foo
; var openClosed3 =
{p}
; var openClosed4 =
{p < p}
; -var openClosed5 =
{p > p}
; +var openClosed5 =
{p > p}
; class SomeClass { f() { @@ -48,12 +48,12 @@ var selfClosed3 = React.createElement("div", {x: '1'}); var selfClosed4 = React.createElement("div", {x: "1", y: '0'}); var selfClosed5 = React.createElement("div", {x: 0, y: '0'}); var selfClosed6 = React.createElement("div", {x: "1", y: '0'}); -var selfClosed7 = React.createElement("div", {x: p, y: 'p'}); +var selfClosed7 = React.createElement("div", {x: p, y: 'p', b: true}); var openClosed1 = React.createElement("div", null); var openClosed2 = React.createElement("div", {n: 'm'}, "foo"); var openClosed3 = React.createElement("div", {n: 'm'}, p); var openClosed4 = React.createElement("div", {n: 'm'}, p < p); -var openClosed5 = React.createElement("div", {n: 'm'}, p > p); +var openClosed5 = React.createElement("div", {n: 'm', b: true}, p > p); var SomeClass = (function () { function SomeClass() { } diff --git a/tests/baselines/reference/tsxReactEmit1.symbols b/tests/baselines/reference/tsxReactEmit1.symbols index f35a7872915..60fa5e70b0a 100644 --- a/tests/baselines/reference/tsxReactEmit1.symbols +++ b/tests/baselines/reference/tsxReactEmit1.symbols @@ -48,11 +48,12 @@ var selfClosed6 =
; >x : Symbol(unknown) >y : Symbol(unknown) -var selfClosed7 =
; +var selfClosed7 =
; >selfClosed7 : Symbol(selfClosed7, Decl(tsxReactEmit1.tsx, 14, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) >x : Symbol(unknown) >y : Symbol(unknown) +>b : Symbol(unknown) var openClosed1 =
; >openClosed1 : Symbol(openClosed1, Decl(tsxReactEmit1.tsx, 16, 3)) @@ -75,15 +76,16 @@ var openClosed4 =
{p < p}
; >p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) >p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) -var openClosed5 =
{p > p}
; +var openClosed5 =
{p > p}
; >openClosed5 : Symbol(openClosed5, Decl(tsxReactEmit1.tsx, 20, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) >n : Symbol(unknown) +>b : Symbol(unknown) >p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) >p : Symbol(p, Decl(tsxReactEmit1.tsx, 7, 3)) class SomeClass { ->SomeClass : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 43)) +>SomeClass : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 45)) f() { >f : Symbol(f, Decl(tsxReactEmit1.tsx, 22, 17)) @@ -91,7 +93,7 @@ class SomeClass { var rewrites1 =
{() => this}
; >rewrites1 : Symbol(rewrites1, Decl(tsxReactEmit1.tsx, 24, 5)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) ->this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 43)) +>this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 45)) var rewrites2 =
{[p, ...p, p]}
; >rewrites2 : Symbol(rewrites2, Decl(tsxReactEmit1.tsx, 25, 5)) @@ -109,7 +111,7 @@ class SomeClass { >rewrites4 : Symbol(rewrites4, Decl(tsxReactEmit1.tsx, 28, 5)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit1.tsx, 1, 22)) >a : Symbol(unknown) ->this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 43)) +>this : Symbol(SomeClass, Decl(tsxReactEmit1.tsx, 20, 45)) var rewrites5 =
; >rewrites5 : Symbol(rewrites5, Decl(tsxReactEmit1.tsx, 29, 5)) diff --git a/tests/baselines/reference/tsxReactEmit1.types b/tests/baselines/reference/tsxReactEmit1.types index d58316b14cf..d23cad4560a 100644 --- a/tests/baselines/reference/tsxReactEmit1.types +++ b/tests/baselines/reference/tsxReactEmit1.types @@ -54,13 +54,14 @@ var selfClosed6 =
; >x : any >y : any -var selfClosed7 =
; +var selfClosed7 =
; >selfClosed7 : JSX.Element ->
: JSX.Element +>
: JSX.Element >div : any >x : any >p : any >y : any +>b : any var openClosed1 =
; >openClosed1 : JSX.Element @@ -93,11 +94,12 @@ var openClosed4 =
{p < p}
; >p : any >div : any -var openClosed5 =
{p > p}
; +var openClosed5 =
{p > p}
; >openClosed5 : JSX.Element ->
{p > p}
: JSX.Element +>
{p > p}
: JSX.Element >div : any >n : any +>b : any >p > p : boolean >p : any >p : any diff --git a/tests/cases/conformance/jsx/tsxReactEmit1.tsx b/tests/cases/conformance/jsx/tsxReactEmit1.tsx index 8ca8ef1ff40..b8f14b0ba22 100644 --- a/tests/cases/conformance/jsx/tsxReactEmit1.tsx +++ b/tests/cases/conformance/jsx/tsxReactEmit1.tsx @@ -14,13 +14,13 @@ var selfClosed3 =
; var selfClosed4 =
; var selfClosed5 =
; var selfClosed6 =
; -var selfClosed7 =
; +var selfClosed7 =
; var openClosed1 =
; var openClosed2 =
foo
; var openClosed3 =
{p}
; var openClosed4 =
{p < p}
; -var openClosed5 =
{p > p}
; +var openClosed5 =
{p > p}
; class SomeClass { f() { From 388e73f49f9857f2ae2783af0d0812ed83952ad1 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Fri, 19 Jun 2015 11:30:34 -0700 Subject: [PATCH 147/309] Fix React emit for spread attributes when they are the first attribute --- src/compiler/emitter.ts | 5 +++++ tests/baselines/reference/tsxReactEmit2.js | 6 +++--- tests/baselines/reference/tsxReactEmit4.errors.txt | 4 +++- tests/baselines/reference/tsxReactEmit4.js | 6 +++++- tests/cases/conformance/jsx/tsxReactEmit4.tsx | 3 +++ 5 files changed, 19 insertions(+), 5 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 588375febc5..2b8faa8d79e 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1178,6 +1178,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { let haveOpenedObjectLiteral = false; for (var i = 0; i < attrs.length; i++) { if (attrs[i].kind === SyntaxKind.JsxSpreadAttribute) { + // If this is the first argument, we need to emit a {} as the first argument + if(i === 0) { + write('{}, '); + } + if (haveOpenedObjectLiteral) { write('}'); haveOpenedObjectLiteral = false; diff --git a/tests/baselines/reference/tsxReactEmit2.js b/tests/baselines/reference/tsxReactEmit2.js index c19d9958ad4..f4a12946ed9 100644 --- a/tests/baselines/reference/tsxReactEmit2.js +++ b/tests/baselines/reference/tsxReactEmit2.js @@ -16,8 +16,8 @@ var spreads5 =
{p2}
; //// [tsxReactEmit2.js] var p1, p2, p3; -var spreads1 = React.createElement("div", React.__spread(p1), p2); -var spreads2 = React.createElement("div", React.__spread(p1), p2); +var spreads1 = React.createElement("div", React.__spread({}, p1), p2); +var spreads2 = React.createElement("div", React.__spread({}, p1), p2); var spreads3 = React.createElement("div", React.__spread({x: p3}, p1), p2); -var spreads4 = React.createElement("div", React.__spread(p1, {x: p3}), p2); +var spreads4 = React.createElement("div", React.__spread({}, p1, {x: p3}), p2); var spreads5 = React.createElement("div", React.__spread({x: p2}, p1, {y: p3}), p2); diff --git a/tests/baselines/reference/tsxReactEmit4.errors.txt b/tests/baselines/reference/tsxReactEmit4.errors.txt index 82cacd39e28..00b7cb8d019 100644 --- a/tests/baselines/reference/tsxReactEmit4.errors.txt +++ b/tests/baselines/reference/tsxReactEmit4.errors.txt @@ -17,4 +17,6 @@ tests/cases/conformance/jsx/tsxReactEmit4.tsx(11,5): error TS2304: Cannot find n !!! error TS2304: Cannot find name 'blah'.
; - \ No newline at end of file + + // Should emit React.__spread({}, p, {x: 0}) + var spread1 =
; \ No newline at end of file diff --git a/tests/baselines/reference/tsxReactEmit4.js b/tests/baselines/reference/tsxReactEmit4.js index b162b17ad7f..2254c4dd651 100644 --- a/tests/baselines/reference/tsxReactEmit4.js +++ b/tests/baselines/reference/tsxReactEmit4.js @@ -12,8 +12,12 @@ var openClosed1 =
{blah}
; - + +// Should emit React.__spread({}, p, {x: 0}) +var spread1 =
; //// [tsxReactEmit4.js] var p; var openClosed1 = React.createElement("div", null, blah); +// Should emit React.__spread({}, p, {x: 0}) +var spread1 = React.createElement("div", React.__spread({}, p, {x: 0})); diff --git a/tests/cases/conformance/jsx/tsxReactEmit4.tsx b/tests/cases/conformance/jsx/tsxReactEmit4.tsx index 0987b89c978..f007c35c24a 100644 --- a/tests/cases/conformance/jsx/tsxReactEmit4.tsx +++ b/tests/cases/conformance/jsx/tsxReactEmit4.tsx @@ -13,3 +13,6 @@ var openClosed1 =
{blah}
; + +// Should emit React.__spread({}, p, {x: 0}) +var spread1 =
; \ No newline at end of file From 5e672b77918ecf0c76e47957f60ab570894e3984 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Fri, 12 Jun 2015 13:49:38 -0700 Subject: [PATCH 148/309] Don't log by default. On the managed side tracing is disabled by default anyways. By logging we still cause tons of allocations of strings on the managed side. These then cause expensive GCs which can pause editing. --- src/services/shims.ts | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/src/services/shims.ts b/src/services/shims.ts index 004393fb3b5..d6f9f7a968a 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -246,16 +246,22 @@ module ts { export class LanguageServiceShimHostAdapter implements LanguageServiceHost { private files: string[]; + private loggingEnabled = false; + private tracingEnabled = false; constructor(private shimHost: LanguageServiceShimHost) { } public log(s: string): void { - this.shimHost.log(s); + if (this.loggingEnabled) { + this.shimHost.log(s); + } } public trace(s: string): void { - this.shimHost.trace(s); + if (this.tracingEnabled) { + this.shimHost.trace(s); + } } public error(s: string): void { @@ -349,15 +355,15 @@ module ts { } } - function simpleForwardCall(logger: Logger, actionDescription: string, action: () => any, noPerfLogging: boolean): any { - if (!noPerfLogging) { + function simpleForwardCall(logger: Logger, actionDescription: string, action: () => any, logPerformance: boolean): any { + if (logPerformance) { logger.log(actionDescription); var start = Date.now(); } var result = action(); - if (!noPerfLogging) { + if (logPerformance) { var end = Date.now(); logger.log(actionDescription + " completed in " + (end - start) + " msec"); if (typeof (result) === "string") { @@ -372,9 +378,9 @@ module ts { return result; } - function forwardJSONCall(logger: Logger, actionDescription: string, action: () => any, noPerfLogging: boolean): string { + function forwardJSONCall(logger: Logger, actionDescription: string, action: () => any, logPerformance: boolean): string { try { - var result = simpleForwardCall(logger, actionDescription, action, noPerfLogging); + var result = simpleForwardCall(logger, actionDescription, action, logPerformance); return JSON.stringify({ result: result }); } catch (err) { @@ -413,6 +419,7 @@ module ts { class LanguageServiceShimObject extends ShimBase implements LanguageServiceShim { private logger: Logger; + private logPerformance = false; constructor(factory: ShimFactory, private host: LanguageServiceShimHost, @@ -422,7 +429,7 @@ module ts { } public forwardJSONCall(actionDescription: string, action: () => any): string { - return forwardJSONCall(this.logger, actionDescription, action, /*noPerfLogging:*/ false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); } /// DISPOSE @@ -811,6 +818,7 @@ module ts { class ClassifierShimObject extends ShimBase implements ClassifierShim { public classifier: Classifier; + private logPerformance = false; constructor(factory: ShimFactory, private logger: Logger) { super(factory); @@ -820,7 +828,7 @@ module ts { public getEncodedLexicalClassifications(text: string, lexState: EndOfLineState, syntacticClassifierAbsent?: boolean): string { return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", () => convertClassifications(this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)), - /*noPerfLogging:*/ true); + this.logPerformance); } /// COLORIZATION @@ -838,13 +846,14 @@ module ts { } class CoreServicesShimObject extends ShimBase implements CoreServicesShim { + private logPerformance = false; constructor(factory: ShimFactory, public logger: Logger, private host: CoreServicesShimHostAdapter) { super(factory); } private forwardJSONCall(actionDescription: string, action: () => any): any { - return forwardJSONCall(this.logger, actionDescription, action, /*noPerfLogging:*/ false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); } public getPreProcessedFileInfo(fileName: string, sourceTextSnapshot: IScriptSnapshot): string { From 8f1790de4ad05a86f94dffb6586a42b090e8e7e3 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Fri, 19 Jun 2015 15:34:19 -0700 Subject: [PATCH 149/309] Simplified checkClassPropertyAccess -- fixed bug in super access --- src/compiler/checker.ts | 107 +++++++++++------- .../diagnosticInformationMap.generated.ts | 6 +- src/compiler/diagnosticMessages.json | 6 +- 3 files changed, 71 insertions(+), 48 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index cb0016c9496..741863f0334 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6658,42 +6658,91 @@ namespace ts { return s.valueDeclaration ? getCombinedNodeFlags(s.valueDeclaration) : s.flags & SymbolFlags.Prototype ? NodeFlags.Public | NodeFlags.Static : 0; } - function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol) { + /** + * Check whether the requested property access is valid. + * Returns true if node passed the check, and false otherwise. + * @param node The node to be checked. + * @param left The left hand side of the property access (eg: the super is `super.*`). + * @param type The type of left. + * @param prop The symbol for the right hand side of the property access. + */ + function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol) : boolean { let flags = getDeclarationFlagsFromSymbol(prop); - // Public properties are always accessible - if (!(flags & (NodeFlags.Private | NodeFlags.Protected))) { - return; + let declaringClass : InterfaceType; + + if (left.kind === SyntaxKind.SuperKeyword) { + let errorNode = (node).name ? + (node).name : + (node).right; + + // TS 1.0 spec (April 2014): 4.8.2 + // - In a constructor, instance member function, instance member accessor, or + // instance member variable initializer where this references a derived class instance, + // a super property access is permitted and must specify a public instance member function of the base class. + // - In a static member function or static member accessor + // where this references the constructor function object of a derived class, + // a super property access is permitted and must specify a public static member function of the base class. + if (getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { // prop is a property access + + error(errorNode, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); + return false; + } + + // In a super call, the member function can be accessed if the method is not abstract. + // Note that a member cannot be private and abstract -- this is checked elsewhere. + if (flags & NodeFlags.Abstract) { + // Get the declaring the class instance type for the error message. + declaringClass = getDeclaredTypeOfSymbol(prop.parent); + + error(errorNode, Diagnostics.Abstract_member_function_0_on_type_1_cannot_be_called_via_super_expression, symbolToString(prop), typeToString(declaringClass)); + return false; + } } - // Property is known to be private or protected at this point - // Get the declaring and enclosing class instance types + + // Public properties are otherwise accessible. + if (!(flags & (NodeFlags.Private | NodeFlags.Protected))) { + return true; + } + + // Property is known to be private or protected at this point. + + // Get the declaring and enclosing class instance types. let enclosingClassDeclaration = getAncestor(node, SyntaxKind.ClassDeclaration); + // Debug.assert(!!enclosingClassDeclaration, "Should be defined"); let enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; - let declaringClass = getDeclaredTypeOfSymbol(prop.parent); + declaringClass = getDeclaredTypeOfSymbol(prop.parent); + // Private property is accessible if declaring and enclosing class are the same if (flags & NodeFlags.Private) { if (declaringClass !== enclosingClass) { error(node, Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(declaringClass)); + return false; } - return; + return true; } + // Property is known to be protected at this point + // All protected properties of a supertype are accessible in a super access if (left.kind === SyntaxKind.SuperKeyword) { - return; + return true; } // A protected property is accessible in the declaring class and classes derived from it if (!enclosingClass || !hasBaseType(enclosingClass, declaringClass)) { error(node, Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(declaringClass)); - return; + return false; } // No further restrictions for static properties if (flags & NodeFlags.Static) { - return; + return true; } // An instance property must be accessed through an instance of the enclosing class + // TODO: why is the first part of this check here? if (!(getTargetType(type).flags & (TypeFlags.Class | TypeFlags.Interface) && hasBaseType(type, enclosingClass))) { error(node, Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1, symbolToString(prop), typeToString(enclosingClass)); + return false; } + return true; } function checkPropertyAccessExpression(node: PropertyAccessExpression) { @@ -6722,31 +6771,12 @@ namespace ts { } return unknownType; } + + // TODO: Why is this line here? getNodeLinks(node).resolvedSymbol = prop; + if (prop.parent && prop.parent.flags & SymbolFlags.Class) { - // TS 1.0 spec (April 2014): 4.8.2 - // - In a constructor, instance member function, instance member accessor, or - // instance member variable initializer where this references a derived class instance, - // a super property access is permitted and must specify a public instance member function of the base class. - // - In a static member function or static member accessor - // where this references the constructor function object of a derived class, - // a super property access is permitted and must specify a public static member function of the base class. - if (left.kind === SyntaxKind.SuperKeyword) { - if (getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { - error(right, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); - } - - // Abstract methods cannot be accessed through super property accesses. Eg: - // class A { abstract foo(); } - // class B extends A { bar() { super.foo();} } - // is illegal. - if (getDeclarationFlagsFromSymbol(prop) & NodeFlags.Abstract) { - error(right, Diagnostics.Abstract_member_function_0_on_type_1_cannot_be_called_via_super_expression, declarationNameToString(right), typeToString(type)); - } - } - else { - checkClassPropertyAccess(node, left, type, prop); - } + checkClassPropertyAccess(node, left, type, prop); } return getTypeOfSymbol(prop); } @@ -6760,14 +6790,7 @@ namespace ts { if (type !== unknownType && !isTypeAny(type)) { let prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & SymbolFlags.Class) { - if (left.kind === SyntaxKind.SuperKeyword && getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { - return false; - } - else { - let modificationCount = diagnostics.getModificationCount(); - checkClassPropertyAccess(node, left, type, prop); - return diagnostics.getModificationCount() === modificationCount; - } + return checkClassPropertyAccess(node, left, type, prop); } } return true; diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index e89a4e03c03..071570482df 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -231,10 +231,10 @@ namespace ts { this_cannot_be_referenced_in_a_static_property_initializer: { code: 2334, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in a static property initializer." }, super_can_only_be_referenced_in_a_derived_class: { code: 2335, category: DiagnosticCategory.Error, key: "'super' can only be referenced in a derived class." }, super_cannot_be_referenced_in_constructor_arguments: { code: 2336, category: DiagnosticCategory.Error, key: "'super' cannot be referenced in constructor arguments." }, - Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: { code: 2337, category: DiagnosticCategory.Error, key: "Super calls are not permitted outside constructors or in nested functions inside constructors" }, - super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: { code: 2338, category: DiagnosticCategory.Error, key: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class" }, + Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: { code: 2337, category: DiagnosticCategory.Error, key: "Super calls are not permitted outside constructors or in nested functions inside constructors." }, + super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: { code: 2338, category: DiagnosticCategory.Error, key: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class." }, Property_0_does_not_exist_on_type_1: { code: 2339, category: DiagnosticCategory.Error, key: "Property '{0}' does not exist on type '{1}'." }, - Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: { code: 2340, category: DiagnosticCategory.Error, key: "Only public and protected methods of the base class are accessible via the 'super' keyword" }, + Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: { code: 2340, category: DiagnosticCategory.Error, key: "Only public and protected methods of the base class are accessible via the 'super' keyword." }, Property_0_is_private_and_only_accessible_within_class_1: { code: 2341, category: DiagnosticCategory.Error, key: "Property '{0}' is private and only accessible within class '{1}'." }, An_index_expression_argument_must_be_of_type_string_number_symbol_or_any: { code: 2342, category: DiagnosticCategory.Error, key: "An index expression argument must be of type 'string', 'number', 'symbol, or 'any'." }, Type_0_does_not_satisfy_the_constraint_1: { code: 2344, category: DiagnosticCategory.Error, key: "Type '{0}' does not satisfy the constraint '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 10ff7cbae35..85c8e46c246 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -911,11 +911,11 @@ "category": "Error", "code": 2336 }, - "Super calls are not permitted outside constructors or in nested functions inside constructors": { + "Super calls are not permitted outside constructors or in nested functions inside constructors.": { "category": "Error", "code": 2337 }, - "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class": { + "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.": { "category": "Error", "code": 2338 }, @@ -923,7 +923,7 @@ "category": "Error", "code": 2339 }, - "Only public and protected methods of the base class are accessible via the 'super' keyword": { + "Only public and protected methods of the base class are accessible via the 'super' keyword.": { "category": "Error", "code": 2340 }, From df3560f6a7f9dc3a8856c305a5d7bfb58c0f3917 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Fri, 19 Jun 2015 15:41:33 -0700 Subject: [PATCH 150/309] moved tests, added a test --- .../classAbstractConstructor.ts | 0 .../classAbstractDeclarations.d.ts | 0 .../classAbstractInheritance.ts | 0 .../classAbstractMethodWithImplementation.ts | 0 .../classAbstractMixedWithModifiers.ts | 0 .../classAbstractOverloads.ts | 0 .../classAbstractProperties.ts | 0 .../classAbstractSuperCalls.ts | 0 .../classAbstractUsingAbstractMethod.ts | 17 +++++++++++++++++ .../classInstantiatingAbstractClass.ts | 10 +++++++++- 10 files changed, 26 insertions(+), 1 deletion(-) rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classAbstractConstructor.ts (100%) rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classAbstractDeclarations.d.ts (100%) rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classAbstractInheritance.ts (100%) rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classAbstractMethodWithImplementation.ts (100%) rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classAbstractMixedWithModifiers.ts (100%) rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classAbstractOverloads.ts (100%) rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classAbstractProperties.ts (100%) rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classAbstractSuperCalls.ts (100%) create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts rename tests/cases/conformance/classes/classDeclarations/{ => classAbstractKeyword}/classInstantiatingAbstractClass.ts (56%) diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractConstructor.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractConstructor.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractDeclarations.d.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractDeclarations.d.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractInheritance.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractInheritance.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractMethodWithImplementation.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractMethodWithImplementation.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractMixedWithModifiers.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractMixedWithModifiers.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractOverloads.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractOverloads.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractProperties.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractProperties.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractSuperCalls.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractSuperCalls.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts new file mode 100644 index 00000000000..8561fa2ce15 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts @@ -0,0 +1,17 @@ +abstract class A { + abstract foo() : number; +} + +class B extends A { + foo() { return 1; } +} + +abstract class C extends A { + abstract foo() : number; +} + +var a = new B; +a.foo(); + +a = new C; // error, cannot instantiate abstract class. +a.foo(); \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classInstantiatingAbstractClass.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts similarity index 56% rename from tests/cases/conformance/classes/classDeclarations/classInstantiatingAbstractClass.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts index beb44cc7894..d60a39a3f2c 100644 --- a/tests/cases/conformance/classes/classDeclarations/classInstantiatingAbstractClass.ts +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts @@ -15,4 +15,12 @@ var c : C; a = new B; b = new B; -c = new B; \ No newline at end of file +c = new B; + +module M { + export abstract class A {} +} + +import myA = M.A; + +var aa = new myA; From b448310058e283071bf8009f31fd61e3711488d0 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Fri, 19 Jun 2015 15:45:18 -0700 Subject: [PATCH 151/309] accepted baselines --- tests/baselines/reference/APISample_linter.js | 146 +++++++++--------- .../reference/abstractClass1.errors.txt | 112 +++++++------- tests/baselines/reference/abstractClass1.js | 144 ++++++++--------- .../reference/abstractClassIdentifierName.js | 20 +-- .../abstractClassIdentifierName.symbols | 16 +- .../abstractClassIdentifierName.types | 16 +- .../reference/abstractIdentifierNameStrict.js | 18 +-- .../abstractIdentifierNameStrict.symbols | 22 +-- .../abstractIdentifierNameStrict.types | 30 ++-- .../abstractInterfaceIdentifierName.js | 8 +- .../abstractInterfaceIdentifierName.symbols | 18 +-- .../abstractInterfaceIdentifierName.types | 18 +-- .../classAbstractConstructor.errors.txt | 12 ++ .../reference/classAbstractConstructor.js | 11 ++ .../classAbstractDeclarations.d.errors.txt | 52 +++++++ .../classAbstractInheritance.errors.txt | 39 +++++ .../reference/classAbstractInheritance.js | 96 ++++++++++++ ...bstractMethodWithImplementation.errors.txt | 9 ++ .../classAbstractMethodWithImplementation.js | 12 ++ ...classAbstractMixedWithModifiers.errors.txt | 36 +++++ .../classAbstractMixedWithModifiers.js | 23 +++ .../classAbstractOverloads.errors.txt | 42 +++++ .../reference/classAbstractOverloads.js | 38 +++++ .../classAbstractProperties.errors.txt | 29 ++++ .../reference/classAbstractProperties.js | 19 +++ .../classAbstractSuperCalls.errors.txt | 33 ++++ .../reference/classAbstractSuperCalls.js | 75 +++++++++ ...lassAbstractUsingAbstractMethod.errors.txt | 23 +++ .../classAbstractUsingAbstractMethod.js | 50 ++++++ ...classInstantiatingAbstractClass.errors.txt | 39 +++++ .../classInstantiatingAbstractClass.js | 75 +++++++++ .../classWithAbstractMethods.errors.txt | 46 ++++++ .../reference/classWithAbstractMethods.js | 98 ++++++++++++ .../computedPropertyNames30_ES5.errors.txt | 4 +- .../computedPropertyNames30_ES6.errors.txt | 4 +- .../decoratorOnClassMethod12.errors.txt | 4 +- ...lassConstructorWithoutSuperCall.errors.txt | 8 +- ...perCallsInNonConstructorMembers.errors.txt | 32 ++-- .../emitThisInSuperMethodCall.errors.txt | 12 +- .../reference/errorSuperCalls.errors.txt | 16 +- .../errorSuperPropertyAccess.errors.txt | 64 ++++---- .../illegalSuperCallsInConstructor.errors.txt | 20 +-- .../reference/parserAstSpans1.errors.txt | 8 +- ...vateInstanceMemberAccessibility.errors.txt | 12 +- ...opertyAccessibleWithinSubclass3.errors.txt | 4 +- ...ctedInstanceMemberAccessibility.errors.txt | 4 +- ...opertyAccessibleWithinSubclass2.errors.txt | 8 +- .../reference/superAccess.errors.txt | 8 +- .../reference/superAccess2.errors.txt | 4 +- .../superCallOutsideConstructor.errors.txt | 12 +- .../reference/superErrors.errors.txt | 20 +-- .../reference/superInLambdas.errors.txt | 8 +- .../reference/superPropertyAccess.errors.txt | 20 +-- .../reference/superPropertyAccess1.errors.txt | 12 +- .../reference/superPropertyAccess2.errors.txt | 4 +- ...ect-literal-getters-and-setters.errors.txt | 4 +- 56 files changed, 1287 insertions(+), 430 deletions(-) create mode 100644 tests/baselines/reference/classAbstractConstructor.errors.txt create mode 100644 tests/baselines/reference/classAbstractConstructor.js create mode 100644 tests/baselines/reference/classAbstractDeclarations.d.errors.txt create mode 100644 tests/baselines/reference/classAbstractInheritance.errors.txt create mode 100644 tests/baselines/reference/classAbstractInheritance.js create mode 100644 tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt create mode 100644 tests/baselines/reference/classAbstractMethodWithImplementation.js create mode 100644 tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt create mode 100644 tests/baselines/reference/classAbstractMixedWithModifiers.js create mode 100644 tests/baselines/reference/classAbstractOverloads.errors.txt create mode 100644 tests/baselines/reference/classAbstractOverloads.js create mode 100644 tests/baselines/reference/classAbstractProperties.errors.txt create mode 100644 tests/baselines/reference/classAbstractProperties.js create mode 100644 tests/baselines/reference/classAbstractSuperCalls.errors.txt create mode 100644 tests/baselines/reference/classAbstractSuperCalls.js create mode 100644 tests/baselines/reference/classAbstractUsingAbstractMethod.errors.txt create mode 100644 tests/baselines/reference/classAbstractUsingAbstractMethod.js create mode 100644 tests/baselines/reference/classInstantiatingAbstractClass.errors.txt create mode 100644 tests/baselines/reference/classInstantiatingAbstractClass.js create mode 100644 tests/baselines/reference/classWithAbstractMethods.errors.txt create mode 100644 tests/baselines/reference/classWithAbstractMethods.js diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js index bdf8a7ed1ca..5c2a8953a61 100644 --- a/tests/baselines/reference/APISample_linter.js +++ b/tests/baselines/reference/APISample_linter.js @@ -1,67 +1,67 @@ //// [APISample_linter.ts] - -/* - * Note: This test is a public API sample. The sample sources can be found - at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter - * Please log a "breaking change" issue for any API breaking change affecting this issue - */ - -declare var process: any; -declare var console: any; -declare var readFileSync: any; - -import * as ts from "typescript"; - -export function delint(sourceFile: ts.SourceFile) { - delintNode(sourceFile); - - function delintNode(node: ts.Node) { - switch (node.kind) { - case ts.SyntaxKind.ForStatement: - case ts.SyntaxKind.ForInStatement: - case ts.SyntaxKind.WhileStatement: - case ts.SyntaxKind.DoStatement: - if ((node).statement.kind !== ts.SyntaxKind.Block) { - report(node, "A looping statement's contents should be wrapped in a block body."); - } - break; - - case ts.SyntaxKind.IfStatement: - let ifStatement = (node); - if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) { - report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); - } - if (ifStatement.elseStatement && - ifStatement.elseStatement.kind !== ts.SyntaxKind.Block && - ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) { - report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); - } - break; - - case ts.SyntaxKind.BinaryExpression: - let op = (node).operatorToken.kind; - if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) { - report(node, "Use '===' and '!=='.") - } - break; - } - - ts.forEachChild(node, delintNode); - } - - function report(node: ts.Node, message: string) { - let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart()); - console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`); - } -} - -const fileNames = process.argv.slice(2); -fileNames.forEach(fileName => { - // Parse a file - let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true); - - // delint it - delint(sourceFile); + +/* + * Note: This test is a public API sample. The sample sources can be found + at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter + * Please log a "breaking change" issue for any API breaking change affecting this issue + */ + +declare var process: any; +declare var console: any; +declare var readFileSync: any; + +import * as ts from "typescript"; + +export function delint(sourceFile: ts.SourceFile) { + delintNode(sourceFile); + + function delintNode(node: ts.Node) { + switch (node.kind) { + case ts.SyntaxKind.ForStatement: + case ts.SyntaxKind.ForInStatement: + case ts.SyntaxKind.WhileStatement: + case ts.SyntaxKind.DoStatement: + if ((node).statement.kind !== ts.SyntaxKind.Block) { + report(node, "A looping statement's contents should be wrapped in a block body."); + } + break; + + case ts.SyntaxKind.IfStatement: + let ifStatement = (node); + if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) { + report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); + } + if (ifStatement.elseStatement && + ifStatement.elseStatement.kind !== ts.SyntaxKind.Block && + ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) { + report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); + } + break; + + case ts.SyntaxKind.BinaryExpression: + let op = (node).operatorToken.kind; + if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) { + report(node, "Use '===' and '!=='.") + } + break; + } + + ts.forEachChild(node, delintNode); + } + + function report(node: ts.Node, message: string) { + let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart()); + console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`); + } +} + +const fileNames = process.argv.slice(2); +fileNames.forEach(fileName => { + // Parse a file + let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true); + + // delint it + delint(sourceFile); }); //// [APISample_linter.js] @@ -75,26 +75,26 @@ function delint(sourceFile) { delintNode(sourceFile); function delintNode(node) { switch (node.kind) { - case 189 /* ForStatement */: - case 190 /* ForInStatement */: - case 188 /* WhileStatement */: - case 187 /* DoStatement */: - if (node.statement.kind !== 182 /* Block */) { + case 190 /* ForStatement */: + case 191 /* ForInStatement */: + case 189 /* WhileStatement */: + case 188 /* DoStatement */: + if (node.statement.kind !== 183 /* Block */) { report(node, "A looping statement's contents should be wrapped in a block body."); } break; - case 186 /* IfStatement */: + case 187 /* IfStatement */: var ifStatement = node; - if (ifStatement.thenStatement.kind !== 182 /* Block */) { + if (ifStatement.thenStatement.kind !== 183 /* Block */) { report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); } if (ifStatement.elseStatement && - ifStatement.elseStatement.kind !== 182 /* Block */ && - ifStatement.elseStatement.kind !== 186 /* IfStatement */) { + ifStatement.elseStatement.kind !== 183 /* Block */ && + ifStatement.elseStatement.kind !== 187 /* IfStatement */) { report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); } break; - case 172 /* BinaryExpression */: + case 173 /* BinaryExpression */: var op = node.operatorToken.kind; if (op === 28 /* EqualsEqualsToken */ || op == 29 /* ExclamationEqualsToken */) { report(node, "Use '===' and '!=='."); diff --git a/tests/baselines/reference/abstractClass1.errors.txt b/tests/baselines/reference/abstractClass1.errors.txt index 5892f542663..5e658fec641 100644 --- a/tests/baselines/reference/abstractClass1.errors.txt +++ b/tests/baselines/reference/abstractClass1.errors.txt @@ -1,57 +1,57 @@ -tests/cases/compiler/abstractClass1.ts(15,9): error TS2502: Cannot create an instance of the abstract class 'Foo' -tests/cases/compiler/abstractClass1.ts(16,9): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/abstractClass1.ts(16,9): error TS2502: Cannot create an instance of the abstract class 'Foo' -tests/cases/compiler/abstractClass1.ts(25,1): error TS2502: Cannot create an instance of the abstract class 'Qux' -tests/cases/compiler/abstractClass1.ts(35,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/abstractClass1.ts(35,1): error TS2502: Cannot create an instance of the abstract class 'Foo' - - -==== tests/cases/compiler/abstractClass1.ts (6 errors) ==== - - abstract class Foo { - constructor(f: any) { } - public static bar(): void { } - - public empty() { } - } - - class Bar extends Foo { - constructor(f: any) { - super(f); - } - } - - var a = new Foo(1); // Error - ~~~~~~~~~~ -!!! error TS2502: Cannot create an instance of the abstract class 'Foo' - var b = new Foo(); // Error because of invalid constructor arguments - ~~~~~~~~~ -!!! error TS2346: Supplied parameters do not match any signature of call target. - ~~~~~~~~~ -!!! error TS2502: Cannot create an instance of the abstract class 'Foo' - - module baz { - export abstract class Qux { - } - export class Quz extends Qux { - } - } - - new baz.Qux(); - ~~~~~~~~~~~~~ -!!! error TS2502: Cannot create an instance of the abstract class 'Qux' - - // Valid - var c = new Bar(1); - c.empty(); - - // Calling a static method on a abstract class is valid - Foo.bar(); - - var Copy = Foo; - new Copy(); - ~~~~~~~~~~ -!!! error TS2346: Supplied parameters do not match any signature of call target. - ~~~~~~~~~~ -!!! error TS2502: Cannot create an instance of the abstract class 'Foo' +tests/cases/compiler/abstractClass1.ts(15,9): error TS2511: Cannot create an instance of the abstract class 'Foo'. +tests/cases/compiler/abstractClass1.ts(16,9): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/abstractClass1.ts(16,9): error TS2511: Cannot create an instance of the abstract class 'Foo'. +tests/cases/compiler/abstractClass1.ts(25,1): error TS2511: Cannot create an instance of the abstract class 'Qux'. +tests/cases/compiler/abstractClass1.ts(35,1): error TS2346: Supplied parameters do not match any signature of call target. +tests/cases/compiler/abstractClass1.ts(35,1): error TS2511: Cannot create an instance of the abstract class 'Foo'. + + +==== tests/cases/compiler/abstractClass1.ts (6 errors) ==== + + abstract class Foo { + constructor(f: any) { } + public static bar(): void { } + + public empty() { } + } + + class Bar extends Foo { + constructor(f: any) { + super(f); + } + } + + var a = new Foo(1); // Error + ~~~~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'Foo'. + var b = new Foo(); // Error because of invalid constructor arguments + ~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + ~~~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'Foo'. + + module baz { + export abstract class Qux { + } + export class Quz extends Qux { + } + } + + new baz.Qux(); + ~~~~~~~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'Qux'. + + // Valid + var c = new Bar(1); + c.empty(); + + // Calling a static method on a abstract class is valid + Foo.bar(); + + var Copy = Foo; + new Copy(); + ~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + ~~~~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'Foo'. \ No newline at end of file diff --git a/tests/baselines/reference/abstractClass1.js b/tests/baselines/reference/abstractClass1.js index 4cb36d91ae1..494673d6ce0 100644 --- a/tests/baselines/reference/abstractClass1.js +++ b/tests/baselines/reference/abstractClass1.js @@ -1,4 +1,4 @@ -//// [abstractClass1.ts] +//// [abstractClass1.ts] abstract class Foo { constructor(f: any) { } @@ -34,74 +34,74 @@ Foo.bar(); var Copy = Foo; new Copy(); - - -//// [abstractClass1.js] -var __extends = this.__extends || function (d, b) { - for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; - function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); -}; -var Foo = (function () { - function Foo(f) { - } - Foo.bar = function () { }; - Foo.prototype.empty = function () { }; - return Foo; -})(); -var Bar = (function (_super) { - __extends(Bar, _super); - function Bar(f) { - _super.call(this, f); - } - return Bar; -})(Foo); -var a = new Foo(1); // Error -var b = new Foo(); // Error because of invalid constructor arguments -var baz; -(function (baz) { - var Qux = (function () { - function Qux() { - } - return Qux; - })(); - baz.Qux = Qux; - var Quz = (function (_super) { - __extends(Quz, _super); - function Quz() { - _super.apply(this, arguments); - } - return Quz; - })(Qux); - baz.Quz = Quz; -})(baz || (baz = {})); -new baz.Qux(); -// Valid -var c = new Bar(1); -c.empty(); -// Calling a static method on a abstract class is valid -Foo.bar(); -var Copy = Foo; -new Copy(); - - -//// [abstractClass1.d.ts] -declare abstract class Foo { - constructor(f: any); - static bar(): void; - empty(): void; -} -declare class Bar extends Foo { - constructor(f: any); -} -declare var a: Foo; -declare var b: any; -declare module baz { - abstract class Qux { - } - class Quz extends Qux { - } -} -declare var c: Bar; -declare var Copy: typeof Foo; + + +//// [abstractClass1.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Foo = (function () { + function Foo(f) { + } + Foo.bar = function () { }; + Foo.prototype.empty = function () { }; + return Foo; +})(); +var Bar = (function (_super) { + __extends(Bar, _super); + function Bar(f) { + _super.call(this, f); + } + return Bar; +})(Foo); +var a = new Foo(1); // Error +var b = new Foo(); // Error because of invalid constructor arguments +var baz; +(function (baz) { + var Qux = (function () { + function Qux() { + } + return Qux; + })(); + baz.Qux = Qux; + var Quz = (function (_super) { + __extends(Quz, _super); + function Quz() { + _super.apply(this, arguments); + } + return Quz; + })(Qux); + baz.Quz = Quz; +})(baz || (baz = {})); +new baz.Qux(); +// Valid +var c = new Bar(1); +c.empty(); +// Calling a static method on a abstract class is valid +Foo.bar(); +var Copy = Foo; +new Copy(); + + +//// [abstractClass1.d.ts] +declare abstract class Foo { + constructor(f: any); + static bar(): void; + empty(): void; +} +declare class Bar extends Foo { + constructor(f: any); +} +declare var a: Foo; +declare var b: any; +declare module baz { + abstract class Qux { + } + class Quz extends Qux { + } +} +declare var c: Bar; +declare var Copy: typeof Foo; diff --git a/tests/baselines/reference/abstractClassIdentifierName.js b/tests/baselines/reference/abstractClassIdentifierName.js index 71827d2cb5b..0e53e44671a 100644 --- a/tests/baselines/reference/abstractClassIdentifierName.js +++ b/tests/baselines/reference/abstractClassIdentifierName.js @@ -1,14 +1,14 @@ -//// [abstractClassIdentifierName.ts] +//// [abstractClassIdentifierName.ts] class abstract { abstract(): void { } } - - -//// [abstractClassIdentifierName.js] -var abstract = (function () { - function abstract() { - } - abstract.prototype.abstract = function () { }; - return abstract; -})(); + + +//// [abstractClassIdentifierName.js] +var abstract = (function () { + function abstract() { + } + abstract.prototype.abstract = function () { }; + return abstract; +})(); diff --git a/tests/baselines/reference/abstractClassIdentifierName.symbols b/tests/baselines/reference/abstractClassIdentifierName.symbols index 41c46649c43..12d878620d8 100644 --- a/tests/baselines/reference/abstractClassIdentifierName.symbols +++ b/tests/baselines/reference/abstractClassIdentifierName.symbols @@ -1,8 +1,8 @@ -=== tests/cases/compiler/abstractClassIdentifierName.ts === -class abstract { ->abstract : Symbol(abstract, Decl(abstractClassIdentifierName.ts, 0, 0)) - - abstract(): void { } ->abstract : Symbol(abstract, Decl(abstractClassIdentifierName.ts, 0, 16)) -} - +=== tests/cases/compiler/abstractClassIdentifierName.ts === +class abstract { +>abstract : Symbol(abstract, Decl(abstractClassIdentifierName.ts, 0, 0)) + + abstract(): void { } +>abstract : Symbol(abstract, Decl(abstractClassIdentifierName.ts, 0, 16)) +} + diff --git a/tests/baselines/reference/abstractClassIdentifierName.types b/tests/baselines/reference/abstractClassIdentifierName.types index ef152979f13..e31abf49a6f 100644 --- a/tests/baselines/reference/abstractClassIdentifierName.types +++ b/tests/baselines/reference/abstractClassIdentifierName.types @@ -1,8 +1,8 @@ -=== tests/cases/compiler/abstractClassIdentifierName.ts === -class abstract { ->abstract : abstract - - abstract(): void { } ->abstract : () => void -} - +=== tests/cases/compiler/abstractClassIdentifierName.ts === +class abstract { +>abstract : abstract + + abstract(): void { } +>abstract : () => void +} + diff --git a/tests/baselines/reference/abstractIdentifierNameStrict.js b/tests/baselines/reference/abstractIdentifierNameStrict.js index 8544019c4d1..92d159766d7 100644 --- a/tests/baselines/reference/abstractIdentifierNameStrict.js +++ b/tests/baselines/reference/abstractIdentifierNameStrict.js @@ -1,14 +1,14 @@ -//// [abstractIdentifierNameStrict.ts] +//// [abstractIdentifierNameStrict.ts] var abstract = true; function foo() { "use strict"; var abstract = true; -} - -//// [abstractIdentifierNameStrict.js] -var abstract = true; -function foo() { - "use strict"; - var abstract = true; -} +} + +//// [abstractIdentifierNameStrict.js] +var abstract = true; +function foo() { + "use strict"; + var abstract = true; +} diff --git a/tests/baselines/reference/abstractIdentifierNameStrict.symbols b/tests/baselines/reference/abstractIdentifierNameStrict.symbols index f983ddccdc9..c6a374e9bcd 100644 --- a/tests/baselines/reference/abstractIdentifierNameStrict.symbols +++ b/tests/baselines/reference/abstractIdentifierNameStrict.symbols @@ -1,11 +1,11 @@ -=== tests/cases/compiler/abstractIdentifierNameStrict.ts === -var abstract = true; ->abstract : Symbol(abstract, Decl(abstractIdentifierNameStrict.ts, 0, 3)) - -function foo() { ->foo : Symbol(foo, Decl(abstractIdentifierNameStrict.ts, 0, 20)) - - "use strict"; - var abstract = true; ->abstract : Symbol(abstract, Decl(abstractIdentifierNameStrict.ts, 4, 7)) -} +=== tests/cases/compiler/abstractIdentifierNameStrict.ts === +var abstract = true; +>abstract : Symbol(abstract, Decl(abstractIdentifierNameStrict.ts, 0, 3)) + +function foo() { +>foo : Symbol(foo, Decl(abstractIdentifierNameStrict.ts, 0, 20)) + + "use strict"; + var abstract = true; +>abstract : Symbol(abstract, Decl(abstractIdentifierNameStrict.ts, 4, 7)) +} diff --git a/tests/baselines/reference/abstractIdentifierNameStrict.types b/tests/baselines/reference/abstractIdentifierNameStrict.types index e43207007e0..7c79ce58a37 100644 --- a/tests/baselines/reference/abstractIdentifierNameStrict.types +++ b/tests/baselines/reference/abstractIdentifierNameStrict.types @@ -1,15 +1,15 @@ -=== tests/cases/compiler/abstractIdentifierNameStrict.ts === -var abstract = true; ->abstract : boolean ->true : boolean - -function foo() { ->foo : () => void - - "use strict"; ->"use strict" : string - - var abstract = true; ->abstract : boolean ->true : boolean -} +=== tests/cases/compiler/abstractIdentifierNameStrict.ts === +var abstract = true; +>abstract : boolean +>true : boolean + +function foo() { +>foo : () => void + + "use strict"; +>"use strict" : string + + var abstract = true; +>abstract : boolean +>true : boolean +} diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.js b/tests/baselines/reference/abstractInterfaceIdentifierName.js index c3913ae5cdf..67058bfc619 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.js +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.js @@ -1,8 +1,8 @@ -//// [abstractInterfaceIdentifierName.ts] +//// [abstractInterfaceIdentifierName.ts] interface abstract { abstract(): void; } - - -//// [abstractInterfaceIdentifierName.js] + + +//// [abstractInterfaceIdentifierName.js] diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.symbols b/tests/baselines/reference/abstractInterfaceIdentifierName.symbols index db2ad0aceba..c70cdec8ac9 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.symbols +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.symbols @@ -1,9 +1,9 @@ -=== tests/cases/compiler/abstractInterfaceIdentifierName.ts === - -interface abstract { ->abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 0, 0)) - - abstract(): void; ->abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 1, 20)) -} - +=== tests/cases/compiler/abstractInterfaceIdentifierName.ts === + +interface abstract { +>abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 0, 0)) + + abstract(): void; +>abstract : Symbol(abstract, Decl(abstractInterfaceIdentifierName.ts, 1, 20)) +} + diff --git a/tests/baselines/reference/abstractInterfaceIdentifierName.types b/tests/baselines/reference/abstractInterfaceIdentifierName.types index 3a5c6024f4c..c6d30ca38a0 100644 --- a/tests/baselines/reference/abstractInterfaceIdentifierName.types +++ b/tests/baselines/reference/abstractInterfaceIdentifierName.types @@ -1,9 +1,9 @@ -=== tests/cases/compiler/abstractInterfaceIdentifierName.ts === - -interface abstract { ->abstract : abstract - - abstract(): void; ->abstract : () => void -} - +=== tests/cases/compiler/abstractInterfaceIdentifierName.ts === + +interface abstract { +>abstract : abstract + + abstract(): void; +>abstract : () => void +} + diff --git a/tests/baselines/reference/classAbstractConstructor.errors.txt b/tests/baselines/reference/classAbstractConstructor.errors.txt new file mode 100644 index 00000000000..b8d91cefb0f --- /dev/null +++ b/tests/baselines/reference/classAbstractConstructor.errors.txt @@ -0,0 +1,12 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts(2,5): error TS1240: Abstract member functions cannot have an implementation. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts (2 errors) ==== + abstract class A { + abstract constructor() {} + ~~~~~~~~ +!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1240: Abstract member functions cannot have an implementation. + } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractConstructor.js b/tests/baselines/reference/classAbstractConstructor.js new file mode 100644 index 00000000000..fa88b0c7d37 --- /dev/null +++ b/tests/baselines/reference/classAbstractConstructor.js @@ -0,0 +1,11 @@ +//// [classAbstractConstructor.ts] +abstract class A { + abstract constructor() {} +} + +//// [classAbstractConstructor.js] +var A = (function () { + function A() { + } + return A; +})(); diff --git a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt new file mode 100644 index 00000000000..aef63b296e7 --- /dev/null +++ b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt @@ -0,0 +1,52 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1240: Abstract member functions cannot have an implementation. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,28): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(11,15): error TS2415: Class 'CC' incorrectly extends base class 'AA'. + Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(13,15): error TS2415: Class 'DD' incorrectly extends base class 'BB'. + Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(17,15): error TS2415: Class 'FF' incorrectly extends base class 'CC'. + Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts (6 errors) ==== + declare abstract class A { + abstract constructor() {} + ~~~~~~~~ +!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1240: Abstract member functions cannot have an implementation. + ~ +!!! error TS1184: An implementation cannot be declared in ambient contexts. + } + + declare abstract class AA { + abstract foo(); + } + + declare abstract class BB extends AA {} + + declare class CC extends AA {} + ~~ +!!! error TS2415: Class 'CC' incorrectly extends base class 'AA'. +!!! error TS2415: Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. + + declare class DD extends BB {} + ~~ +!!! error TS2415: Class 'DD' incorrectly extends base class 'BB'. +!!! error TS2415: Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. + + declare abstract class EE extends BB {} + + declare class FF extends CC {} + ~~ +!!! error TS2415: Class 'FF' incorrectly extends base class 'CC'. +!!! error TS2415: Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. + + declare abstract class GG extends CC {} + + declare abstract class AAA {} + + declare abstract class BBB extends AAA {} + + declare class CCC extends AAA {} \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractInheritance.errors.txt b/tests/baselines/reference/classAbstractInheritance.errors.txt new file mode 100644 index 00000000000..39e209b2e05 --- /dev/null +++ b/tests/baselines/reference/classAbstractInheritance.errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(13,7): error TS2415: Class 'CC' incorrectly extends base class 'AA'. + Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(15,7): error TS2415: Class 'DD' incorrectly extends base class 'BB'. + Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(19,7): error TS2415: Class 'FF' incorrectly extends base class 'CC'. + Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts (3 errors) ==== + abstract class A {} + + abstract class B extends A {} + + class C extends A {} + + abstract class AA { + abstract foo(); + } + + abstract class BB extends AA {} + + class CC extends AA {} + ~~ +!!! error TS2415: Class 'CC' incorrectly extends base class 'AA'. +!!! error TS2415: Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. + + class DD extends BB {} + ~~ +!!! error TS2415: Class 'DD' incorrectly extends base class 'BB'. +!!! error TS2415: Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. + + abstract class EE extends BB {} + + class FF extends CC {} + ~~ +!!! error TS2415: Class 'FF' incorrectly extends base class 'CC'. +!!! error TS2415: Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. + + abstract class GG extends CC {} \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractInheritance.js b/tests/baselines/reference/classAbstractInheritance.js new file mode 100644 index 00000000000..2aa156500e0 --- /dev/null +++ b/tests/baselines/reference/classAbstractInheritance.js @@ -0,0 +1,96 @@ +//// [classAbstractInheritance.ts] +abstract class A {} + +abstract class B extends A {} + +class C extends A {} + +abstract class AA { + abstract foo(); +} + +abstract class BB extends AA {} + +class CC extends AA {} + +class DD extends BB {} + +abstract class EE extends BB {} + +class FF extends CC {} + +abstract class GG extends CC {} + +//// [classAbstractInheritance.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var A = (function () { + function A() { + } + return A; +})(); +var B = (function (_super) { + __extends(B, _super); + function B() { + _super.apply(this, arguments); + } + return B; +})(A); +var C = (function (_super) { + __extends(C, _super); + function C() { + _super.apply(this, arguments); + } + return C; +})(A); +var AA = (function () { + function AA() { + } + return AA; +})(); +var BB = (function (_super) { + __extends(BB, _super); + function BB() { + _super.apply(this, arguments); + } + return BB; +})(AA); +var CC = (function (_super) { + __extends(CC, _super); + function CC() { + _super.apply(this, arguments); + } + return CC; +})(AA); +var DD = (function (_super) { + __extends(DD, _super); + function DD() { + _super.apply(this, arguments); + } + return DD; +})(BB); +var EE = (function (_super) { + __extends(EE, _super); + function EE() { + _super.apply(this, arguments); + } + return EE; +})(BB); +var FF = (function (_super) { + __extends(FF, _super); + function FF() { + _super.apply(this, arguments); + } + return FF; +})(CC); +var GG = (function (_super) { + __extends(GG, _super); + function GG() { + _super.apply(this, arguments); + } + return GG; +})(CC); diff --git a/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt b/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt new file mode 100644 index 00000000000..5e1196f0e7c --- /dev/null +++ b/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt @@ -0,0 +1,9 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts(2,5): error TS1240: Abstract member functions cannot have an implementation. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts (1 errors) ==== + abstract class A { + abstract foo() {} + ~~~~~~~~~~~~~~~~~ +!!! error TS1240: Abstract member functions cannot have an implementation. + } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractMethodWithImplementation.js b/tests/baselines/reference/classAbstractMethodWithImplementation.js new file mode 100644 index 00000000000..d9319012712 --- /dev/null +++ b/tests/baselines/reference/classAbstractMethodWithImplementation.js @@ -0,0 +1,12 @@ +//// [classAbstractMethodWithImplementation.ts] +abstract class A { + abstract foo() {} +} + +//// [classAbstractMethodWithImplementation.js] +var A = (function () { + function A() { + } + A.prototype.foo = function () { }; + return A; +})(); diff --git a/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt b/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt new file mode 100644 index 00000000000..488fbdeb36e --- /dev/null +++ b/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt @@ -0,0 +1,36 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(6,13): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(8,14): error TS1029: 'public' modifier must precede 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(9,14): error TS1029: 'protected' modifier must precede 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(10,14): error TS1029: 'private' modifier must precede 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(12,14): error TS1237: 'static' modifier cannot be used with 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(14,12): error TS1237: 'static' modifier cannot be used with 'abstract' modifier. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts (6 errors) ==== + abstract class A { + abstract foo_a(); + + public abstract foo_b(); + protected abstract foo_c(); + private abstract foo_d(); + ~~~~~~~~ +!!! error TS1237: 'private' modifier cannot be used with 'abstract' modifier. + + abstract public foo_bb(); + ~~~~~~ +!!! error TS1029: 'public' modifier must precede 'abstract' modifier. + abstract protected foo_cc(); + ~~~~~~~~~ +!!! error TS1029: 'protected' modifier must precede 'abstract' modifier. + abstract private foo_dd(); + ~~~~~~~ +!!! error TS1029: 'private' modifier must precede 'abstract' modifier. + + abstract static foo_d(); + ~~~~~~ +!!! error TS1237: 'static' modifier cannot be used with 'abstract' modifier. + + static abstract foo_e(); + ~~~~~~~~ +!!! error TS1237: 'static' modifier cannot be used with 'abstract' modifier. + } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractMixedWithModifiers.js b/tests/baselines/reference/classAbstractMixedWithModifiers.js new file mode 100644 index 00000000000..71eb4c61c04 --- /dev/null +++ b/tests/baselines/reference/classAbstractMixedWithModifiers.js @@ -0,0 +1,23 @@ +//// [classAbstractMixedWithModifiers.ts] +abstract class A { + abstract foo_a(); + + public abstract foo_b(); + protected abstract foo_c(); + private abstract foo_d(); + + abstract public foo_bb(); + abstract protected foo_cc(); + abstract private foo_dd(); + + abstract static foo_d(); + + static abstract foo_e(); +} + +//// [classAbstractMixedWithModifiers.js] +var A = (function () { + function A() { + } + return A; +})(); diff --git a/tests/baselines/reference/classAbstractOverloads.errors.txt b/tests/baselines/reference/classAbstractOverloads.errors.txt new file mode 100644 index 00000000000..88dd33c2bed --- /dev/null +++ b/tests/baselines/reference/classAbstractOverloads.errors.txt @@ -0,0 +1,42 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(7,5): error TS2512: All overload signatures must match with respect to modifier 'abstract'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(10,14): error TS2512: All overload signatures must match with respect to modifier 'abstract'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(12,14): error TS2512: All overload signatures must match with respect to modifier 'abstract'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(15,5): error TS2391: Function implementation is missing or not immediately following the declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(20,14): error TS2516: All declarations of an abstract member function must be consecutive. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts (5 errors) ==== + abstract class A { + abstract foo(); + abstract foo() : number; + abstract foo(); + + abstract bar(); + bar(); + ~~~ +!!! error TS2512: All overload signatures must match with respect to modifier 'abstract'. + abstract bar(); + + abstract baz(); + ~~~ +!!! error TS2512: All overload signatures must match with respect to modifier 'abstract'. + baz(); + abstract baz(); + ~~~ +!!! error TS2512: All overload signatures must match with respect to modifier 'abstract'. + baz() {} + + qux(); + ~~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. + } + + abstract class B { + abstract foo() : number; + abstract foo(); + ~~~ +!!! error TS2516: All declarations of an abstract member function must be consecutive. + x : number; + abstract foo(); + abstract foo(); + } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractOverloads.js b/tests/baselines/reference/classAbstractOverloads.js new file mode 100644 index 00000000000..1bdff73d5b7 --- /dev/null +++ b/tests/baselines/reference/classAbstractOverloads.js @@ -0,0 +1,38 @@ +//// [classAbstractOverloads.ts] +abstract class A { + abstract foo(); + abstract foo() : number; + abstract foo(); + + abstract bar(); + bar(); + abstract bar(); + + abstract baz(); + baz(); + abstract baz(); + baz() {} + + qux(); +} + +abstract class B { + abstract foo() : number; + abstract foo(); + x : number; + abstract foo(); + abstract foo(); +} + +//// [classAbstractOverloads.js] +var A = (function () { + function A() { + } + A.prototype.baz = function () { }; + return A; +})(); +var B = (function () { + function B() { + } + return B; +})(); diff --git a/tests/baselines/reference/classAbstractProperties.errors.txt b/tests/baselines/reference/classAbstractProperties.errors.txt new file mode 100644 index 00000000000..0f40d091fd8 --- /dev/null +++ b/tests/baselines/reference/classAbstractProperties.errors.txt @@ -0,0 +1,29 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(3,12): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(4,15): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(5,13): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(10,13): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts (5 errors) ==== + abstract class A { + abstract x : number; + ~~~~~~~~ +!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. + public abstract y : number; + ~~~~~~~~ +!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. + protected abstract z : number; + ~~~~~~~~ +!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. + private abstract w : number; + ~~~~~~~~ +!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. + + abstract foo_x() : number; + public abstract foo_y() : number; + protected abstract foo_z() : number; + private abstract foo_w() : number; + ~~~~~~~~ +!!! error TS1237: 'private' modifier cannot be used with 'abstract' modifier. + } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractProperties.js b/tests/baselines/reference/classAbstractProperties.js new file mode 100644 index 00000000000..a410715e4f7 --- /dev/null +++ b/tests/baselines/reference/classAbstractProperties.js @@ -0,0 +1,19 @@ +//// [classAbstractProperties.ts] +abstract class A { + abstract x : number; + public abstract y : number; + protected abstract z : number; + private abstract w : number; + + abstract foo_x() : number; + public abstract foo_y() : number; + protected abstract foo_z() : number; + private abstract foo_w() : number; +} + +//// [classAbstractProperties.js] +var A = (function () { + function A() { + } + return A; +})(); diff --git a/tests/baselines/reference/classAbstractSuperCalls.errors.txt b/tests/baselines/reference/classAbstractSuperCalls.errors.txt new file mode 100644 index 00000000000..b63b768cbfe --- /dev/null +++ b/tests/baselines/reference/classAbstractSuperCalls.errors.txt @@ -0,0 +1,33 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,26): error TS2513: Abstract member function 'foo' on type 'B' cannot be called via super expression. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts (1 errors) ==== + + class A { + foo() { return 1; } + } + + abstract class B extends A { + abstract foo(); + bar() { super.foo(); } + baz() { return this.foo; } + } + + class C extends B { + foo() { return 2; } + qux() { return super.foo(); } // error, super is abstract + ~~~ +!!! error TS2513: Abstract member function 'foo' on type 'B' cannot be called via super expression. + norf() { return super.bar(); } + } + + class AA { + foo() { return 1; } + bar() { return this.foo(); } + } + + abstract class BB extends AA { + abstract foo(); + // inherits bar. But BB is abstract, so this is OK. + } + \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractSuperCalls.js b/tests/baselines/reference/classAbstractSuperCalls.js new file mode 100644 index 00000000000..7841785ac05 --- /dev/null +++ b/tests/baselines/reference/classAbstractSuperCalls.js @@ -0,0 +1,75 @@ +//// [classAbstractSuperCalls.ts] + +class A { + foo() { return 1; } +} + +abstract class B extends A { + abstract foo(); + bar() { super.foo(); } + baz() { return this.foo; } +} + +class C extends B { + foo() { return 2; } + qux() { return super.foo(); } // error, super is abstract + norf() { return super.bar(); } +} + +class AA { + foo() { return 1; } + bar() { return this.foo(); } +} + +abstract class BB extends AA { + abstract foo(); + // inherits bar. But BB is abstract, so this is OK. +} + + +//// [classAbstractSuperCalls.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var A = (function () { + function A() { + } + A.prototype.foo = function () { return 1; }; + return A; +})(); +var B = (function (_super) { + __extends(B, _super); + function B() { + _super.apply(this, arguments); + } + B.prototype.bar = function () { _super.prototype.foo.call(this); }; + B.prototype.baz = function () { return this.foo; }; + return B; +})(A); +var C = (function (_super) { + __extends(C, _super); + function C() { + _super.apply(this, arguments); + } + C.prototype.foo = function () { return 2; }; + C.prototype.qux = function () { return _super.prototype.foo.call(this); }; // error, super is abstract + C.prototype.norf = function () { return _super.prototype.bar.call(this); }; + return C; +})(B); +var AA = (function () { + function AA() { + } + AA.prototype.foo = function () { return 1; }; + AA.prototype.bar = function () { return this.foo(); }; + return AA; +})(); +var BB = (function (_super) { + __extends(BB, _super); + function BB() { + _super.apply(this, arguments); + } + return BB; +})(AA); diff --git a/tests/baselines/reference/classAbstractUsingAbstractMethod.errors.txt b/tests/baselines/reference/classAbstractUsingAbstractMethod.errors.txt new file mode 100644 index 00000000000..3ae5084e2db --- /dev/null +++ b/tests/baselines/reference/classAbstractUsingAbstractMethod.errors.txt @@ -0,0 +1,23 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts(16,5): error TS2511: Cannot create an instance of the abstract class 'C'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts (1 errors) ==== + abstract class A { + abstract foo() : number; + } + + class B extends A { + foo() { return 1; } + } + + abstract class C extends A { + abstract foo() : number; + } + + var a = new B; + a.foo(); + + a = new C; // error, cannot instantiate abstract class. + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'C'. + a.foo(); \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractUsingAbstractMethod.js b/tests/baselines/reference/classAbstractUsingAbstractMethod.js new file mode 100644 index 00000000000..26a406aa008 --- /dev/null +++ b/tests/baselines/reference/classAbstractUsingAbstractMethod.js @@ -0,0 +1,50 @@ +//// [classAbstractUsingAbstractMethod.ts] +abstract class A { + abstract foo() : number; +} + +class B extends A { + foo() { return 1; } +} + +abstract class C extends A { + abstract foo() : number; +} + +var a = new B; +a.foo(); + +a = new C; // error, cannot instantiate abstract class. +a.foo(); + +//// [classAbstractUsingAbstractMethod.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var A = (function () { + function A() { + } + return A; +})(); +var B = (function (_super) { + __extends(B, _super); + function B() { + _super.apply(this, arguments); + } + B.prototype.foo = function () { return 1; }; + return B; +})(A); +var C = (function (_super) { + __extends(C, _super); + function C() { + _super.apply(this, arguments); + } + return C; +})(A); +var a = new B; +a.foo(); +a = new C; // error, cannot instantiate abstract class. +a.foo(); diff --git a/tests/baselines/reference/classInstantiatingAbstractClass.errors.txt b/tests/baselines/reference/classInstantiatingAbstractClass.errors.txt new file mode 100644 index 00000000000..a9da2f38c37 --- /dev/null +++ b/tests/baselines/reference/classInstantiatingAbstractClass.errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts(8,1): error TS2511: Cannot create an instance of the abstract class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'C'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts(26,10): error TS2511: Cannot create an instance of the abstract class 'A'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts (3 errors) ==== + + abstract class A {} + + class B extends A {} + + abstract class C extends B {} + + new A; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + new B; + new C; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'C'. + + var a : A; + var b : B; + var c : C; + + a = new B; + b = new B; + c = new B; + + module M { + export abstract class A {} + } + + import myA = M.A; + + var aa = new myA; + ~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + \ No newline at end of file diff --git a/tests/baselines/reference/classInstantiatingAbstractClass.js b/tests/baselines/reference/classInstantiatingAbstractClass.js new file mode 100644 index 00000000000..5a23d3d9b40 --- /dev/null +++ b/tests/baselines/reference/classInstantiatingAbstractClass.js @@ -0,0 +1,75 @@ +//// [classInstantiatingAbstractClass.ts] + +abstract class A {} + +class B extends A {} + +abstract class C extends B {} + +new A; +new B; +new C; + +var a : A; +var b : B; +var c : C; + +a = new B; +b = new B; +c = new B; + +module M { + export abstract class A {} +} + +import myA = M.A; + +var aa = new myA; + + +//// [classInstantiatingAbstractClass.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var A = (function () { + function A() { + } + return A; +})(); +var B = (function (_super) { + __extends(B, _super); + function B() { + _super.apply(this, arguments); + } + return B; +})(A); +var C = (function (_super) { + __extends(C, _super); + function C() { + _super.apply(this, arguments); + } + return C; +})(B); +new A; +new B; +new C; +var a; +var b; +var c; +a = new B; +b = new B; +c = new B; +var M; +(function (M) { + var A = (function () { + function A() { + } + return A; + })(); + M.A = A; +})(M || (M = {})); +var myA = M.A; +var aa = new myA; diff --git a/tests/baselines/reference/classWithAbstractMethods.errors.txt b/tests/baselines/reference/classWithAbstractMethods.errors.txt new file mode 100644 index 00000000000..37eba4a6a86 --- /dev/null +++ b/tests/baselines/reference/classWithAbstractMethods.errors.txt @@ -0,0 +1,46 @@ +tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts(1,7): error TS2514: Classes containing abstract functions must be marked abstract. +tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts(2,5): error TS1238: Abstract methods can only appear within an abstract class. +tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts(5,7): error TS2415: Class 'B' incorrectly extends base class 'A'. + Non-abstract class 'B' does not implement inherited abstract member 'A.foo'. +tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts(21,7): error TS2415: Class 'BB' incorrectly extends base class 'AA'. + Non-abstract class 'BB' does not implement inherited abstract member 'AA.foo'. + + +==== tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts (4 errors) ==== + class A { + ~ +!!! error TS2514: Classes containing abstract functions must be marked abstract. + abstract foo(); + ~~~~~~~~ +!!! error TS1238: Abstract methods can only appear within an abstract class. + } + + class B extends A {} + ~ +!!! error TS2415: Class 'B' incorrectly extends base class 'A'. +!!! error TS2415: Non-abstract class 'B' does not implement inherited abstract member 'A.foo'. + + abstract class C extends A {} + + class D extends A { + foo() {} + } + + abstract class E extends A { + foo() {} + } + + abstract class AA { + abstract foo(); + } + + class BB extends AA {} + ~~ +!!! error TS2415: Class 'BB' incorrectly extends base class 'AA'. +!!! error TS2415: Non-abstract class 'BB' does not implement inherited abstract member 'AA.foo'. + + abstract class CC extends AA {} + + class DD extends AA { + foo() {} + } \ No newline at end of file diff --git a/tests/baselines/reference/classWithAbstractMethods.js b/tests/baselines/reference/classWithAbstractMethods.js new file mode 100644 index 00000000000..2035ba20ea9 --- /dev/null +++ b/tests/baselines/reference/classWithAbstractMethods.js @@ -0,0 +1,98 @@ +//// [classWithAbstractMethods.ts] +class A { + abstract foo(); +} + +class B extends A {} + +abstract class C extends A {} + +class D extends A { + foo() {} +} + +abstract class E extends A { + foo() {} +} + +abstract class AA { + abstract foo(); +} + +class BB extends AA {} + +abstract class CC extends AA {} + +class DD extends AA { + foo() {} +} + +//// [classWithAbstractMethods.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var A = (function () { + function A() { + } + return A; +})(); +var B = (function (_super) { + __extends(B, _super); + function B() { + _super.apply(this, arguments); + } + return B; +})(A); +var C = (function (_super) { + __extends(C, _super); + function C() { + _super.apply(this, arguments); + } + return C; +})(A); +var D = (function (_super) { + __extends(D, _super); + function D() { + _super.apply(this, arguments); + } + D.prototype.foo = function () { }; + return D; +})(A); +var E = (function (_super) { + __extends(E, _super); + function E() { + _super.apply(this, arguments); + } + E.prototype.foo = function () { }; + return E; +})(A); +var AA = (function () { + function AA() { + } + return AA; +})(); +var BB = (function (_super) { + __extends(BB, _super); + function BB() { + _super.apply(this, arguments); + } + return BB; +})(AA); +var CC = (function (_super) { + __extends(CC, _super); + function CC() { + _super.apply(this, arguments); + } + return CC; +})(AA); +var DD = (function (_super) { + __extends(DD, _super); + function DD() { + _super.apply(this, arguments); + } + DD.prototype.foo = function () { }; + return DD; +})(AA); diff --git a/tests/baselines/reference/computedPropertyNames30_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames30_ES5.errors.txt index 1dfb605db33..deb80dbcca8 100644 --- a/tests/baselines/reference/computedPropertyNames30_ES5.errors.txt +++ b/tests/baselines/reference/computedPropertyNames30_ES5.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES5.ts(11,19): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES5.ts(11,19): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES5.ts (1 errors) ==== @@ -14,7 +14,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES5.ts(11 //treatment of other similar violations. [(super(), "prop")]() { } ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. }; } } diff --git a/tests/baselines/reference/computedPropertyNames30_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames30_ES6.errors.txt index dc8892fd326..b10d184f799 100644 --- a/tests/baselines/reference/computedPropertyNames30_ES6.errors.txt +++ b/tests/baselines/reference/computedPropertyNames30_ES6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES6.ts(11,19): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES6.ts(11,19): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES6.ts (1 errors) ==== @@ -14,7 +14,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES6.ts(11 //treatment of other similar violations. [(super(), "prop")]() { } ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. }; } } diff --git a/tests/baselines/reference/decoratorOnClassMethod12.errors.txt b/tests/baselines/reference/decoratorOnClassMethod12.errors.txt index 14845839089..3ad3cabebe2 100644 --- a/tests/baselines/reference/decoratorOnClassMethod12.errors.txt +++ b/tests/baselines/reference/decoratorOnClassMethod12.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts(6,10): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts(6,10): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. ==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts (1 errors) ==== @@ -9,7 +9,7 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts(6,10 class C extends S { @super.decorator ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. method() { } } } \ No newline at end of file diff --git a/tests/baselines/reference/derivedClassConstructorWithoutSuperCall.errors.txt b/tests/baselines/reference/derivedClassConstructorWithoutSuperCall.errors.txt index 40610b5b838..c67bc2479ec 100644 --- a/tests/baselines/reference/derivedClassConstructorWithoutSuperCall.errors.txt +++ b/tests/baselines/reference/derivedClassConstructorWithoutSuperCall.errors.txt @@ -1,8 +1,8 @@ tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassConstructorWithoutSuperCall.ts(8,5): error TS2377: Constructors for derived classes must contain a 'super' call. tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassConstructorWithoutSuperCall.ts(17,5): error TS2377: Constructors for derived classes must contain a 'super' call. -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassConstructorWithoutSuperCall.ts(18,24): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassConstructorWithoutSuperCall.ts(18,24): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassConstructorWithoutSuperCall.ts(23,5): error TS2377: Constructors for derived classes must contain a 'super' call. -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassConstructorWithoutSuperCall.ts(24,31): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassConstructorWithoutSuperCall.ts(24,31): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassConstructorWithoutSuperCall.ts (5 errors) ==== @@ -30,7 +30,7 @@ tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassC var r2 = () => super(); // error for misplaced super call (nested function) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } ~~~~~ !!! error TS2377: Constructors for derived classes must contain a 'super' call. @@ -42,7 +42,7 @@ tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassC var r = function () { super() } // error ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } ~~~~~ !!! error TS2377: Constructors for derived classes must contain a 'super' call. diff --git a/tests/baselines/reference/derivedClassSuperCallsInNonConstructorMembers.errors.txt b/tests/baselines/reference/derivedClassSuperCallsInNonConstructorMembers.errors.txt index f465afbccad..ab79f8d3e23 100644 --- a/tests/baselines/reference/derivedClassSuperCallsInNonConstructorMembers.errors.txt +++ b/tests/baselines/reference/derivedClassSuperCallsInNonConstructorMembers.errors.txt @@ -1,13 +1,13 @@ tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(8,8): error TS1110: Type expected. -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(8,8): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(10,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(13,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(17,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(8,8): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(10,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(13,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(17,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(20,15): error TS1110: Type expected. -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(20,15): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(22,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(25,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(29,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(20,15): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(22,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(25,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts(29,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassSuperCallsInNonConstructorMembers.ts (10 errors) ==== @@ -22,43 +22,43 @@ tests/cases/conformance/classes/constructorDeclarations/superCalls/derivedClassS ~~~~~ !!! error TS1110: Type expected. ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. b() { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } get C() { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. return 1; } set C(v) { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } static a: super(); ~~~~~ !!! error TS1110: Type expected. ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. static b() { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } static get C() { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. return 1; } static set C(v) { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } } \ No newline at end of file diff --git a/tests/baselines/reference/emitThisInSuperMethodCall.errors.txt b/tests/baselines/reference/emitThisInSuperMethodCall.errors.txt index 7fe090395e3..06211ef771f 100644 --- a/tests/baselines/reference/emitThisInSuperMethodCall.errors.txt +++ b/tests/baselines/reference/emitThisInSuperMethodCall.errors.txt @@ -1,6 +1,6 @@ -tests/cases/compiler/emitThisInSuperMethodCall.ts(10,17): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class -tests/cases/compiler/emitThisInSuperMethodCall.ts(17,17): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class -tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +tests/cases/compiler/emitThisInSuperMethodCall.ts(10,17): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. +tests/cases/compiler/emitThisInSuperMethodCall.ts(17,17): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. +tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. ==== tests/cases/compiler/emitThisInSuperMethodCall.ts (3 errors) ==== @@ -15,7 +15,7 @@ tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super' function inner() { super.sayHello(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } }; } @@ -24,7 +24,7 @@ tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super' () => { super.sayHello(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } } } @@ -32,7 +32,7 @@ tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super' function inner() { super.sayHello(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } } } diff --git a/tests/baselines/reference/errorSuperCalls.errors.txt b/tests/baselines/reference/errorSuperCalls.errors.txt index cd1aa23f14d..9ecc7a1565e 100644 --- a/tests/baselines/reference/errorSuperCalls.errors.txt +++ b/tests/baselines/reference/errorSuperCalls.errors.txt @@ -8,10 +8,10 @@ tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(30,16): error tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(34,9): error TS2335: 'super' can only be referenced in a derived class. tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(38,9): error TS2335: 'super' can only be referenced in a derived class. tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(46,14): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(58,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(62,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(67,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(71,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(58,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(62,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(67,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(71,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts (14 errors) ==== @@ -94,26 +94,26 @@ tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(71,9): error T //super call in class member initializer of derived type t = super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. fn() { //super call in class member function of derived type super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } //super call in class accessor (get and set) of derived type get foo() { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. return null; } set foo(n) { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } } \ No newline at end of file diff --git a/tests/baselines/reference/errorSuperPropertyAccess.errors.txt b/tests/baselines/reference/errorSuperPropertyAccess.errors.txt index b273b1b6f45..c34ed912046 100644 --- a/tests/baselines/reference/errorSuperPropertyAccess.errors.txt +++ b/tests/baselines/reference/errorSuperPropertyAccess.errors.txt @@ -9,30 +9,30 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(25,9): error TS2335: 'super' can only be referenced in a derived class. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(29,23): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(30,9): error TS2335: 'super' can only be referenced in a derived class. -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(57,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(61,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(57,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(61,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(64,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(65,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(65,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(68,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(69,19): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(73,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(76,40): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(87,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(91,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(69,19): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(73,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(76,40): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(87,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(91,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(94,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(95,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(95,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(98,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(99,19): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(109,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(110,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(99,19): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(109,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(110,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(111,9): error TS2341: Property 'privateStaticFunc' is private and only accessible within class 'SomeBase'. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(113,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(114,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(115,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(114,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(115,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(116,9): error TS2341: Property 'privateStaticFunc' is private and only accessible within class 'SomeBase'. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(119,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(120,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(121,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(120,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(121,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(122,9): error TS2341: Property 'privateStaticFunc' is private and only accessible within class 'SomeBase'. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(127,16): error TS2335: 'super' can only be referenced in a derived class. tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(127,30): error TS2335: 'super' can only be referenced in a derived class. @@ -119,13 +119,13 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess super(); super.publicMember = 1; ~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } fn() { var x = super.publicMember; ~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } get a() { @@ -133,7 +133,7 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. var x = super.publicMember; ~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. return undefined; } set a(n) { @@ -141,18 +141,18 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. n = super.publicMember; ~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } fn2() { function inner() { super.publicFunc(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } var x = { test: function () { return super.publicFunc(); } ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } } } @@ -165,13 +165,13 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess super(); super.privateMember = 1; ~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } fn() { var x = super.privateMember; ~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } get a() { @@ -179,7 +179,7 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. var x = super.privateMember; ~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. return undefined; } set a(n) { @@ -187,7 +187,7 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. n = super.privateMember; ~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } } @@ -199,10 +199,10 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess static fn() { super.publicStaticMember = 3; ~~~~~~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. super.privateStaticMember = 3; ~~~~~~~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. super.privateStaticFunc(); ~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2341: Property 'privateStaticFunc' is private and only accessible within class 'SomeBase'. @@ -212,10 +212,10 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. super.publicStaticMember = 3; ~~~~~~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. super.privateStaticMember = 3; ~~~~~~~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. super.privateStaticFunc(); ~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2341: Property 'privateStaticFunc' is private and only accessible within class 'SomeBase'. @@ -226,10 +226,10 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. super.publicStaticMember = 3; ~~~~~~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. super.privateStaticMember = 3; ~~~~~~~~~~~~~~~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. super.privateStaticFunc(); ~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2341: Property 'privateStaticFunc' is private and only accessible within class 'SomeBase'. diff --git a/tests/baselines/reference/illegalSuperCallsInConstructor.errors.txt b/tests/baselines/reference/illegalSuperCallsInConstructor.errors.txt index a07fbea75d8..1d3d2e7c275 100644 --- a/tests/baselines/reference/illegalSuperCallsInConstructor.errors.txt +++ b/tests/baselines/reference/illegalSuperCallsInConstructor.errors.txt @@ -1,11 +1,11 @@ tests/cases/compiler/illegalSuperCallsInConstructor.ts(6,5): error TS2377: Constructors for derived classes must contain a 'super' call. -tests/cases/compiler/illegalSuperCallsInConstructor.ts(7,24): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/compiler/illegalSuperCallsInConstructor.ts(8,26): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/compiler/illegalSuperCallsInConstructor.ts(9,32): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/compiler/illegalSuperCallsInConstructor.ts(7,24): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/compiler/illegalSuperCallsInConstructor.ts(8,26): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/compiler/illegalSuperCallsInConstructor.ts(9,32): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. tests/cases/compiler/illegalSuperCallsInConstructor.ts(11,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/illegalSuperCallsInConstructor.ts(12,17): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/compiler/illegalSuperCallsInConstructor.ts(12,17): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. tests/cases/compiler/illegalSuperCallsInConstructor.ts(15,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/illegalSuperCallsInConstructor.ts(16,17): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/compiler/illegalSuperCallsInConstructor.ts(16,17): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/compiler/illegalSuperCallsInConstructor.ts (8 errors) ==== @@ -19,15 +19,15 @@ tests/cases/compiler/illegalSuperCallsInConstructor.ts(16,17): error TS2337: Sup var r2 = () => super(); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. var r3 = () => { super(); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. var r4 = function () { super(); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. var r5 = { ~~~~~~~~~~~~~~~~~~ get foo() { @@ -37,7 +37,7 @@ tests/cases/compiler/illegalSuperCallsInConstructor.ts(16,17): error TS2337: Sup super(); ~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. return 1; ~~~~~~~~~~~~~~~~~~~~~~~~~ }, @@ -49,7 +49,7 @@ tests/cases/compiler/illegalSuperCallsInConstructor.ts(16,17): error TS2337: Sup super(); ~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } ~~~~~~~~~~~~~ } diff --git a/tests/baselines/reference/parserAstSpans1.errors.txt b/tests/baselines/reference/parserAstSpans1.errors.txt index 9697dcbc128..648929e974e 100644 --- a/tests/baselines/reference/parserAstSpans1.errors.txt +++ b/tests/baselines/reference/parserAstSpans1.errors.txt @@ -2,10 +2,10 @@ tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(79,16): error TS10 tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(85,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(94,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(100,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(111,25): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(111,25): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(119,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(125,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(217,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(217,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts (8 errors) ==== @@ -129,7 +129,7 @@ tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(217,24): error TS2 super(10); this.p1 = super.c2_p1; ~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } /** c3 p1*/ public p1: number; @@ -241,6 +241,6 @@ tests/cases/conformance/parser/ecmascript5/parserAstSpans1.ts(217,24): error TS2 super(); this.d = super.b; ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } } \ No newline at end of file diff --git a/tests/baselines/reference/privateInstanceMemberAccessibility.errors.txt b/tests/baselines/reference/privateInstanceMemberAccessibility.errors.txt index f29ee917ea7..7893100b5a5 100644 --- a/tests/baselines/reference/privateInstanceMemberAccessibility.errors.txt +++ b/tests/baselines/reference/privateInstanceMemberAccessibility.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(6,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(8,22): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(6,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(8,22): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(10,15): error TS1003: Identifier expected. -tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(10,21): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(10,21): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(12,8): error TS1110: Type expected. tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(12,8): error TS2341: Property 'foo' is private and only accessible within class 'Base'. @@ -14,17 +14,17 @@ tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAcces class Derived extends Base { x = super.foo; // error ~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. y() { return super.foo; // error ~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } z: typeof super.foo; // error ~~~~~ !!! error TS1003: Identifier expected. ~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. a: this.foo; // error ~~~~ diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass3.errors.txt b/tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass3.errors.txt index f2b19d043c2..897636b6d90 100644 --- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass3.errors.txt +++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass3.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinSubclass3.ts(11,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinSubclass3.ts(11,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAccessibleWithinSubclass3.ts (1 errors) ==== @@ -14,6 +14,6 @@ tests/cases/conformance/classes/members/accessibility/protectedClassPropertyAcce this.x; // OK, accessed within a subclass of the declaring class super.x; // Error, x is not public ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } } \ No newline at end of file diff --git a/tests/baselines/reference/protectedInstanceMemberAccessibility.errors.txt b/tests/baselines/reference/protectedInstanceMemberAccessibility.errors.txt index 03671925feb..4b950c70019 100644 --- a/tests/baselines/reference/protectedInstanceMemberAccessibility.errors.txt +++ b/tests/baselines/reference/protectedInstanceMemberAccessibility.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/classes/members/accessibility/protectedInstanceMemberAccessibility.ts(14,23): error TS2339: Property 'z' does not exist on type 'B'. -tests/cases/conformance/classes/members/accessibility/protectedInstanceMemberAccessibility.ts(16,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/classes/members/accessibility/protectedInstanceMemberAccessibility.ts(16,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/classes/members/accessibility/protectedInstanceMemberAccessibility.ts(18,24): error TS2339: Property 'y' does not exist on type 'A'. tests/cases/conformance/classes/members/accessibility/protectedInstanceMemberAccessibility.ts(19,24): error TS2339: Property 'z' does not exist on type 'A'. tests/cases/conformance/classes/members/accessibility/protectedInstanceMemberAccessibility.ts(22,18): error TS2446: Property 'x' is protected and only accessible through an instance of class 'B'. @@ -33,7 +33,7 @@ tests/cases/conformance/classes/members/accessibility/protectedInstanceMemberAcc var s1 = super.x; // error ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. var s2 = super.f(); var s3 = super.y; // error ~ diff --git a/tests/baselines/reference/protectedStaticClassPropertyAccessibleWithinSubclass2.errors.txt b/tests/baselines/reference/protectedStaticClassPropertyAccessibleWithinSubclass2.errors.txt index 1f1bd72617c..b6fa239f291 100644 --- a/tests/baselines/reference/protectedStaticClassPropertyAccessibleWithinSubclass2.errors.txt +++ b/tests/baselines/reference/protectedStaticClassPropertyAccessibleWithinSubclass2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/conformance/classes/members/accessibility/protectedStaticClassPropertyAccessibleWithinSubclass2.ts(11,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/conformance/classes/members/accessibility/protectedStaticClassPropertyAccessibleWithinSubclass2.ts(19,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/conformance/classes/members/accessibility/protectedStaticClassPropertyAccessibleWithinSubclass2.ts(11,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/conformance/classes/members/accessibility/protectedStaticClassPropertyAccessibleWithinSubclass2.ts(19,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/conformance/classes/members/accessibility/protectedStaticClassPropertyAccessibleWithinSubclass2.ts (2 errors) ==== @@ -15,7 +15,7 @@ tests/cases/conformance/classes/members/accessibility/protectedStaticClassProper this.x; // OK, accessed within a class derived from their declaring class super.x; // Error, x is not public ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } } @@ -25,6 +25,6 @@ tests/cases/conformance/classes/members/accessibility/protectedStaticClassProper this.x; // OK, accessed within a class derived from their declaring class super.x; // Error, x is not public ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } } \ No newline at end of file diff --git a/tests/baselines/reference/superAccess.errors.txt b/tests/baselines/reference/superAccess.errors.txt index 64c921e0e7f..f506bb9f136 100644 --- a/tests/baselines/reference/superAccess.errors.txt +++ b/tests/baselines/reference/superAccess.errors.txt @@ -1,6 +1,6 @@ tests/cases/compiler/superAccess.ts(9,24): error TS2339: Property 'S1' does not exist on type 'MyBase'. -tests/cases/compiler/superAccess.ts(10,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/compiler/superAccess.ts(11,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/compiler/superAccess.ts(10,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superAccess.ts(11,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/compiler/superAccess.ts (3 errors) ==== @@ -17,9 +17,9 @@ tests/cases/compiler/superAccess.ts(11,24): error TS2340: Only public and protec !!! error TS2339: Property 'S1' does not exist on type 'MyBase'. var l4 = super.S2; // Expected => Error: Only public instance methods of the base class are accessible via the 'super' keyword ~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. var l5 = super.f(); // Expected => Error: Only public instance methods of the base class are accessible via the 'super' keyword ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } } \ No newline at end of file diff --git a/tests/baselines/reference/superAccess2.errors.txt b/tests/baselines/reference/superAccess2.errors.txt index eda3e29bb0a..d8b39284f65 100644 --- a/tests/baselines/reference/superAccess2.errors.txt +++ b/tests/baselines/reference/superAccess2.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/superAccess2.ts(7,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/compiler/superAccess2.ts(8,17): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +tests/cases/compiler/superAccess2.ts(8,17): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. tests/cases/compiler/superAccess2.ts(8,22): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/compiler/superAccess2.ts(11,28): error TS2336: 'super' cannot be referenced in constructor arguments. tests/cases/compiler/superAccess2.ts(11,33): error TS1034: 'super' must be followed by an argument list or member access. @@ -25,7 +25,7 @@ tests/cases/compiler/superAccess2.ts(21,15): error TS2339: Property 'x' does not !!! error TS1034: 'super' must be followed by an argument list or member access. static yy = super; // error for static initializer accessing super ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. ~ !!! error TS1034: 'super' must be followed by an argument list or member access. diff --git a/tests/baselines/reference/superCallOutsideConstructor.errors.txt b/tests/baselines/reference/superCallOutsideConstructor.errors.txt index 2cdcaad1891..c22c4d33b5d 100644 --- a/tests/baselines/reference/superCallOutsideConstructor.errors.txt +++ b/tests/baselines/reference/superCallOutsideConstructor.errors.txt @@ -1,6 +1,6 @@ -tests/cases/compiler/superCallOutsideConstructor.ts(6,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/compiler/superCallOutsideConstructor.ts(12,13): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors -tests/cases/compiler/superCallOutsideConstructor.ts(16,13): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +tests/cases/compiler/superCallOutsideConstructor.ts(6,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/compiler/superCallOutsideConstructor.ts(12,13): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. +tests/cases/compiler/superCallOutsideConstructor.ts(16,13): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. ==== tests/cases/compiler/superCallOutsideConstructor.ts (3 errors) ==== @@ -11,7 +11,7 @@ tests/cases/compiler/superCallOutsideConstructor.ts(16,13): error TS2337: Super class D extends C { x = super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. constructor() { super(); @@ -19,13 +19,13 @@ tests/cases/compiler/superCallOutsideConstructor.ts(16,13): error TS2337: Super var y = () => { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } var y2 = function() { super(); ~~~~~ -!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors +!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors. } } } diff --git a/tests/baselines/reference/superErrors.errors.txt b/tests/baselines/reference/superErrors.errors.txt index fad592b490c..26e0ba3a6c4 100644 --- a/tests/baselines/reference/superErrors.errors.txt +++ b/tests/baselines/reference/superErrors.errors.txt @@ -4,12 +4,12 @@ tests/cases/compiler/superErrors.ts(4,19): error TS2335: 'super' can only be ref tests/cases/compiler/superErrors.ts(4,24): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/compiler/superErrors.ts(5,31): error TS2335: 'super' can only be referenced in a derived class. tests/cases/compiler/superErrors.ts(5,36): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/compiler/superErrors.ts(22,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class -tests/cases/compiler/superErrors.ts(27,27): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class -tests/cases/compiler/superErrors.ts(31,36): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +tests/cases/compiler/superErrors.ts(22,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. +tests/cases/compiler/superErrors.ts(27,27): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. +tests/cases/compiler/superErrors.ts(31,36): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. tests/cases/compiler/superErrors.ts(31,41): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/compiler/superErrors.ts(39,27): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class -tests/cases/compiler/superErrors.ts(43,36): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +tests/cases/compiler/superErrors.ts(39,27): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. +tests/cases/compiler/superErrors.ts(43,36): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. tests/cases/compiler/superErrors.ts(43,41): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/compiler/superErrors.ts(47,22): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/compiler/superErrors.ts(48,28): error TS1034: 'super' must be followed by an argument list or member access. @@ -52,20 +52,20 @@ tests/cases/compiler/superErrors.ts(49,40): error TS1034: 'super' must be follow function inner() { super.sayHello(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } // super call in a lambda in an inner function in a constructor function inner2() { var x = () => super.sayHello(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } // super call in a lambda in a function expression in a constructor (function() { return () => super; })(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. ~ !!! error TS1034: 'super' must be followed by an argument list or member access. } @@ -77,13 +77,13 @@ tests/cases/compiler/superErrors.ts(49,40): error TS1034: 'super' must be follow function inner() { var x = () => super.sayHello(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } // super call in a lambda in a function expression in a constructor (function() { return () => super; })(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. ~ !!! error TS1034: 'super' must be followed by an argument list or member access. } diff --git a/tests/baselines/reference/superInLambdas.errors.txt b/tests/baselines/reference/superInLambdas.errors.txt index 7587ed82ef1..a3863d00c02 100644 --- a/tests/baselines/reference/superInLambdas.errors.txt +++ b/tests/baselines/reference/superInLambdas.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/superInLambdas.ts(47,49): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/compiler/superInLambdas.ts(51,49): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/compiler/superInLambdas.ts(47,49): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superInLambdas.ts(51,49): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/compiler/superInLambdas.ts(61,34): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/compiler/superInLambdas.ts(65,34): error TS1034: 'super' must be followed by an argument list or member access. @@ -53,13 +53,13 @@ tests/cases/compiler/superInLambdas.ts(65,34): error TS1034: 'super' must be fol // super property in a nested lambda in a constructor var superName = () => () => () => super.name; ~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } sayHello(): void { // super property in a nested lambda in a method var superName = () => () => () => super.name; ~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } } diff --git a/tests/baselines/reference/superPropertyAccess.errors.txt b/tests/baselines/reference/superPropertyAccess.errors.txt index 4880bf66f17..41e0a0adac5 100644 --- a/tests/baselines/reference/superPropertyAccess.errors.txt +++ b/tests/baselines/reference/superPropertyAccess.errors.txt @@ -1,11 +1,11 @@ tests/cases/compiler/superPropertyAccess.ts(8,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/compiler/superPropertyAccess.ts(9,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/superPropertyAccess.ts(22,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/compiler/superPropertyAccess.ts(22,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/compiler/superPropertyAccess.ts(24,9): error TS2341: Property 'p1' is private and only accessible within class 'MyBase'. -tests/cases/compiler/superPropertyAccess.ts(26,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/compiler/superPropertyAccess.ts(28,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/compiler/superPropertyAccess.ts(32,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/compiler/superPropertyAccess.ts(34,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/compiler/superPropertyAccess.ts(26,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(28,24): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(32,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess.ts(34,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/compiler/superPropertyAccess.ts (8 errors) ==== @@ -36,7 +36,7 @@ tests/cases/compiler/superPropertyAccess.ts(34,23): error TS2340: Only public an super.m2.bind(this); // Should error, instance property, not a public instance member function ~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. super.p1(); // Should error, private not public instance member function ~~~~~~~~ @@ -44,20 +44,20 @@ tests/cases/compiler/superPropertyAccess.ts(34,23): error TS2340: Only public an var l1 = super.d1; // Should error, instance data property not a public instance member function ~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. var l1 = super.d2; // Should error, instance data property not a public instance member function ~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. super.m1 = function (a: string) { return ""; }; // Should be allowed, we will not restrict assignment super.value = 0; // Should error, instance data property not a public instance member function ~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. var z = super.value; // Should error, instance data property not a public instance member function ~~~~~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } } \ No newline at end of file diff --git a/tests/baselines/reference/superPropertyAccess1.errors.txt b/tests/baselines/reference/superPropertyAccess1.errors.txt index b256860ec72..aed25fd6a92 100644 --- a/tests/baselines/reference/superPropertyAccess1.errors.txt +++ b/tests/baselines/reference/superPropertyAccess1.errors.txt @@ -1,8 +1,8 @@ tests/cases/compiler/superPropertyAccess1.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/superPropertyAccess1.ts(13,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword -tests/cases/compiler/superPropertyAccess1.ts(19,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/compiler/superPropertyAccess1.ts(13,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. +tests/cases/compiler/superPropertyAccess1.ts(19,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/compiler/superPropertyAccess1.ts(22,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/superPropertyAccess1.ts(24,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/compiler/superPropertyAccess1.ts(24,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. ==== tests/cases/compiler/superPropertyAccess1.ts (5 errors) ==== @@ -22,7 +22,7 @@ tests/cases/compiler/superPropertyAccess1.ts(24,15): error TS2340: Only public a super.bar(); super.x; // error ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } constructor() { @@ -30,7 +30,7 @@ tests/cases/compiler/superPropertyAccess1.ts(24,15): error TS2340: Only public a super.bar(); super.x; // error ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } public get y() { @@ -39,7 +39,7 @@ tests/cases/compiler/superPropertyAccess1.ts(24,15): error TS2340: Only public a super.bar(); super.x; // error ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. return 1; } } \ No newline at end of file diff --git a/tests/baselines/reference/superPropertyAccess2.errors.txt b/tests/baselines/reference/superPropertyAccess2.errors.txt index 475705f1506..2512ad91fae 100644 --- a/tests/baselines/reference/superPropertyAccess2.errors.txt +++ b/tests/baselines/reference/superPropertyAccess2.errors.txt @@ -1,7 +1,7 @@ tests/cases/compiler/superPropertyAccess2.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/compiler/superPropertyAccess2.ts(13,15): error TS2339: Property 'x' does not exist on type 'typeof C'. tests/cases/compiler/superPropertyAccess2.ts(18,15): error TS2339: Property 'bar' does not exist on type 'C'. -tests/cases/compiler/superPropertyAccess2.ts(19,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +tests/cases/compiler/superPropertyAccess2.ts(19,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/compiler/superPropertyAccess2.ts(22,23): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/compiler/superPropertyAccess2.ts(24,15): error TS2339: Property 'x' does not exist on type 'typeof C'. @@ -33,7 +33,7 @@ tests/cases/compiler/superPropertyAccess2.ts(24,15): error TS2339: Property 'x' !!! error TS2339: Property 'bar' does not exist on type 'C'. super.x; // error ~ -!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword +!!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. } public static get y() { diff --git a/tests/baselines/reference/super_inside-object-literal-getters-and-setters.errors.txt b/tests/baselines/reference/super_inside-object-literal-getters-and-setters.errors.txt index 44332e6e567..4f1faf78a78 100644 --- a/tests/baselines/reference/super_inside-object-literal-getters-and-setters.errors.txt +++ b/tests/baselines/reference/super_inside-object-literal-getters-and-setters.errors.txt @@ -4,7 +4,7 @@ tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(7,13): e tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(8,13): error TS2335: 'super' can only be referenced in a derived class. tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(11,20): error TS2335: 'super' can only be referenced in a derived class. tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(20,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(21,24): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(21,24): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. ==== tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts (7 errors) ==== @@ -42,7 +42,7 @@ tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(21,24): !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. return super.test(); ~~~~~ -!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class +!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class. } }; } From 933a2fa6df4345cfd91df7868f69f7cc7f84e5ee Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Fri, 19 Jun 2015 16:00:03 -0700 Subject: [PATCH 152/309] updated baseline for new __extends impl --- tests/baselines/reference/abstractClass1.js | 3 +-- tests/baselines/reference/classAbstractInheritance.js | 3 +-- tests/baselines/reference/classAbstractSuperCalls.js | 3 +-- tests/baselines/reference/classAbstractUsingAbstractMethod.js | 3 +-- tests/baselines/reference/classInstantiatingAbstractClass.js | 3 +-- tests/baselines/reference/classWithAbstractMethods.js | 3 +-- 6 files changed, 6 insertions(+), 12 deletions(-) diff --git a/tests/baselines/reference/abstractClass1.js b/tests/baselines/reference/abstractClass1.js index 494673d6ce0..06868a485f5 100644 --- a/tests/baselines/reference/abstractClass1.js +++ b/tests/baselines/reference/abstractClass1.js @@ -40,8 +40,7 @@ new Copy(); var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; var Foo = (function () { function Foo(f) { diff --git a/tests/baselines/reference/classAbstractInheritance.js b/tests/baselines/reference/classAbstractInheritance.js index 2aa156500e0..6656e4687d2 100644 --- a/tests/baselines/reference/classAbstractInheritance.js +++ b/tests/baselines/reference/classAbstractInheritance.js @@ -25,8 +25,7 @@ abstract class GG extends CC {} var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; var A = (function () { function A() { diff --git a/tests/baselines/reference/classAbstractSuperCalls.js b/tests/baselines/reference/classAbstractSuperCalls.js index 7841785ac05..152fd03f463 100644 --- a/tests/baselines/reference/classAbstractSuperCalls.js +++ b/tests/baselines/reference/classAbstractSuperCalls.js @@ -31,8 +31,7 @@ abstract class BB extends AA { var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; var A = (function () { function A() { diff --git a/tests/baselines/reference/classAbstractUsingAbstractMethod.js b/tests/baselines/reference/classAbstractUsingAbstractMethod.js index 26a406aa008..74bc80b2630 100644 --- a/tests/baselines/reference/classAbstractUsingAbstractMethod.js +++ b/tests/baselines/reference/classAbstractUsingAbstractMethod.js @@ -21,8 +21,7 @@ a.foo(); var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; var A = (function () { function A() { diff --git a/tests/baselines/reference/classInstantiatingAbstractClass.js b/tests/baselines/reference/classInstantiatingAbstractClass.js index 5a23d3d9b40..6a2c3f31e37 100644 --- a/tests/baselines/reference/classInstantiatingAbstractClass.js +++ b/tests/baselines/reference/classInstantiatingAbstractClass.js @@ -31,8 +31,7 @@ var aa = new myA; var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; var A = (function () { function A() { diff --git a/tests/baselines/reference/classWithAbstractMethods.js b/tests/baselines/reference/classWithAbstractMethods.js index 2035ba20ea9..91ccc5f9306 100644 --- a/tests/baselines/reference/classWithAbstractMethods.js +++ b/tests/baselines/reference/classWithAbstractMethods.js @@ -31,8 +31,7 @@ class DD extends AA { var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; var A = (function () { function A() { From 5b32903ab40549efc9cefd4f5f73688dff101a0a Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 19 Jun 2015 16:01:12 -0700 Subject: [PATCH 153/309] Fix async function emit for lexical arguments --- src/compiler/checker.ts | 1 + src/compiler/emitter.ts | 57 +++++++++++-------- src/compiler/types.ts | 9 +-- .../reference/asyncArrowFunction1_es6.js | 2 +- .../reference/asyncArrowFunction6_es6.js | 2 +- .../reference/asyncArrowFunction7_es6.js | 4 +- .../reference/asyncArrowFunction8_es6.js | 2 +- ...asyncArrowFunctionCapturesArguments_es6.js | 2 +- .../asyncArrowFunctionCapturesThis_es6.js | 2 +- .../asyncAwaitIsolatedModules_es6.js | 55 +++++++++--------- tests/baselines/reference/asyncAwait_es6.js | 55 +++++++++--------- .../asyncFunctionDeclaration11_es6.js | 2 +- .../asyncFunctionDeclaration13_es6.js | 2 +- .../asyncFunctionDeclaration14_es6.js | 2 +- .../asyncFunctionDeclaration1_es6.js | 2 +- .../asyncFunctionDeclaration6_es6.js | 2 +- .../asyncFunctionDeclaration7_es6.js | 4 +- .../asyncFunctionDeclaration9_es6.js | 2 +- .../reference/awaitBinaryExpression1_es6.js | 2 +- .../reference/awaitBinaryExpression2_es6.js | 2 +- .../reference/awaitBinaryExpression3_es6.js | 2 +- .../reference/awaitBinaryExpression4_es6.js | 2 +- .../reference/awaitBinaryExpression5_es6.js | 2 +- .../reference/awaitCallExpression1_es6.js | 2 +- .../reference/awaitCallExpression2_es6.js | 2 +- .../reference/awaitCallExpression3_es6.js | 2 +- .../reference/awaitCallExpression4_es6.js | 2 +- .../reference/awaitCallExpression5_es6.js | 2 +- .../reference/awaitCallExpression6_es6.js | 2 +- .../reference/awaitCallExpression7_es6.js | 2 +- .../reference/awaitCallExpression8_es6.js | 2 +- tests/baselines/reference/awaitUnion_es6.js | 2 +- 32 files changed, 122 insertions(+), 113 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 5445c7f919e..53c5e3d8833 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5765,6 +5765,7 @@ namespace ts { if (node.parserContextFlags & ParserContextFlags.Await) { getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments; + getNodeLinks(node).flags |= NodeCheckFlags.LexicalArguments; } } diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index d537380dc5d..a5271b27c2c 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -49,11 +49,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { };`; const awaiterHelper = ` -var __awaiter = (this && this.__awaiter) || function (args, generator) { - var PromiseConstructor = args[1] || Promise; - return new PromiseConstructor(function (resolve, reject) { - generator = generator.call(args[0], args[2]); - function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); } +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promise, generator) { + return new Promise(function (resolve, reject) { + generator = generator.call(thisArg, _arguments); + function cast(value) { return value instanceof Promise && value.constructor === Promise ? value : new Promise(function (resolve) { resolve(value); }); } function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } } function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } } function step(verb, value) { @@ -1239,6 +1238,11 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { } function emitExpressionIdentifier(node: Identifier) { + if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.LexicalArguments) { + write("_arguments"); + return; + } + let container = resolver.getReferencedExportContainer(node); if (container) { if (container.kind === SyntaxKind.SourceFile) { @@ -3374,9 +3378,9 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { // let a = async (b) => { await b; } // // // output - // let a = (b) => __awaiter([this], function* (b) { + // let a = (b) => __awaiter(this, void 0, void 0, function* () { // yield b; - // }, this); + // }); // // The emit for an async arrow with a lexical `arguments` binding might be: // @@ -3384,7 +3388,7 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { // let a = async (b) => { await arguments[0]; } // // // output - // let a = (b) => __awaiter([this, arguments], function* (arguments) { + // let a = (b) => __awaiter(this, arguments, void 0, function* (arguments) { // yield arguments[0]; // }); // @@ -3398,9 +3402,9 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { // // // output // let a = function (b) { - // return __awaiter([this], function* () { + // return __awaiter(this, void 0, void 0, function* () { // yield b; - // }, this); + // }); // } // // The emit for an async function expression with a lexical `arguments` binding @@ -3413,8 +3417,8 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { // // // output // let a = function (b) { - // return __awaiter([this, arguments], function* (arguments) { - // yield arguments[0]; + // return __awaiter(this, arguments, void 0, function* (_arguments) { + // yield _arguments[0]; // }); // } // @@ -3428,8 +3432,8 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { // // // output // let a = function (b) { - // return __awaiter([this, arguments, MyPromise], function* (arguments) { - // yield arguments[0]; + // return __awaiter(this, arguments, MyPromise, function* (_arguments) { + // yield _arguments[0]; // }); // } // @@ -3443,23 +3447,28 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { write("return"); } - write(" __awaiter([this"); - if (promiseConstructor || hasLexicalArguments) { + write(" __awaiter(this"); + if (hasLexicalArguments) { + write(", arguments"); + } + else { + write(", void 0"); + } + + if (promiseConstructor) { write(", "); - if (promiseConstructor) { - emitNodeWithoutSourceMap(promiseConstructor); - } - if (hasLexicalArguments) { - write(", arguments"); - } + emitNodeWithoutSourceMap(promiseConstructor); + } + else { + write(", Promise"); } // Emit the call to __awaiter. if (hasLexicalArguments) { - write("], function* (arguments)"); + write(", function* (_arguments)"); } else { - write("], function* ()"); + write(", function* ()"); } // Emit the signature and body for the inner generator function. diff --git a/src/compiler/types.ts b/src/compiler/types.ts index db2eafe4e53..e55cccc0ccc 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1595,12 +1595,13 @@ namespace ts { SuperInstance = 0x00000100, // Instance 'super' reference SuperStatic = 0x00000200, // Static 'super' reference ContextChecked = 0x00000400, // Contextual types have been assigned - CaptureArguments = 0x00000800, // Lexical 'arguments' used in body (for async functions) + LexicalArguments = 0x00000800, + CaptureArguments = 0x00001000, // Lexical 'arguments' used in body (for async functions) // Values for enum members have been computed, and any errors have been reported for them. - EnumValuesComputed = 0x00001000, - BlockScopedBindingInLoop = 0x00002000, - LexicalModuleMergesWithClass= 0x00004000, // Instantiated lexical module declaration is merged with a previous class declaration. + EnumValuesComputed = 0x00002000, + BlockScopedBindingInLoop = 0x00004000, + LexicalModuleMergesWithClass= 0x00008000, // Instantiated lexical module declaration is merged with a previous class declaration. } /* @internal */ diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js index 2c2f1091b15..4f03acc5ced 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.js +++ b/tests/baselines/reference/asyncArrowFunction1_es6.js @@ -4,5 +4,5 @@ var foo = async (): Promise => { }; //// [asyncArrowFunction1_es6.js] -var foo = () => __awaiter([this, Promise], function* () { +var foo = () => __awaiter(this, void 0, Promise, function* () { }); diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js index 0a39441edf7..54b8aa1f6b1 100644 --- a/tests/baselines/reference/asyncArrowFunction6_es6.js +++ b/tests/baselines/reference/asyncArrowFunction6_es6.js @@ -4,5 +4,5 @@ var foo = async (a = await): Promise => { } //// [asyncArrowFunction6_es6.js] -var foo = (a = yield ) => __awaiter([this, Promise], function* () { +var foo = (a = yield ) => __awaiter(this, void 0, Promise, function* () { }); diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js index bb17963bfd3..ac68a8fd2f8 100644 --- a/tests/baselines/reference/asyncArrowFunction7_es6.js +++ b/tests/baselines/reference/asyncArrowFunction7_es6.js @@ -7,8 +7,8 @@ var bar = async (): Promise => { } //// [asyncArrowFunction7_es6.js] -var bar = () => __awaiter([this, Promise], function* () { +var bar = () => __awaiter(this, void 0, Promise, function* () { // 'await' here is an identifier, and not an await expression. - var foo = (a = yield ) => __awaiter([this, Promise], function* () { + var foo = (a = yield ) => __awaiter(this, void 0, Promise, function* () { }); }); diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js index 2ec23259510..9cee5ee1525 100644 --- a/tests/baselines/reference/asyncArrowFunction8_es6.js +++ b/tests/baselines/reference/asyncArrowFunction8_es6.js @@ -5,6 +5,6 @@ var foo = async (): Promise => { } //// [asyncArrowFunction8_es6.js] -var foo = () => __awaiter([this, Promise], function* () { +var foo = () => __awaiter(this, void 0, Promise, function* () { var v = { [yield ]: foo }; }); diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js index 8cac736ea1b..c24259cf0b5 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js @@ -11,6 +11,6 @@ class C { class C { method() { function other() { } - var fn = () => __awaiter([this, , arguments], function* (arguments) { return yield other.apply(this, arguments); }); + var fn = () => __awaiter(this, arguments, Promise, function* (_arguments) { return yield other.apply(this, _arguments); }); } } diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js index b13815ffcbf..0f09e366ef3 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js +++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js @@ -9,6 +9,6 @@ class C { //// [asyncArrowFunctionCapturesThis_es6.js] class C { method() { - var fn = () => __awaiter([this], function* () { return yield this; }); + var fn = () => __awaiter(this, void 0, Promise, function* () { return yield this; }); } } diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js index 7fb55df0eae..7007c66ae28 100644 --- a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js @@ -40,11 +40,10 @@ module M { } //// [asyncAwaitIsolatedModules_es6.js] -var __awaiter = (this && this.__awaiter) || function (args, generator) { - var PromiseConstructor = args[1] || Promise; - return new PromiseConstructor(function (resolve, reject) { - generator = generator.call(args[0], args[2]); - function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); } +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promise, generator) { + return new Promise(function (resolve, reject) { + generator = generator.call(thisArg, _arguments); + function cast(value) { return value instanceof Promise && value.constructor === Promise ? value : new Promise(function (resolve) { resolve(value); }); } function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } } function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } } function step(verb, value) { @@ -55,65 +54,65 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { }); }; function f0() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } function f1() { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } function f3() { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); } let f4 = function () { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); }; let f5 = function () { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); }; let f6 = function () { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); }; -let f7 = () => __awaiter([this], function* () { }); -let f8 = () => __awaiter([this, Promise], function* () { }); -let f9 = () => __awaiter([this, MyPromise], function* () { }); -let f10 = () => __awaiter([this], function* () { return p; }); -let f11 = () => __awaiter([this], function* () { return mp; }); -let f12 = () => __awaiter([this, Promise], function* () { return mp; }); -let f13 = () => __awaiter([this, MyPromise], function* () { return p; }); +let f7 = () => __awaiter(this, void 0, Promise, function* () { }); +let f8 = () => __awaiter(this, void 0, Promise, function* () { }); +let f9 = () => __awaiter(this, void 0, MyPromise, function* () { }); +let f10 = () => __awaiter(this, void 0, Promise, function* () { return p; }); +let f11 = () => __awaiter(this, void 0, Promise, function* () { return mp; }); +let f12 = () => __awaiter(this, void 0, Promise, function* () { return mp; }); +let f13 = () => __awaiter(this, void 0, MyPromise, function* () { return p; }); let o = { m1() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); }, m2() { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); }, m3() { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); } }; class C { m1() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } m2() { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } m3() { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); } static m4() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } static m5() { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } static m6() { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); } } var M; (function (M) { function f1() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } M.f1 = f1; })(M || (M = {})); diff --git a/tests/baselines/reference/asyncAwait_es6.js b/tests/baselines/reference/asyncAwait_es6.js index 2c0ffaf478a..155a44d339d 100644 --- a/tests/baselines/reference/asyncAwait_es6.js +++ b/tests/baselines/reference/asyncAwait_es6.js @@ -40,11 +40,10 @@ module M { } //// [asyncAwait_es6.js] -var __awaiter = (this && this.__awaiter) || function (args, generator) { - var PromiseConstructor = args[1] || Promise; - return new PromiseConstructor(function (resolve, reject) { - generator = generator.call(args[0], args[2]); - function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); } +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promise, generator) { + return new Promise(function (resolve, reject) { + generator = generator.call(thisArg, _arguments); + function cast(value) { return value instanceof Promise && value.constructor === Promise ? value : new Promise(function (resolve) { resolve(value); }); } function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } } function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } } function step(verb, value) { @@ -55,65 +54,65 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) { }); }; function f0() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } function f1() { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } function f3() { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); } let f4 = function () { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); }; let f5 = function () { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); }; let f6 = function () { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); }; -let f7 = () => __awaiter([this], function* () { }); -let f8 = () => __awaiter([this, Promise], function* () { }); -let f9 = () => __awaiter([this, MyPromise], function* () { }); -let f10 = () => __awaiter([this], function* () { return p; }); -let f11 = () => __awaiter([this], function* () { return mp; }); -let f12 = () => __awaiter([this, Promise], function* () { return mp; }); -let f13 = () => __awaiter([this, MyPromise], function* () { return p; }); +let f7 = () => __awaiter(this, void 0, Promise, function* () { }); +let f8 = () => __awaiter(this, void 0, Promise, function* () { }); +let f9 = () => __awaiter(this, void 0, MyPromise, function* () { }); +let f10 = () => __awaiter(this, void 0, Promise, function* () { return p; }); +let f11 = () => __awaiter(this, void 0, Promise, function* () { return mp; }); +let f12 = () => __awaiter(this, void 0, Promise, function* () { return mp; }); +let f13 = () => __awaiter(this, void 0, MyPromise, function* () { return p; }); let o = { m1() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); }, m2() { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); }, m3() { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); } }; class C { m1() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } m2() { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } m3() { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); } static m4() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } static m5() { - return __awaiter([this, Promise], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } static m6() { - return __awaiter([this, MyPromise], function* () { }); + return __awaiter(this, void 0, MyPromise, function* () { }); } } var M; (function (M) { function f1() { - return __awaiter([this], function* () { }); + return __awaiter(this, void 0, Promise, function* () { }); } M.f1 = f1; })(M || (M = {})); diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js index 7cc10548371..a44343cef78 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js @@ -4,6 +4,6 @@ async function await(): Promise { //// [asyncFunctionDeclaration11_es6.js] function await() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js index f17b5c894f8..4257c8691c2 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js @@ -7,7 +7,7 @@ async function foo(): Promise { //// [asyncFunctionDeclaration13_es6.js] function foo() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { // Legal to use 'await' in a type context. var v; }); diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js index 7fee3f4802a..f32d106f92e 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js @@ -5,7 +5,7 @@ async function foo(): Promise { //// [asyncFunctionDeclaration14_es6.js] function foo() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { return; }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js index 3e587858021..263e27fa35e 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js @@ -4,6 +4,6 @@ async function foo(): Promise { //// [asyncFunctionDeclaration1_es6.js] function foo() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js index 33645996cd8..8c37968ab4c 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js @@ -4,6 +4,6 @@ async function foo(a = await): Promise { //// [asyncFunctionDeclaration6_es6.js] function foo(a = yield ) { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { }); } diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js index 667250e45db..ef66df4e413 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js @@ -7,10 +7,10 @@ async function bar(): Promise { //// [asyncFunctionDeclaration7_es6.js] function bar() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { // 'await' here is an identifier, and not a yield expression. function foo(a = yield ) { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { }); } }); diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js index dab1b75076e..9723a69f2a2 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js @@ -5,7 +5,7 @@ async function foo(): Promise { //// [asyncFunctionDeclaration9_es6.js] function foo() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { var v = { [yield ]: foo }; }); } diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.js b/tests/baselines/reference/awaitBinaryExpression1_es6.js index 11b630355d4..8deb771f5ab 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.js @@ -9,7 +9,7 @@ async function func(): Promise { //// [awaitBinaryExpression1_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = (yield p) || a; "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.js b/tests/baselines/reference/awaitBinaryExpression2_es6.js index e8f610ae10a..506af50a0ef 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.js @@ -9,7 +9,7 @@ async function func(): Promise { //// [awaitBinaryExpression2_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = (yield p) && a; "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.js b/tests/baselines/reference/awaitBinaryExpression3_es6.js index 770bf75d5a1..4b298d7b947 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.js @@ -9,7 +9,7 @@ async function func(): Promise { //// [awaitBinaryExpression3_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = (yield p) + a; "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.js b/tests/baselines/reference/awaitBinaryExpression4_es6.js index f756d6604bb..4d313588984 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.js @@ -9,7 +9,7 @@ async function func(): Promise { //// [awaitBinaryExpression4_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = yield p, a; "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.js b/tests/baselines/reference/awaitBinaryExpression5_es6.js index c66cfbbd57a..01d6c50f6f0 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.js +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.js @@ -10,7 +10,7 @@ async function func(): Promise { //// [awaitBinaryExpression5_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var o; o.a = yield p; diff --git a/tests/baselines/reference/awaitCallExpression1_es6.js b/tests/baselines/reference/awaitCallExpression1_es6.js index db4e0c96abf..f9dad87a8b6 100644 --- a/tests/baselines/reference/awaitCallExpression1_es6.js +++ b/tests/baselines/reference/awaitCallExpression1_es6.js @@ -13,7 +13,7 @@ async function func(): Promise { //// [awaitCallExpression1_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = fn(a, a, a); "after"; diff --git a/tests/baselines/reference/awaitCallExpression2_es6.js b/tests/baselines/reference/awaitCallExpression2_es6.js index 47b1e062ae5..87d99cd0793 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.js +++ b/tests/baselines/reference/awaitCallExpression2_es6.js @@ -13,7 +13,7 @@ async function func(): Promise { //// [awaitCallExpression2_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = fn(yield p, a, a); "after"; diff --git a/tests/baselines/reference/awaitCallExpression3_es6.js b/tests/baselines/reference/awaitCallExpression3_es6.js index e7a09f9b9b8..f397d83c3a1 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.js +++ b/tests/baselines/reference/awaitCallExpression3_es6.js @@ -13,7 +13,7 @@ async function func(): Promise { //// [awaitCallExpression3_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = fn(a, yield p, a); "after"; diff --git a/tests/baselines/reference/awaitCallExpression4_es6.js b/tests/baselines/reference/awaitCallExpression4_es6.js index 59449e4f6a1..d8824d7e7a0 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.js +++ b/tests/baselines/reference/awaitCallExpression4_es6.js @@ -13,7 +13,7 @@ async function func(): Promise { //// [awaitCallExpression4_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = (yield pfn)(a, a, a); "after"; diff --git a/tests/baselines/reference/awaitCallExpression5_es6.js b/tests/baselines/reference/awaitCallExpression5_es6.js index c5e28deee89..f39a633765d 100644 --- a/tests/baselines/reference/awaitCallExpression5_es6.js +++ b/tests/baselines/reference/awaitCallExpression5_es6.js @@ -13,7 +13,7 @@ async function func(): Promise { //// [awaitCallExpression5_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = o.fn(a, a, a); "after"; diff --git a/tests/baselines/reference/awaitCallExpression6_es6.js b/tests/baselines/reference/awaitCallExpression6_es6.js index 62fde8c799c..de8477fa938 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.js +++ b/tests/baselines/reference/awaitCallExpression6_es6.js @@ -13,7 +13,7 @@ async function func(): Promise { //// [awaitCallExpression6_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = o.fn(yield p, a, a); "after"; diff --git a/tests/baselines/reference/awaitCallExpression7_es6.js b/tests/baselines/reference/awaitCallExpression7_es6.js index f717d76c51d..24edc3b9393 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.js +++ b/tests/baselines/reference/awaitCallExpression7_es6.js @@ -13,7 +13,7 @@ async function func(): Promise { //// [awaitCallExpression7_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = o.fn(a, yield p, a); "after"; diff --git a/tests/baselines/reference/awaitCallExpression8_es6.js b/tests/baselines/reference/awaitCallExpression8_es6.js index e6e2cee172b..8bee6112a7a 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.js +++ b/tests/baselines/reference/awaitCallExpression8_es6.js @@ -13,7 +13,7 @@ async function func(): Promise { //// [awaitCallExpression8_es6.js] function func() { - return __awaiter([this, Promise], function* () { + return __awaiter(this, void 0, Promise, function* () { "before"; var b = (yield po).fn(a, a, a); "after"; diff --git a/tests/baselines/reference/awaitUnion_es6.js b/tests/baselines/reference/awaitUnion_es6.js index 7ac556b01bc..80c68f811ef 100644 --- a/tests/baselines/reference/awaitUnion_es6.js +++ b/tests/baselines/reference/awaitUnion_es6.js @@ -14,7 +14,7 @@ async function f() { //// [awaitUnion_es6.js] function f() { - return __awaiter([this], function* () { + return __awaiter(this, void 0, Promise, function* () { let await_a = yield a; let await_b = yield b; let await_c = yield c; From 331b63df7d05c9476b6b9cae97a7a158eba303ca Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Fri, 19 Jun 2015 16:01:27 -0700 Subject: [PATCH 154/309] update LKG --- bin/tsc.js | 83 +++++++++++----- bin/tsserver.js | 134 ++++++++++++++++---------- bin/typescript.d.ts | 14 ++- bin/typescript.js | 182 ++++++++++++++++++++++++------------ bin/typescriptServices.d.ts | 14 ++- bin/typescriptServices.js | 182 ++++++++++++++++++++++++------------ 6 files changed, 415 insertions(+), 194 deletions(-) diff --git a/bin/tsc.js b/bin/tsc.js index e7a41e8aa7e..0aa82496955 100644 --- a/bin/tsc.js +++ b/bin/tsc.js @@ -31,6 +31,36 @@ var ts; /// var ts; (function (ts) { + function createFileMap(getCanonicalFileName) { + var files = {}; + return { + get: get, + set: set, + contains: contains, + remove: remove, + forEachValue: forEachValueInMap + }; + function set(fileName, value) { + files[normalizeKey(fileName)] = value; + } + function get(fileName) { + return files[normalizeKey(fileName)]; + } + function contains(fileName) { + return hasProperty(files, normalizeKey(fileName)); + } + function remove(fileName) { + var key = normalizeKey(fileName); + delete files[key]; + } + function forEachValueInMap(f) { + forEachValue(files, f); + } + function normalizeKey(key) { + return getCanonicalFileName(normalizeSlashes(key)); + } + } + ts.createFileMap = createFileMap; function forEach(array, callback) { if (array) { for (var i = 0, len = array.length; i < len; i++) { @@ -7758,7 +7788,7 @@ var ts; token === 18) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { var name_3 = createMissingNode(65, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_3, undefined); } @@ -8162,7 +8192,7 @@ var ts; case 85: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { + if (decorators || modifiers) { var node = createMissingNode(219, true, ts.Diagnostics.Declaration_expected); node.pos = fullStart; node.decorators = decorators; @@ -8238,7 +8268,7 @@ var ts; } sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { @@ -8849,21 +8879,24 @@ var ts; if (!ts.isExternalModule(location)) break; case 206: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { - if (result.flags & meaning || !(result.flags & 8388608 && getDeclarationOfAliasSymbol(result).kind === 218)) { - break loop; - } - result = undefined; - } - else if (location.kind === 228 || + var moduleExports = getSymbolOfNode(location).exports; + if (location.kind === 228 || (location.kind === 206 && location.name.kind === 8)) { - result = getSymbolOfNode(location).exports["default"]; + if (ts.hasProperty(moduleExports, name) && + moduleExports[name].flags === 8388608 && + ts.getDeclarationOfKind(moduleExports[name], 218)) { + break; + } + result = moduleExports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + if (result = getSymbol(moduleExports, name, meaning & 8914931)) { + break loop; + } break; case 205: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { @@ -24450,10 +24483,10 @@ var ts; emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(true); decreaseIndent(); writeLine(); write("}"); + emitTempDeclarations(true); } function emitSetters(exportStarFunction) { write("setters:["); @@ -24553,7 +24586,11 @@ var ts; collectExternalModuleInfo(node); ts.Debug.assert(!exportFunctionForFile); exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); + } + write("["); for (var i = 0; i < externalImports.length; ++i) { var text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -24626,8 +24663,8 @@ var ts; collectExternalModuleInfo(node); writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, true); write(") {"); @@ -25201,7 +25238,6 @@ var ts; function createProgram(rootNames, options, host) { var program; var files = []; - var filesByName = {}; var diagnostics = ts.createDiagnosticCollection(); var seenNoDefaultLib = options.noLib; var commonSourceDirectory; @@ -25209,6 +25245,7 @@ var ts; var noDiagnosticsTypeChecker; var start = new Date().getTime(); host = host || createCompilerHost(options); + var filesByName = ts.createFileMap(function (fileName) { return host.getCanonicalFileName(fileName); }); ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); if (!seenNoDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); @@ -25264,8 +25301,7 @@ var ts; return emitResult; } function getSourceFile(fileName) { - fileName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile, getDiagnostics) { if (sourceFile) { @@ -25361,16 +25397,16 @@ var ts; } function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - if (ts.hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { return getSourceFileFromCache(fileName, canonicalName, false); } else { var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } - var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } @@ -25378,9 +25414,10 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; - filesByName[canonicalAbsolutePath] = file; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); processReferencedFiles(file, basePath); @@ -25396,7 +25433,7 @@ var ts; return file; } function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { - var file = filesByName[canonicalName]; + var file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { diff --git a/bin/tsserver.js b/bin/tsserver.js index 8536491127d..040eac2ef75 100644 --- a/bin/tsserver.js +++ b/bin/tsserver.js @@ -31,6 +31,36 @@ var ts; /// var ts; (function (ts) { + function createFileMap(getCanonicalFileName) { + var files = {}; + return { + get: get, + set: set, + contains: contains, + remove: remove, + forEachValue: forEachValueInMap + }; + function set(fileName, value) { + files[normalizeKey(fileName)] = value; + } + function get(fileName) { + return files[normalizeKey(fileName)]; + } + function contains(fileName) { + return hasProperty(files, normalizeKey(fileName)); + } + function remove(fileName) { + var key = normalizeKey(fileName); + delete files[key]; + } + function forEachValueInMap(f) { + forEachValue(files, f); + } + function normalizeKey(key) { + return getCanonicalFileName(normalizeSlashes(key)); + } + } + ts.createFileMap = createFileMap; function forEach(array, callback) { if (array) { for (var i = 0, len = array.length; i < len; i++) { @@ -7635,7 +7665,7 @@ var ts; token === 18) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { var name_3 = createMissingNode(65, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_3, undefined); } @@ -8039,7 +8069,7 @@ var ts; case 85: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { + if (decorators || modifiers) { var node = createMissingNode(219, true, ts.Diagnostics.Declaration_expected); node.pos = fullStart; node.decorators = decorators; @@ -8115,7 +8145,7 @@ var ts; } sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { @@ -9239,21 +9269,24 @@ var ts; if (!ts.isExternalModule(location)) break; case 206: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { - if (result.flags & meaning || !(result.flags & 8388608 && getDeclarationOfAliasSymbol(result).kind === 218)) { - break loop; - } - result = undefined; - } - else if (location.kind === 228 || + var moduleExports = getSymbolOfNode(location).exports; + if (location.kind === 228 || (location.kind === 206 && location.name.kind === 8)) { - result = getSymbolOfNode(location).exports["default"]; + if (ts.hasProperty(moduleExports, name) && + moduleExports[name].flags === 8388608 && + ts.getDeclarationOfKind(moduleExports[name], 218)) { + break; + } + result = moduleExports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + if (result = getSymbol(moduleExports, name, meaning & 8914931)) { + break loop; + } break; case 205: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { @@ -24840,10 +24873,10 @@ var ts; emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(true); decreaseIndent(); writeLine(); write("}"); + emitTempDeclarations(true); } function emitSetters(exportStarFunction) { write("setters:["); @@ -24943,7 +24976,11 @@ var ts; collectExternalModuleInfo(node); ts.Debug.assert(!exportFunctionForFile); exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); + } + write("["); for (var i = 0; i < externalImports.length; ++i) { var text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -25016,8 +25053,8 @@ var ts; collectExternalModuleInfo(node); writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, true); write(") {"); @@ -25591,7 +25628,6 @@ var ts; function createProgram(rootNames, options, host) { var program; var files = []; - var filesByName = {}; var diagnostics = ts.createDiagnosticCollection(); var seenNoDefaultLib = options.noLib; var commonSourceDirectory; @@ -25599,6 +25635,7 @@ var ts; var noDiagnosticsTypeChecker; var start = new Date().getTime(); host = host || createCompilerHost(options); + var filesByName = ts.createFileMap(function (fileName) { return host.getCanonicalFileName(fileName); }); ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); if (!seenNoDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); @@ -25654,8 +25691,7 @@ var ts; return emitResult; } function getSourceFile(fileName) { - fileName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile, getDiagnostics) { if (sourceFile) { @@ -25751,16 +25787,16 @@ var ts; } function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - if (ts.hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { return getSourceFileFromCache(fileName, canonicalName, false); } else { var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } - var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } @@ -25768,9 +25804,10 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; - filesByName[canonicalAbsolutePath] = file; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); processReferencedFiles(file, basePath); @@ -25786,7 +25823,7 @@ var ts; return file; } function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { - var file = filesByName[canonicalName]; + var file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { @@ -31308,8 +31345,7 @@ var ts; var HostCache = (function () { function HostCache(host, getCanonicalFileName) { this.host = host; - this.getCanonicalFileName = getCanonicalFileName; - this.fileNameToEntry = {}; + this.fileNameToEntry = ts.createFileMap(getCanonicalFileName); var rootFileNames = host.getScriptFileNames(); for (var _i = 0; _i < rootFileNames.length; _i++) { var fileName = rootFileNames[_i]; @@ -31320,9 +31356,6 @@ var ts; HostCache.prototype.compilationSettings = function () { return this._compilationSettings; }; - HostCache.prototype.normalizeFileName = function (fileName) { - return this.getCanonicalFileName(ts.normalizeSlashes(fileName)); - }; HostCache.prototype.createEntry = function (fileName) { var entry; var scriptSnapshot = this.host.getScriptSnapshot(fileName); @@ -31333,13 +31366,14 @@ var ts; scriptSnapshot: scriptSnapshot }; } - return this.fileNameToEntry[this.normalizeFileName(fileName)] = entry; + this.fileNameToEntry.set(fileName, entry); + return entry; }; HostCache.prototype.getEntry = function (fileName) { - return ts.lookUp(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.get(fileName); }; HostCache.prototype.contains = function (fileName) { - return ts.hasProperty(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.contains(fileName); }; HostCache.prototype.getOrCreateEntry = function (fileName) { if (this.contains(fileName)) { @@ -31348,12 +31382,10 @@ var ts; return this.createEntry(fileName); }; HostCache.prototype.getRootFileNames = function () { - var _this = this; var fileNames = []; - ts.forEachKey(this.fileNameToEntry, function (key) { - var entry = _this.getEntry(key); - if (entry) { - fileNames.push(entry.hostFileName); + this.fileNameToEntry.forEachValue(function (value) { + if (value) { + fileNames.push(value.hostFileName); } }); return fileNames; @@ -31400,7 +31432,7 @@ var ts; sourceFile.version = version; sourceFile.scriptSnapshot = scriptSnapshot; } - function transpile(input, compilerOptions, fileName, diagnostics) { + function transpile(input, compilerOptions, fileName, diagnostics, moduleName) { var options = compilerOptions ? ts.clone(compilerOptions) : getDefaultCompilerOptions(); options.isolatedModules = true; options.allowNonTsExtensions = true; @@ -31408,6 +31440,9 @@ var ts; options.noResolve = true; var inputFileName = fileName || "module.ts"; var sourceFile = ts.createSourceFile(inputFileName, input, options.target); + if (moduleName) { + sourceFile.moduleName = moduleName; + } if (diagnostics && sourceFile.parseDiagnostics) { diagnostics.push.apply(diagnostics, sourceFile.parseDiagnostics); } @@ -31474,8 +31509,14 @@ var ts; return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, true); } ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; - function createDocumentRegistry() { + function createGetCanonicalFileName(useCaseSensitivefileNames) { + return useCaseSensitivefileNames + ? (function (fileName) { return fileName; }) + : (function (fileName) { return fileName.toLowerCase(); }); + } + function createDocumentRegistry(useCaseSensitiveFileNames) { var buckets = {}; + var getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames); function getKeyFromCompilationSettings(settings) { return "_" + settings.target; } @@ -31483,7 +31524,7 @@ var ts; var key = getKeyFromCompilationSettings(settings); var bucket = ts.lookUp(buckets, key); if (!bucket && createIfMissing) { - buckets[key] = bucket = {}; + buckets[key] = bucket = ts.createFileMap(getCanonicalFileName); } return bucket; } @@ -31492,7 +31533,7 @@ var ts; var entries = ts.lookUp(buckets, name); var sourceFiles = []; for (var i in entries) { - var entry = entries[i]; + var entry = entries.get(i); sourceFiles.push({ name: i, refCount: entry.languageServiceRefCount, @@ -31515,15 +31556,16 @@ var ts; } function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) { var bucket = getBucketForCompilationSettings(compilationSettings, true); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); if (!entry) { ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?"); var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false); - bucket[fileName] = entry = { + entry = { sourceFile: sourceFile, languageServiceRefCount: 0, owners: [] }; + bucket.set(fileName, entry); } else { if (entry.sourceFile.version !== version) { @@ -31538,11 +31580,11 @@ var ts; function releaseDocument(fileName, compilationSettings) { var bucket = getBucketForCompilationSettings(compilationSettings, false); ts.Debug.assert(bucket !== undefined); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); entry.languageServiceRefCount--; ts.Debug.assert(entry.languageServiceRefCount >= 0); if (entry.languageServiceRefCount === 0) { - delete bucket[fileName]; + bucket.remove(fileName); } } return { @@ -31887,9 +31929,7 @@ var ts; host.log(message); } } - function getCanonicalFileName(fileName) { - return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); - } + var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames); function getValidSourceFile(fileName) { fileName = ts.normalizeSlashes(fileName); var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); diff --git a/bin/typescript.d.ts b/bin/typescript.d.ts index 50f5c1ade22..11169b6fa28 100644 --- a/bin/typescript.d.ts +++ b/bin/typescript.d.ts @@ -17,6 +17,13 @@ declare module "typescript" { interface Map { [index: string]: T; } + interface FileMap { + get(fileName: string): T; + set(fileName: string, value: T): void; + contains(fileName: string): boolean; + remove(fileName: string): void; + forEachValue(f: (v: T) => void): void; + } interface TextRange { pos: number; end: number; @@ -748,7 +755,7 @@ declare module "typescript" { path: string; name: string; }[]; - amdModuleName: string; + moduleName: string; referencedFiles: FileReference[]; hasNoDefaultLib: boolean; languageVersion: ScriptTarget; @@ -1391,6 +1398,7 @@ declare module "typescript" { log?(s: string): void; trace?(s: string): void; error?(s: string): void; + useCaseSensitiveFileNames?(): boolean; } interface LanguageService { cleanupSemanticCache(): void; @@ -1847,11 +1855,11 @@ declare module "typescript" { isCancellationRequested(): boolean; throwIfCancellationRequested(): void; } - function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string; + function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string; function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile; let disableIncrementalParsing: boolean; function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile; - function createDocumentRegistry(): DocumentRegistry; + function createDocumentRegistry(useCaseSensitiveFileNames?: boolean): DocumentRegistry; function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo; function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService; function createClassifier(): Classifier; diff --git a/bin/typescript.js b/bin/typescript.js index b393f2ee881..c2f23126ea8 100644 --- a/bin/typescript.js +++ b/bin/typescript.js @@ -706,6 +706,36 @@ var ts; Ternary[Ternary["True"] = -1] = "True"; })(ts.Ternary || (ts.Ternary = {})); var Ternary = ts.Ternary; + function createFileMap(getCanonicalFileName) { + var files = {}; + return { + get: get, + set: set, + contains: contains, + remove: remove, + forEachValue: forEachValueInMap + }; + function set(fileName, value) { + files[normalizeKey(fileName)] = value; + } + function get(fileName) { + return files[normalizeKey(fileName)]; + } + function contains(fileName) { + return hasProperty(files, normalizeKey(fileName)); + } + function remove(fileName) { + var key = normalizeKey(fileName); + delete files[key]; + } + function forEachValueInMap(f) { + forEachValue(files, f); + } + function normalizeKey(key) { + return getCanonicalFileName(normalizeSlashes(key)); + } + } + ts.createFileMap = createFileMap; (function (Comparison) { Comparison[Comparison["LessThan"] = -1] = "LessThan"; Comparison[Comparison["EqualTo"] = 0] = "EqualTo"; @@ -9703,7 +9733,7 @@ var ts; token === 18 /* OpenBracketToken */) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { // treat this as a property declaration with a missing name. var name_3 = createMissingNode(65 /* Identifier */, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_3, undefined); @@ -10161,7 +10191,7 @@ var ts; case 85 /* ImportKeyword */: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { + if (decorators || modifiers) { // We reached this point because we encountered an AtToken and assumed a declaration would // follow. For recovery and error reporting purposes, return an incomplete declaration. var node = createMissingNode(219 /* MissingDeclaration */, true, ts.Diagnostics.Declaration_expected); @@ -10242,7 +10272,7 @@ var ts; } sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { @@ -11085,21 +11115,35 @@ var ts; if (!ts.isExternalModule(location)) break; case 206 /* ModuleDeclaration */: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931 /* ModuleMember */)) { - if (result.flags & meaning || !(result.flags & 8388608 /* Alias */ && getDeclarationOfAliasSymbol(result).kind === 218 /* ExportSpecifier */)) { - break loop; - } - result = undefined; - } - else if (location.kind === 228 /* SourceFile */ || + var moduleExports = getSymbolOfNode(location).exports; + if (location.kind === 228 /* SourceFile */ || (location.kind === 206 /* ModuleDeclaration */ && location.name.kind === 8 /* StringLiteral */)) { - result = getSymbolOfNode(location).exports["default"]; + // It's an external module. Because of module/namespace merging, a module's exports are in scope, + // yet we never want to treat an export specifier as putting a member in scope. Therefore, + // if the name we find is purely an export specifier, it is not actually considered in scope. + // Two things to note about this: + // 1. We have to check this without calling getSymbol. The problem with calling getSymbol + // on an export specifier is that it might find the export specifier itself, and try to + // resolve it as an alias. This will cause the checker to consider the export specifier + // a circular alias reference when it might not be. + // 2. We check === SymbolFlags.Alias in order to check that the symbol is *purely* + // an alias. If we used &, we'd be throwing out symbols that have non alias aspects, + // which is not the desired behavior. + if (ts.hasProperty(moduleExports, name) && + moduleExports[name].flags === 8388608 /* Alias */ && + ts.getDeclarationOfKind(moduleExports[name], 218 /* ExportSpecifier */)) { + break; + } + result = moduleExports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + if (result = getSymbol(moduleExports, name, meaning & 8914931 /* ModuleMember */)) { + break loop; + } break; case 205 /* EnumDeclaration */: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8 /* EnumMember */)) { @@ -28972,10 +29016,10 @@ var ts; emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(true); decreaseIndent(); writeLine(); write("}"); // return + emitTempDeclarations(true); } function emitSetters(exportStarFunction) { write("setters:["); @@ -29108,7 +29152,11 @@ var ts; ts.Debug.assert(!exportFunctionForFile); // make sure that name of 'exports' function does not conflict with existing identifiers exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); + } + write("["); for (var i = 0; i < externalImports.length; ++i) { var text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -29188,8 +29236,8 @@ var ts; collectExternalModuleInfo(node); writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, true); write(") {"); @@ -29810,7 +29858,6 @@ var ts; function createProgram(rootNames, options, host) { var program; var files = []; - var filesByName = {}; var diagnostics = ts.createDiagnosticCollection(); var seenNoDefaultLib = options.noLib; var commonSourceDirectory; @@ -29818,6 +29865,7 @@ var ts; var noDiagnosticsTypeChecker; var start = new Date().getTime(); host = host || createCompilerHost(options); + var filesByName = ts.createFileMap(function (fileName) { return host.getCanonicalFileName(fileName); }); ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); if (!seenNoDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); @@ -29883,8 +29931,7 @@ var ts; return emitResult; } function getSourceFile(fileName) { - fileName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile, getDiagnostics) { if (sourceFile) { @@ -29982,18 +30029,18 @@ var ts; // Get source file from normalized fileName function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - if (ts.hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { // We've already looked for this file, use cached result return getSourceFileFromCache(fileName, canonicalName, false); } else { var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } // We haven't looked for this file, do so now and cache result - var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } @@ -30001,10 +30048,11 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; // Set the source file for normalized absolute path - filesByName[canonicalAbsolutePath] = file; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); processReferencedFiles(file, basePath); @@ -30020,7 +30068,7 @@ var ts; return file; } function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { - var file = filesByName[canonicalName]; + var file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { @@ -36625,9 +36673,8 @@ var ts; var HostCache = (function () { function HostCache(host, getCanonicalFileName) { this.host = host; - this.getCanonicalFileName = getCanonicalFileName; // script id => script index - this.fileNameToEntry = {}; + this.fileNameToEntry = ts.createFileMap(getCanonicalFileName); // Initialize the list with the root file names var rootFileNames = host.getScriptFileNames(); for (var _i = 0; _i < rootFileNames.length; _i++) { @@ -36640,9 +36687,6 @@ var ts; HostCache.prototype.compilationSettings = function () { return this._compilationSettings; }; - HostCache.prototype.normalizeFileName = function (fileName) { - return this.getCanonicalFileName(ts.normalizeSlashes(fileName)); - }; HostCache.prototype.createEntry = function (fileName) { var entry; var scriptSnapshot = this.host.getScriptSnapshot(fileName); @@ -36653,13 +36697,14 @@ var ts; scriptSnapshot: scriptSnapshot }; } - return this.fileNameToEntry[this.normalizeFileName(fileName)] = entry; + this.fileNameToEntry.set(fileName, entry); + return entry; }; HostCache.prototype.getEntry = function (fileName) { - return ts.lookUp(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.get(fileName); }; HostCache.prototype.contains = function (fileName) { - return ts.hasProperty(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.contains(fileName); }; HostCache.prototype.getOrCreateEntry = function (fileName) { if (this.contains(fileName)) { @@ -36668,12 +36713,10 @@ var ts; return this.createEntry(fileName); }; HostCache.prototype.getRootFileNames = function () { - var _this = this; var fileNames = []; - ts.forEachKey(this.fileNameToEntry, function (key) { - var entry = _this.getEntry(key); - if (entry) { - fileNames.push(entry.hostFileName); + this.fileNameToEntry.forEachValue(function (value) { + if (value) { + fileNames.push(value.hostFileName); } }); return fileNames; @@ -36733,7 +36776,7 @@ var ts; * - noLib = true * - noResolve = true */ - function transpile(input, compilerOptions, fileName, diagnostics) { + function transpile(input, compilerOptions, fileName, diagnostics, moduleName) { var options = compilerOptions ? ts.clone(compilerOptions) : getDefaultCompilerOptions(); options.isolatedModules = true; // Filename can be non-ts file. @@ -36747,6 +36790,9 @@ var ts; // Parse var inputFileName = fileName || "module.ts"; var sourceFile = ts.createSourceFile(inputFileName, input, options.target); + if (moduleName) { + sourceFile.moduleName = moduleName; + } // Store syntactic diagnostics if (diagnostics && sourceFile.parseDiagnostics) { diagnostics.push.apply(diagnostics, sourceFile.parseDiagnostics); @@ -36829,10 +36875,16 @@ var ts; return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, true); } ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; - function createDocumentRegistry() { + function createGetCanonicalFileName(useCaseSensitivefileNames) { + return useCaseSensitivefileNames + ? (function (fileName) { return fileName; }) + : (function (fileName) { return fileName.toLowerCase(); }); + } + function createDocumentRegistry(useCaseSensitiveFileNames) { // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have // for those settings. var buckets = {}; + var getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames); function getKeyFromCompilationSettings(settings) { return "_" + settings.target; // + "|" + settings.propagateEnumConstantoString() } @@ -36840,7 +36892,7 @@ var ts; var key = getKeyFromCompilationSettings(settings); var bucket = ts.lookUp(buckets, key); if (!bucket && createIfMissing) { - buckets[key] = bucket = {}; + buckets[key] = bucket = ts.createFileMap(getCanonicalFileName); } return bucket; } @@ -36849,7 +36901,7 @@ var ts; var entries = ts.lookUp(buckets, name); var sourceFiles = []; for (var i in entries) { - var entry = entries[i]; + var entry = entries.get(i); sourceFiles.push({ name: i, refCount: entry.languageServiceRefCount, @@ -36872,16 +36924,17 @@ var ts; } function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) { var bucket = getBucketForCompilationSettings(compilationSettings, true); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); if (!entry) { ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?"); // Have never seen this file with these settings. Create a new source file for it. var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false); - bucket[fileName] = entry = { + entry = { sourceFile: sourceFile, languageServiceRefCount: 0, owners: [] }; + bucket.set(fileName, entry); } else { // We have an entry for this file. However, it may be for a different version of @@ -36904,11 +36957,11 @@ var ts; function releaseDocument(fileName, compilationSettings) { var bucket = getBucketForCompilationSettings(compilationSettings, false); ts.Debug.assert(bucket !== undefined); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); entry.languageServiceRefCount--; ts.Debug.assert(entry.languageServiceRefCount >= 0); if (entry.languageServiceRefCount === 0) { - delete bucket[fileName]; + bucket.remove(fileName); } } return { @@ -37305,9 +37358,7 @@ var ts; host.log(message); } } - function getCanonicalFileName(fileName) { - return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); - } + var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames); function getValidSourceFile(fileName) { fileName = ts.normalizeSlashes(fileName); var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); @@ -41901,12 +41952,18 @@ var ts; var LanguageServiceShimHostAdapter = (function () { function LanguageServiceShimHostAdapter(shimHost) { this.shimHost = shimHost; + this.loggingEnabled = false; + this.tracingEnabled = false; } LanguageServiceShimHostAdapter.prototype.log = function (s) { - this.shimHost.log(s); + if (this.loggingEnabled) { + this.shimHost.log(s); + } }; LanguageServiceShimHostAdapter.prototype.trace = function (s) { - this.shimHost.trace(s); + if (this.tracingEnabled) { + this.shimHost.trace(s); + } }; LanguageServiceShimHostAdapter.prototype.error = function (s) { this.shimHost.error(s); @@ -41918,6 +41975,9 @@ var ts; } return this.shimHost.getProjectVersion(); }; + LanguageServiceShimHostAdapter.prototype.useCaseSensitiveFileNames = function () { + return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false; + }; LanguageServiceShimHostAdapter.prototype.getCompilationSettings = function () { var settingsJson = this.shimHost.getCompilationSettings(); if (settingsJson == null || settingsJson == "") { @@ -41985,13 +42045,13 @@ var ts; return CoreServicesShimHostAdapter; })(); ts.CoreServicesShimHostAdapter = CoreServicesShimHostAdapter; - function simpleForwardCall(logger, actionDescription, action, noPerfLogging) { - if (!noPerfLogging) { + function simpleForwardCall(logger, actionDescription, action, logPerformance) { + if (logPerformance) { logger.log(actionDescription); var start = Date.now(); } var result = action(); - if (!noPerfLogging) { + if (logPerformance) { var end = Date.now(); logger.log(actionDescription + " completed in " + (end - start) + " msec"); if (typeof (result) === "string") { @@ -42004,9 +42064,9 @@ var ts; } return result; } - function forwardJSONCall(logger, actionDescription, action, noPerfLogging) { + function forwardJSONCall(logger, actionDescription, action, logPerformance) { try { - var result = simpleForwardCall(logger, actionDescription, action, noPerfLogging); + var result = simpleForwardCall(logger, actionDescription, action, logPerformance); return JSON.stringify({ result: result }); } catch (err) { @@ -42048,10 +42108,11 @@ var ts; _super.call(this, factory); this.host = host; this.languageService = languageService; + this.logPerformance = false; this.logger = this.host; } LanguageServiceShimObject.prototype.forwardJSONCall = function (actionDescription, action) { - return forwardJSONCall(this.logger, actionDescription, action, false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); }; /// DISPOSE /** @@ -42358,12 +42419,12 @@ var ts; function ClassifierShimObject(factory, logger) { _super.call(this, factory); this.logger = logger; + this.logPerformance = false; this.classifier = ts.createClassifier(); } ClassifierShimObject.prototype.getEncodedLexicalClassifications = function (text, lexState, syntacticClassifierAbsent) { var _this = this; - return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, - /*noPerfLogging:*/ true); + return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, this.logPerformance); }; /// COLORIZATION ClassifierShimObject.prototype.getClassificationsForLine = function (text, lexState, classifyKeywordsInGenerics) { @@ -42385,9 +42446,10 @@ var ts; _super.call(this, factory); this.logger = logger; this.host = host; + this.logPerformance = false; } CoreServicesShimObject.prototype.forwardJSONCall = function (actionDescription, action) { - return forwardJSONCall(this.logger, actionDescription, action, false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); }; CoreServicesShimObject.prototype.getPreProcessedFileInfo = function (fileName, sourceTextSnapshot) { return this.forwardJSONCall("getPreProcessedFileInfo('" + fileName + "')", function () { @@ -42444,7 +42506,6 @@ var ts; var TypeScriptServicesFactory = (function () { function TypeScriptServicesFactory() { this._shims = []; - this.documentRegistry = ts.createDocumentRegistry(); } /* * Returns script API version. @@ -42454,6 +42515,9 @@ var ts; }; TypeScriptServicesFactory.prototype.createLanguageServiceShim = function (host) { try { + if (this.documentRegistry === undefined) { + this.documentRegistry = ts.createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames()); + } var hostAdapter = new LanguageServiceShimHostAdapter(host); var languageService = ts.createLanguageService(hostAdapter, this.documentRegistry); return new LanguageServiceShimObject(this, host, languageService); diff --git a/bin/typescriptServices.d.ts b/bin/typescriptServices.d.ts index 558504fcede..ae49ab102ad 100644 --- a/bin/typescriptServices.d.ts +++ b/bin/typescriptServices.d.ts @@ -17,6 +17,13 @@ declare module ts { interface Map { [index: string]: T; } + interface FileMap { + get(fileName: string): T; + set(fileName: string, value: T): void; + contains(fileName: string): boolean; + remove(fileName: string): void; + forEachValue(f: (v: T) => void): void; + } interface TextRange { pos: number; end: number; @@ -748,7 +755,7 @@ declare module ts { path: string; name: string; }[]; - amdModuleName: string; + moduleName: string; referencedFiles: FileReference[]; hasNoDefaultLib: boolean; languageVersion: ScriptTarget; @@ -1391,6 +1398,7 @@ declare module ts { log?(s: string): void; trace?(s: string): void; error?(s: string): void; + useCaseSensitiveFileNames?(): boolean; } interface LanguageService { cleanupSemanticCache(): void; @@ -1847,11 +1855,11 @@ declare module ts { isCancellationRequested(): boolean; throwIfCancellationRequested(): void; } - function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string; + function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string; function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile; let disableIncrementalParsing: boolean; function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile; - function createDocumentRegistry(): DocumentRegistry; + function createDocumentRegistry(useCaseSensitiveFileNames?: boolean): DocumentRegistry; function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo; function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService; function createClassifier(): Classifier; diff --git a/bin/typescriptServices.js b/bin/typescriptServices.js index b393f2ee881..c2f23126ea8 100644 --- a/bin/typescriptServices.js +++ b/bin/typescriptServices.js @@ -706,6 +706,36 @@ var ts; Ternary[Ternary["True"] = -1] = "True"; })(ts.Ternary || (ts.Ternary = {})); var Ternary = ts.Ternary; + function createFileMap(getCanonicalFileName) { + var files = {}; + return { + get: get, + set: set, + contains: contains, + remove: remove, + forEachValue: forEachValueInMap + }; + function set(fileName, value) { + files[normalizeKey(fileName)] = value; + } + function get(fileName) { + return files[normalizeKey(fileName)]; + } + function contains(fileName) { + return hasProperty(files, normalizeKey(fileName)); + } + function remove(fileName) { + var key = normalizeKey(fileName); + delete files[key]; + } + function forEachValueInMap(f) { + forEachValue(files, f); + } + function normalizeKey(key) { + return getCanonicalFileName(normalizeSlashes(key)); + } + } + ts.createFileMap = createFileMap; (function (Comparison) { Comparison[Comparison["LessThan"] = -1] = "LessThan"; Comparison[Comparison["EqualTo"] = 0] = "EqualTo"; @@ -9703,7 +9733,7 @@ var ts; token === 18 /* OpenBracketToken */) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { // treat this as a property declaration with a missing name. var name_3 = createMissingNode(65 /* Identifier */, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_3, undefined); @@ -10161,7 +10191,7 @@ var ts; case 85 /* ImportKeyword */: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { + if (decorators || modifiers) { // We reached this point because we encountered an AtToken and assumed a declaration would // follow. For recovery and error reporting purposes, return an incomplete declaration. var node = createMissingNode(219 /* MissingDeclaration */, true, ts.Diagnostics.Declaration_expected); @@ -10242,7 +10272,7 @@ var ts; } sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { @@ -11085,21 +11115,35 @@ var ts; if (!ts.isExternalModule(location)) break; case 206 /* ModuleDeclaration */: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931 /* ModuleMember */)) { - if (result.flags & meaning || !(result.flags & 8388608 /* Alias */ && getDeclarationOfAliasSymbol(result).kind === 218 /* ExportSpecifier */)) { - break loop; - } - result = undefined; - } - else if (location.kind === 228 /* SourceFile */ || + var moduleExports = getSymbolOfNode(location).exports; + if (location.kind === 228 /* SourceFile */ || (location.kind === 206 /* ModuleDeclaration */ && location.name.kind === 8 /* StringLiteral */)) { - result = getSymbolOfNode(location).exports["default"]; + // It's an external module. Because of module/namespace merging, a module's exports are in scope, + // yet we never want to treat an export specifier as putting a member in scope. Therefore, + // if the name we find is purely an export specifier, it is not actually considered in scope. + // Two things to note about this: + // 1. We have to check this without calling getSymbol. The problem with calling getSymbol + // on an export specifier is that it might find the export specifier itself, and try to + // resolve it as an alias. This will cause the checker to consider the export specifier + // a circular alias reference when it might not be. + // 2. We check === SymbolFlags.Alias in order to check that the symbol is *purely* + // an alias. If we used &, we'd be throwing out symbols that have non alias aspects, + // which is not the desired behavior. + if (ts.hasProperty(moduleExports, name) && + moduleExports[name].flags === 8388608 /* Alias */ && + ts.getDeclarationOfKind(moduleExports[name], 218 /* ExportSpecifier */)) { + break; + } + result = moduleExports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + if (result = getSymbol(moduleExports, name, meaning & 8914931 /* ModuleMember */)) { + break loop; + } break; case 205 /* EnumDeclaration */: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8 /* EnumMember */)) { @@ -28972,10 +29016,10 @@ var ts; emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(true); decreaseIndent(); writeLine(); write("}"); // return + emitTempDeclarations(true); } function emitSetters(exportStarFunction) { write("setters:["); @@ -29108,7 +29152,11 @@ var ts; ts.Debug.assert(!exportFunctionForFile); // make sure that name of 'exports' function does not conflict with existing identifiers exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); + } + write("["); for (var i = 0; i < externalImports.length; ++i) { var text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -29188,8 +29236,8 @@ var ts; collectExternalModuleInfo(node); writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, true); write(") {"); @@ -29810,7 +29858,6 @@ var ts; function createProgram(rootNames, options, host) { var program; var files = []; - var filesByName = {}; var diagnostics = ts.createDiagnosticCollection(); var seenNoDefaultLib = options.noLib; var commonSourceDirectory; @@ -29818,6 +29865,7 @@ var ts; var noDiagnosticsTypeChecker; var start = new Date().getTime(); host = host || createCompilerHost(options); + var filesByName = ts.createFileMap(function (fileName) { return host.getCanonicalFileName(fileName); }); ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); if (!seenNoDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); @@ -29883,8 +29931,7 @@ var ts; return emitResult; } function getSourceFile(fileName) { - fileName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile, getDiagnostics) { if (sourceFile) { @@ -29982,18 +30029,18 @@ var ts; // Get source file from normalized fileName function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - if (ts.hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { // We've already looked for this file, use cached result return getSourceFileFromCache(fileName, canonicalName, false); } else { var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } // We haven't looked for this file, do so now and cache result - var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } @@ -30001,10 +30048,11 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; // Set the source file for normalized absolute path - filesByName[canonicalAbsolutePath] = file; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); processReferencedFiles(file, basePath); @@ -30020,7 +30068,7 @@ var ts; return file; } function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { - var file = filesByName[canonicalName]; + var file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { @@ -36625,9 +36673,8 @@ var ts; var HostCache = (function () { function HostCache(host, getCanonicalFileName) { this.host = host; - this.getCanonicalFileName = getCanonicalFileName; // script id => script index - this.fileNameToEntry = {}; + this.fileNameToEntry = ts.createFileMap(getCanonicalFileName); // Initialize the list with the root file names var rootFileNames = host.getScriptFileNames(); for (var _i = 0; _i < rootFileNames.length; _i++) { @@ -36640,9 +36687,6 @@ var ts; HostCache.prototype.compilationSettings = function () { return this._compilationSettings; }; - HostCache.prototype.normalizeFileName = function (fileName) { - return this.getCanonicalFileName(ts.normalizeSlashes(fileName)); - }; HostCache.prototype.createEntry = function (fileName) { var entry; var scriptSnapshot = this.host.getScriptSnapshot(fileName); @@ -36653,13 +36697,14 @@ var ts; scriptSnapshot: scriptSnapshot }; } - return this.fileNameToEntry[this.normalizeFileName(fileName)] = entry; + this.fileNameToEntry.set(fileName, entry); + return entry; }; HostCache.prototype.getEntry = function (fileName) { - return ts.lookUp(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.get(fileName); }; HostCache.prototype.contains = function (fileName) { - return ts.hasProperty(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.contains(fileName); }; HostCache.prototype.getOrCreateEntry = function (fileName) { if (this.contains(fileName)) { @@ -36668,12 +36713,10 @@ var ts; return this.createEntry(fileName); }; HostCache.prototype.getRootFileNames = function () { - var _this = this; var fileNames = []; - ts.forEachKey(this.fileNameToEntry, function (key) { - var entry = _this.getEntry(key); - if (entry) { - fileNames.push(entry.hostFileName); + this.fileNameToEntry.forEachValue(function (value) { + if (value) { + fileNames.push(value.hostFileName); } }); return fileNames; @@ -36733,7 +36776,7 @@ var ts; * - noLib = true * - noResolve = true */ - function transpile(input, compilerOptions, fileName, diagnostics) { + function transpile(input, compilerOptions, fileName, diagnostics, moduleName) { var options = compilerOptions ? ts.clone(compilerOptions) : getDefaultCompilerOptions(); options.isolatedModules = true; // Filename can be non-ts file. @@ -36747,6 +36790,9 @@ var ts; // Parse var inputFileName = fileName || "module.ts"; var sourceFile = ts.createSourceFile(inputFileName, input, options.target); + if (moduleName) { + sourceFile.moduleName = moduleName; + } // Store syntactic diagnostics if (diagnostics && sourceFile.parseDiagnostics) { diagnostics.push.apply(diagnostics, sourceFile.parseDiagnostics); @@ -36829,10 +36875,16 @@ var ts; return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, true); } ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; - function createDocumentRegistry() { + function createGetCanonicalFileName(useCaseSensitivefileNames) { + return useCaseSensitivefileNames + ? (function (fileName) { return fileName; }) + : (function (fileName) { return fileName.toLowerCase(); }); + } + function createDocumentRegistry(useCaseSensitiveFileNames) { // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have // for those settings. var buckets = {}; + var getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames); function getKeyFromCompilationSettings(settings) { return "_" + settings.target; // + "|" + settings.propagateEnumConstantoString() } @@ -36840,7 +36892,7 @@ var ts; var key = getKeyFromCompilationSettings(settings); var bucket = ts.lookUp(buckets, key); if (!bucket && createIfMissing) { - buckets[key] = bucket = {}; + buckets[key] = bucket = ts.createFileMap(getCanonicalFileName); } return bucket; } @@ -36849,7 +36901,7 @@ var ts; var entries = ts.lookUp(buckets, name); var sourceFiles = []; for (var i in entries) { - var entry = entries[i]; + var entry = entries.get(i); sourceFiles.push({ name: i, refCount: entry.languageServiceRefCount, @@ -36872,16 +36924,17 @@ var ts; } function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) { var bucket = getBucketForCompilationSettings(compilationSettings, true); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); if (!entry) { ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?"); // Have never seen this file with these settings. Create a new source file for it. var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false); - bucket[fileName] = entry = { + entry = { sourceFile: sourceFile, languageServiceRefCount: 0, owners: [] }; + bucket.set(fileName, entry); } else { // We have an entry for this file. However, it may be for a different version of @@ -36904,11 +36957,11 @@ var ts; function releaseDocument(fileName, compilationSettings) { var bucket = getBucketForCompilationSettings(compilationSettings, false); ts.Debug.assert(bucket !== undefined); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); entry.languageServiceRefCount--; ts.Debug.assert(entry.languageServiceRefCount >= 0); if (entry.languageServiceRefCount === 0) { - delete bucket[fileName]; + bucket.remove(fileName); } } return { @@ -37305,9 +37358,7 @@ var ts; host.log(message); } } - function getCanonicalFileName(fileName) { - return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); - } + var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames); function getValidSourceFile(fileName) { fileName = ts.normalizeSlashes(fileName); var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); @@ -41901,12 +41952,18 @@ var ts; var LanguageServiceShimHostAdapter = (function () { function LanguageServiceShimHostAdapter(shimHost) { this.shimHost = shimHost; + this.loggingEnabled = false; + this.tracingEnabled = false; } LanguageServiceShimHostAdapter.prototype.log = function (s) { - this.shimHost.log(s); + if (this.loggingEnabled) { + this.shimHost.log(s); + } }; LanguageServiceShimHostAdapter.prototype.trace = function (s) { - this.shimHost.trace(s); + if (this.tracingEnabled) { + this.shimHost.trace(s); + } }; LanguageServiceShimHostAdapter.prototype.error = function (s) { this.shimHost.error(s); @@ -41918,6 +41975,9 @@ var ts; } return this.shimHost.getProjectVersion(); }; + LanguageServiceShimHostAdapter.prototype.useCaseSensitiveFileNames = function () { + return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false; + }; LanguageServiceShimHostAdapter.prototype.getCompilationSettings = function () { var settingsJson = this.shimHost.getCompilationSettings(); if (settingsJson == null || settingsJson == "") { @@ -41985,13 +42045,13 @@ var ts; return CoreServicesShimHostAdapter; })(); ts.CoreServicesShimHostAdapter = CoreServicesShimHostAdapter; - function simpleForwardCall(logger, actionDescription, action, noPerfLogging) { - if (!noPerfLogging) { + function simpleForwardCall(logger, actionDescription, action, logPerformance) { + if (logPerformance) { logger.log(actionDescription); var start = Date.now(); } var result = action(); - if (!noPerfLogging) { + if (logPerformance) { var end = Date.now(); logger.log(actionDescription + " completed in " + (end - start) + " msec"); if (typeof (result) === "string") { @@ -42004,9 +42064,9 @@ var ts; } return result; } - function forwardJSONCall(logger, actionDescription, action, noPerfLogging) { + function forwardJSONCall(logger, actionDescription, action, logPerformance) { try { - var result = simpleForwardCall(logger, actionDescription, action, noPerfLogging); + var result = simpleForwardCall(logger, actionDescription, action, logPerformance); return JSON.stringify({ result: result }); } catch (err) { @@ -42048,10 +42108,11 @@ var ts; _super.call(this, factory); this.host = host; this.languageService = languageService; + this.logPerformance = false; this.logger = this.host; } LanguageServiceShimObject.prototype.forwardJSONCall = function (actionDescription, action) { - return forwardJSONCall(this.logger, actionDescription, action, false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); }; /// DISPOSE /** @@ -42358,12 +42419,12 @@ var ts; function ClassifierShimObject(factory, logger) { _super.call(this, factory); this.logger = logger; + this.logPerformance = false; this.classifier = ts.createClassifier(); } ClassifierShimObject.prototype.getEncodedLexicalClassifications = function (text, lexState, syntacticClassifierAbsent) { var _this = this; - return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, - /*noPerfLogging:*/ true); + return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, this.logPerformance); }; /// COLORIZATION ClassifierShimObject.prototype.getClassificationsForLine = function (text, lexState, classifyKeywordsInGenerics) { @@ -42385,9 +42446,10 @@ var ts; _super.call(this, factory); this.logger = logger; this.host = host; + this.logPerformance = false; } CoreServicesShimObject.prototype.forwardJSONCall = function (actionDescription, action) { - return forwardJSONCall(this.logger, actionDescription, action, false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); }; CoreServicesShimObject.prototype.getPreProcessedFileInfo = function (fileName, sourceTextSnapshot) { return this.forwardJSONCall("getPreProcessedFileInfo('" + fileName + "')", function () { @@ -42444,7 +42506,6 @@ var ts; var TypeScriptServicesFactory = (function () { function TypeScriptServicesFactory() { this._shims = []; - this.documentRegistry = ts.createDocumentRegistry(); } /* * Returns script API version. @@ -42454,6 +42515,9 @@ var ts; }; TypeScriptServicesFactory.prototype.createLanguageServiceShim = function (host) { try { + if (this.documentRegistry === undefined) { + this.documentRegistry = ts.createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames()); + } var hostAdapter = new LanguageServiceShimHostAdapter(host); var languageService = ts.createLanguageService(hostAdapter, this.documentRegistry); return new LanguageServiceShimObject(this, host, languageService); From 24da34c4ad7a2b1fd5fe6fbb66016809c382fd4b Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Fri, 19 Jun 2015 16:20:00 -0700 Subject: [PATCH 155/309] fixed some indentation quirks, comments --- src/compiler/checker.ts | 53 +++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 29 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3b9b0301fb8..bf455b87e08 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2003,7 +2003,7 @@ namespace ts { // If the binding pattern is empty, this variable declaration is not visible return false; } - // Otherwise fall through + // Otherwise fall through case SyntaxKind.ModuleDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: @@ -4585,9 +4585,7 @@ namespace ts { let sourceProp = getPropertyOfType(source, targetProp.name); if (sourceProp === targetProp) { // source inherits targetProp and doesn't redeclare/override it. - if (source.flags & TypeFlags.Class && target.flags & TypeFlags.Class) { - let targetPropFlags = getDeclarationFlagsFromSymbol(targetProp); let sourceDecl = getDeclarationOfKind(source.symbol, SyntaxKind.ClassDeclaration); @@ -6035,20 +6033,20 @@ namespace ts { if (container && container.parent && container.parent.kind === SyntaxKind.ClassDeclaration) { if (container.flags & NodeFlags.Static) { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor; } else { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor || - container.kind === SyntaxKind.PropertyDeclaration || - container.kind === SyntaxKind.PropertySignature || - container.kind === SyntaxKind.Constructor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor || + container.kind === SyntaxKind.PropertyDeclaration || + container.kind === SyntaxKind.PropertySignature || + container.kind === SyntaxKind.Constructor; } } } @@ -7666,7 +7664,7 @@ namespace ts { /** * Performs typechecking on the given node, which is a call/new expression. * @param node The call expression to be checked. - * @returns On success, the expression's signature's return type. On failure, any. + * @returns On success, the expression's signature's return type. On failure, anyType. */ function checkCallExpression(node: CallExpression): Type { // Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true @@ -8166,8 +8164,8 @@ namespace ts { let type = isTypeAny(sourceType) ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || - getIndexTypeOfType(sourceType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || + getIndexTypeOfType(sourceType, IndexKind.String); if (type) { checkDestructuringAssignment((p).initializer || name, type); } @@ -8355,7 +8353,7 @@ namespace ts { if (!checkForDisallowedESSymbolOperand(operator)) { return booleanType; } - // fall-through + // Otherwise fall through case SyntaxKind.EqualsEqualsToken: case SyntaxKind.ExclamationEqualsToken: case SyntaxKind.EqualsEqualsEqualsToken: @@ -9578,7 +9576,7 @@ namespace ts { case SyntaxKind.MethodDeclaration: checkParameterTypeAnnotationsAsExpressions(node); - // fall-through + // Otherwise fall through case SyntaxKind.SetAccessor: case SyntaxKind.GetAccessor: @@ -10705,8 +10703,6 @@ namespace ts { checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); - - if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class)) { // When the static base type is a "class-like" constructor function (but not actually a class), we verify // that all instantiated base constructor signatures return the same type. We can simply compare the type @@ -10798,7 +10794,6 @@ namespace ts { error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2, typeToString(type), typeToString(baseType), symbolToString(baseProperty)); } - } else { // derived !== undefined -- derived overrides base let derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived); if ((baseDeclarationFlags & NodeFlags.Private) || (derivedDeclarationFlags & NodeFlags.Private)) { @@ -12088,7 +12083,7 @@ namespace ts { (node.parent).moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } - // fall-through + // Otherwise fall through case SyntaxKind.NumericLiteral: // index access @@ -12261,7 +12256,7 @@ namespace ts { if (links.isNestedRedeclaration === undefined) { let container = getEnclosingBlockScopeContainer(symbol.valueDeclaration); links.isNestedRedeclaration = isStatementWithLocals(container) && - !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); + !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); } return links.isNestedRedeclaration; } @@ -12512,11 +12507,11 @@ namespace ts { // // For rules on serializing type annotations, see `serializeTypeNode`. switch (node.kind) { - case SyntaxKind.ClassDeclaration: return "Function"; - case SyntaxKind.PropertyDeclaration: return serializeTypeNode((node).type); - case SyntaxKind.Parameter: return serializeTypeNode((node).type); - case SyntaxKind.GetAccessor: return serializeTypeNode((node).type); - case SyntaxKind.SetAccessor: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node)); + case SyntaxKind.ClassDeclaration: return "Function"; + case SyntaxKind.PropertyDeclaration: return serializeTypeNode((node).type); + case SyntaxKind.Parameter: return serializeTypeNode((node).type); + case SyntaxKind.GetAccessor: return serializeTypeNode((node).type); + case SyntaxKind.SetAccessor: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node)); } if (isFunctionLike(node)) { return "Function"; From 9ab6f4189047485b13a2eee677a61b38a647fe61 Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Fri, 19 Jun 2015 17:34:10 -0700 Subject: [PATCH 156/309] Fix the issue that the "out" path is not relative to the path of tsconfig.json --- src/compiler/commandLineParser.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 07bccf4a5ef..4e401c5c9b3 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -110,6 +110,7 @@ namespace ts { { name: "out", type: "string", + isFilePath: true, description: Diagnostics.Concatenate_and_emit_output_to_single_file, paramType: Diagnostics.FILE, }, From 76c0d32f9da2a378f12e427b52edade900576915 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 19 Jun 2015 18:05:43 -0700 Subject: [PATCH 157/309] Moved async functions for ES6 behind experimental flag --- src/compiler/checker.ts | 4 ++++ src/compiler/commandLineParser.ts | 5 +++++ src/compiler/diagnosticInformationMap.generated.ts | 3 +++ src/compiler/diagnosticMessages.json | 12 ++++++++++++ src/compiler/program.ts | 7 ++++++- src/compiler/types.ts | 1 + src/harness/harness.ts | 4 ++++ .../asyncArrowFunction/asyncArrowFunction10_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction1_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction2_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction3_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction4_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction5_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction6_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction7_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction8_es6.ts | 1 + .../asyncArrowFunction/asyncArrowFunction9_es6.ts | 1 + .../asyncArrowFunctionCapturesArguments_es6.ts | 1 + .../asyncArrowFunctionCapturesThis_es6.ts | 1 + .../async/es6/asyncAwaitIsolatedModules_es6.ts | 1 + tests/cases/conformance/async/es6/asyncAwait_es6.ts | 1 + tests/cases/conformance/async/es6/asyncClass_es6.ts | 1 + .../conformance/async/es6/asyncConstructor_es6.ts | 1 + .../cases/conformance/async/es6/asyncDeclare_es6.ts | 1 + tests/cases/conformance/async/es6/asyncEnum_es6.ts | 1 + tests/cases/conformance/async/es6/asyncGetter_es6.ts | 1 + .../conformance/async/es6/asyncInterface_es6.ts | 1 + tests/cases/conformance/async/es6/asyncModule_es6.ts | 1 + tests/cases/conformance/async/es6/asyncSetter_es6.ts | 1 + .../awaitBinaryExpression1_es6.ts | 1 + .../awaitBinaryExpression2_es6.ts | 1 + .../awaitBinaryExpression3_es6.ts | 1 + .../awaitBinaryExpression4_es6.ts | 1 + .../awaitBinaryExpression5_es6.ts | 1 + .../awaitCallExpression/awaitCallExpression1_es6.ts | 1 + .../awaitCallExpression/awaitCallExpression2_es6.ts | 1 + .../awaitCallExpression/awaitCallExpression3_es6.ts | 1 + .../awaitCallExpression/awaitCallExpression4_es6.ts | 1 + .../awaitCallExpression/awaitCallExpression5_es6.ts | 1 + .../awaitCallExpression/awaitCallExpression6_es6.ts | 1 + .../awaitCallExpression/awaitCallExpression7_es6.ts | 1 + .../awaitCallExpression/awaitCallExpression8_es6.ts | 1 + tests/cases/conformance/async/es6/awaitUnion_es6.ts | 1 + .../asyncFunctionDeclaration10_es6.ts | 1 + .../asyncFunctionDeclaration11_es6.ts | 1 + .../asyncFunctionDeclaration12_es6.ts | 1 + .../asyncFunctionDeclaration13_es6.ts | 1 + .../asyncFunctionDeclaration14_es6.ts | 1 + .../asyncFunctionDeclaration1_es6.ts | 1 + .../asyncFunctionDeclaration2_es6.ts | 1 + .../asyncFunctionDeclaration3_es6.ts | 1 + .../asyncFunctionDeclaration4_es6.ts | 1 + .../asyncFunctionDeclaration5_es6.ts | 1 + .../asyncFunctionDeclaration6_es6.ts | 1 + .../asyncFunctionDeclaration7_es6.ts | 1 + .../asyncFunctionDeclaration8_es6.ts | 1 + .../asyncFunctionDeclaration9_es6.ts | 1 + 57 files changed, 85 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 53c5e3d8833..87b5ac44dce 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9863,6 +9863,10 @@ namespace ts { checkSignatureDeclaration(node); let isAsync = isAsyncFunctionLike(node); if (isAsync) { + if (!compilerOptions.experimentalAsyncFunctions) { + error(node, Diagnostics.Experimental_support_for_async_functions_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalAsyncFunctions_to_remove_this_warning); + } + emitAwaiter = true; } diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 07bccf4a5ef..f2b7dcc91c1 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -192,6 +192,11 @@ namespace ts { type: "boolean", description: Diagnostics.Watch_input_files, }, + { + name: "experimentalAsyncFunctions", + type: "boolean", + description: Diagnostics.Enables_experimental_support_for_ES7_async_functions + }, { name: "experimentalDecorators", type: "boolean", diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 6cd9a803aa4..beb35eec9bf 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -201,6 +201,7 @@ namespace ts { An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, + Experimental_support_for_async_functions_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalAsyncFunctions_to_remove_this_warning: { code: 1236, category: DiagnosticCategory.Error, key: "Experimental support for async functions is a feature that is subject to change in a future release. Specify '--experimentalAsyncFunctions' to remove this warning." }, with_statements_are_not_allowed_in_an_async_function_block: { code: 1300, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in an async function block." }, await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: DiagnosticCategory.Error, key: "'await' expression is only allowed within an async function." }, Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: DiagnosticCategory.Error, key: "Async functions are only available when targeting ECMAScript 6 and higher." }, @@ -547,6 +548,8 @@ namespace ts { Option_experimentalDecorators_must_also_be_specified_when_option_emitDecoratorMetadata_is_specified: { code: 6064, category: DiagnosticCategory.Error, key: "Option 'experimentalDecorators' must also be specified when option 'emitDecoratorMetadata' is specified." }, Enables_experimental_support_for_ES7_decorators: { code: 6065, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 decorators." }, Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: DiagnosticCategory.Message, key: "Enables experimental support for emitting type metadata for decorators." }, + Option_experimentalAsyncFunctions_cannot_be_specified_when_targeting_ES5_or_lower: { code: 6067, category: DiagnosticCategory.Message, key: "Option 'experimentalAsyncFunctions' cannot be specified when targeting ES5 or lower." }, + Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 async functions." }, Variable_0_implicitly_has_an_1_type: { code: 7005, category: DiagnosticCategory.Error, key: "Variable '{0}' implicitly has an '{1}' type." }, Parameter_0_implicitly_has_an_1_type: { code: 7006, category: DiagnosticCategory.Error, key: "Parameter '{0}' implicitly has an '{1}' type." }, Member_0_implicitly_has_an_1_type: { code: 7008, category: DiagnosticCategory.Error, key: "Member '{0}' implicitly has an '{1}' type." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 4ad7408d70d..089ddb6a83e 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -791,6 +791,10 @@ "category": "Error", "code": 1235 }, + "Experimental support for async functions is a feature that is subject to change in a future release. Specify '--experimentalAsyncFunctions' to remove this warning.": { + "category": "Error", + "code": 1236 + }, "'with' statements are not allowed in an async function block.": { @@ -2180,6 +2184,14 @@ "category": "Message", "code": 6066 }, + "Option 'experimentalAsyncFunctions' cannot be specified when targeting ES5 or lower.": { + "category": "Message", + "code": 6067 + }, + "Enables experimental support for ES7 async functions.": { + "category": "Message", + "code": 6068 + }, "Variable '{0}' implicitly has an '{1}' type.": { "category": "Error", diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 562654c2ed0..4484addd84e 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -144,7 +144,7 @@ namespace ts { let program: Program; let files: SourceFile[] = []; let diagnostics = createDiagnosticCollection(); - + let commonSourceDirectory: string; let diagnosticsProducingTypeChecker: TypeChecker; let noDiagnosticsTypeChecker: TypeChecker; @@ -676,6 +676,11 @@ namespace ts { !options.experimentalDecorators) { diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_experimentalDecorators_must_also_be_specified_when_option_emitDecoratorMetadata_is_specified)); } + + if (options.experimentalAsyncFunctions && + options.target !== ScriptTarget.ES6) { + diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_experimentalAsyncFunctions_cannot_be_specified_when_targeting_ES5_or_lower)); + } } } } \ No newline at end of file diff --git a/src/compiler/types.ts b/src/compiler/types.ts index e55cccc0ccc..3d9d4151079 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1878,6 +1878,7 @@ namespace ts { watch?: boolean; isolatedModules?: boolean; experimentalDecorators?: boolean; + experimentalAsyncFunctions?: boolean; emitDecoratorMetadata?: boolean; /* @internal */ stripInternal?: boolean; diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 6a559488150..8e8fb8d9acb 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -1055,6 +1055,10 @@ module Harness { case 'emitdecoratormetadata': options.emitDecoratorMetadata = setting.value === 'true'; break; + + case 'experimentalasyncfunctions': + options.experimentalAsyncFunctions = setting.value === 'true'; + break; case 'noemithelpers': options.noEmitHelpers = setting.value === 'true'; diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts index 0959ed6c561..bb9f8a54e44 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var foo = async foo(): Promise => { // Legal to use 'await' in a type context. diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts index 83e7413c527..45e686fd280 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var foo = async (): Promise => { }; \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts index bf39735d460..8d792fdff9c 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var f = (await) => { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts index 4ae27c596f1..9ca200f8d76 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true function f(await = await) { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts index 51b34abeca1..4946592c45b 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var await = () => { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts index 174a619bdf9..53052368b31 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var foo = async (await): Promise => { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts index dace96c4933..69768429ecf 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var foo = async (a = await): Promise => { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts index b1fd5cc030d..a034381ba57 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var bar = async (): Promise => { // 'await' here is an identifier, and not an await expression. diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts index 5d53338b1bd..397e06f703d 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var foo = async (): Promise => { var v = { [await]: foo } diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts index da041fe472b..3f961c9d595 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var foo = async (a = await => await): Promise => { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts index 8dab2c04086..f00d0d16545 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true class C { method() { function other() {} diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts index f2c507cbdd6..a90f08cb9f7 100644 --- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts +++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true class C { method() { var fn = async () => await this; diff --git a/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts b/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts index 8e2cfd8c6c5..52694f24118 100644 --- a/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts +++ b/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @isolatedModules: true +// @experimentalAsyncFunctions: true import { MyPromise } from "missing"; declare var p: Promise; diff --git a/tests/cases/conformance/async/es6/asyncAwait_es6.ts b/tests/cases/conformance/async/es6/asyncAwait_es6.ts index 8e72197a98d..eee2e73d023 100644 --- a/tests/cases/conformance/async/es6/asyncAwait_es6.ts +++ b/tests/cases/conformance/async/es6/asyncAwait_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 +// @experimentalAsyncFunctions: true type MyPromise = Promise; declare var MyPromise: typeof Promise; declare var p: Promise; diff --git a/tests/cases/conformance/async/es6/asyncClass_es6.ts b/tests/cases/conformance/async/es6/asyncClass_es6.ts index 22ffe997b03..c4a444ca909 100644 --- a/tests/cases/conformance/async/es6/asyncClass_es6.ts +++ b/tests/cases/conformance/async/es6/asyncClass_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async class C { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncConstructor_es6.ts b/tests/cases/conformance/async/es6/asyncConstructor_es6.ts index d769fad0395..998156f19f4 100644 --- a/tests/cases/conformance/async/es6/asyncConstructor_es6.ts +++ b/tests/cases/conformance/async/es6/asyncConstructor_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true class C { async constructor() { } diff --git a/tests/cases/conformance/async/es6/asyncDeclare_es6.ts b/tests/cases/conformance/async/es6/asyncDeclare_es6.ts index 5e0fb536b39..d83c25a421a 100644 --- a/tests/cases/conformance/async/es6/asyncDeclare_es6.ts +++ b/tests/cases/conformance/async/es6/asyncDeclare_es6.ts @@ -1,3 +1,4 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare async function foo(): Promise; \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncEnum_es6.ts b/tests/cases/conformance/async/es6/asyncEnum_es6.ts index 4fad7923a8c..d9569bef9d1 100644 --- a/tests/cases/conformance/async/es6/asyncEnum_es6.ts +++ b/tests/cases/conformance/async/es6/asyncEnum_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async enum E { Value } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncGetter_es6.ts b/tests/cases/conformance/async/es6/asyncGetter_es6.ts index 79fde60fdc4..fe5751ece0b 100644 --- a/tests/cases/conformance/async/es6/asyncGetter_es6.ts +++ b/tests/cases/conformance/async/es6/asyncGetter_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true class C { async get foo() { } diff --git a/tests/cases/conformance/async/es6/asyncInterface_es6.ts b/tests/cases/conformance/async/es6/asyncInterface_es6.ts index 5d5497d3cd4..c7bb460ea2b 100644 --- a/tests/cases/conformance/async/es6/asyncInterface_es6.ts +++ b/tests/cases/conformance/async/es6/asyncInterface_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async interface I { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncModule_es6.ts b/tests/cases/conformance/async/es6/asyncModule_es6.ts index aa4c295d0e3..cf660d25d1f 100644 --- a/tests/cases/conformance/async/es6/asyncModule_es6.ts +++ b/tests/cases/conformance/async/es6/asyncModule_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async module M { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/asyncSetter_es6.ts b/tests/cases/conformance/async/es6/asyncSetter_es6.ts index 8eedcbb5288..2ca1c805a45 100644 --- a/tests/cases/conformance/async/es6/asyncSetter_es6.ts +++ b/tests/cases/conformance/async/es6/asyncSetter_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true class C { async set foo(value) { } diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts index 46060f309b2..df0d0e459d4 100644 --- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; async function func(): Promise { diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts index 362f1ecc446..7678c4b17ab 100644 --- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; async function func(): Promise { diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts index d3b02033252..0b441f063dd 100644 --- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: number; declare var p: Promise; async function func(): Promise { diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts index eba3be31acf..a0bdf58710f 100644 --- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; async function func(): Promise { diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts index 71b173f9e73..3276d24ee4b 100644 --- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts +++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; async function func(): Promise { diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts index d0442f0968d..02de646112c 100644 --- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts index 6de07ef12ff..5d2e4046349 100644 --- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts index 2cc0b7b12d0..702e1f4cbcc 100644 --- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts index 8e349fbc5c3..aeeb192b4ba 100644 --- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts index bbe81ac94b1..82bb1f88ad2 100644 --- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts index 09e88f5acbc..d5778df71ba 100644 --- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts index fe0182da4aa..db01f34c825 100644 --- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts index e3280eb7c10..b0b10a02a6f 100644 --- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts +++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare var a: boolean; declare var p: Promise; declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; diff --git a/tests/cases/conformance/async/es6/awaitUnion_es6.ts b/tests/cases/conformance/async/es6/awaitUnion_es6.ts index a132ae01dfd..59c5285556c 100644 --- a/tests/cases/conformance/async/es6/awaitUnion_es6.ts +++ b/tests/cases/conformance/async/es6/awaitUnion_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true declare let a: number | string; declare let b: PromiseLike | PromiseLike; declare let c: PromiseLike; diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts index aab1f0013ec..d543e424a38 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function foo(a = await => await): Promise { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts index 747d20d7ea8..23e40a0e5ba 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function await(): Promise { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts index bbd77250365..a457d27073f 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts @@ -1,3 +1,4 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var v = async function await(): Promise { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts index 8670fa02811..83b6a99579c 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function foo(): Promise { // Legal to use 'await' in a type context. var v: await; diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts index ba70c61b492..b837e6618d1 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function foo(): Promise { return; } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts index 289a65bb74f..3a792140011 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function foo(): Promise { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts index 25a153b4a34..e75ef1d36a3 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true function f(await) { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts index 4ae27c596f1..9ca200f8d76 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true function f(await = await) { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts index 5d1ec389da3..ac4447a0e4d 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true function await() { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts index eb3cd1db556..60a0a8f4b74 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function foo(await): Promise { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts index 89b0445fd2e..a3ab64b9d29 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts @@ -1,4 +1,5 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function foo(a = await): Promise { } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts index 5a964695da5..cde12c7dbe3 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function bar(): Promise { // 'await' here is an identifier, and not a yield expression. async function foo(a = await): Promise { diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts index 764b0f3fb8a..52b6dba2792 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts @@ -1,3 +1,4 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true var v = { [await]: foo } \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts index 7671764ad2a..662fa017606 100644 --- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts @@ -1,5 +1,6 @@ // @target: ES6 // @noEmitHelpers: true +// @experimentalAsyncFunctions: true async function foo(): Promise { var v = { [await]: foo } } \ No newline at end of file From 138970f35fc3d410761d3fbe449c813b4acb1c3c Mon Sep 17 00:00:00 2001 From: jbondc Date: Tue, 16 Jun 2015 22:00:42 -0400 Subject: [PATCH 158/309] Fixes #2632 (invoking methods on numbers) --- .../diagnosticInformationMap.generated.ts | 1 + src/compiler/diagnosticMessages.json | 4 ++ src/compiler/parser.ts | 41 ++++++++++++++----- src/compiler/types.ts | 3 +- tests/baselines/reference/numLit.errors.txt | 27 ++++++++---- tests/baselines/reference/numLit.js | 28 +++++++++++-- tests/cases/compiler/numLit.ts | 15 ++++++- 7 files changed, 93 insertions(+), 26 deletions(-) diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 09b009711fe..46976813120 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -569,5 +569,6 @@ namespace ts { decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." }, + Numeric_literal_0_cannot_be_followed_by_an_expression: { code: 9004, category: DiagnosticCategory.Error, key: "Numeric literal {0} cannot be followed by an expression." }, }; } \ No newline at end of file diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index fee46a84c1e..4b705396fe5 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2268,5 +2268,9 @@ "'class' expressions are not currently supported.": { "category": "Error", "code": 9003 + }, + "Numeric literal {0} cannot be followed by an expression.": { + "category": "Error", + "code": 9004 } } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index fbb3dad5037..55fdcd91d34 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -100,6 +100,8 @@ namespace ts { visitNode(cbNode, (node).type) || visitNode(cbNode, (node).equalsGreaterThanToken) || visitNode(cbNode, (node).body); + case SyntaxKind.NumericLiteral: + return visitNode(cbNode, (node).invalidDotExpression); case SyntaxKind.TypeReference: return visitNode(cbNode, (node).typeName) || visitNodes(cbNodes, (node).typeArguments); @@ -1830,20 +1832,37 @@ namespace ts { } let tokenPos = scanner.getTokenPos(); + let nextCharCode: number; + nextToken(); 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))) { - - node.flags |= NodeFlags.OctalLiteral; + if (node.kind === SyntaxKind.NumericLiteral) { + // 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 (sourceText.charCodeAt(tokenPos) === CharacterCodes._0 && isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) { + node.flags |= NodeFlags.OctalLiteral; + } + else if (token === SyntaxKind.DotToken) { + // Issue #2632 Keep space for 3 .toString() + if (isWhiteSpace(sourceText.charCodeAt(node.end))) { + node.end++; + scanner.setTextPos(node.end + 1); + } + } + else if (token === SyntaxKind.Identifier && sourceText.charCodeAt(node.end-1) === CharacterCodes.dot) { + nextCharCode = sourceText.charCodeAt(node.end); + if (!isWhiteSpace(nextCharCode) && !isLineBreak(nextCharCode)) { + // Eat up an invalid expression following '1.' e.g. 1.something() + node.invalidDotExpression = parseLeftHandSideExpressionOrHigher(); + parseErrorAtPosition(node.end, node.invalidDotExpression.end - node.end, Diagnostics.Numeric_literal_0_cannot_be_followed_by_an_expression, "'" + sourceText.substring(tokenPos, node.end) + "'"); + node.end = node.invalidDotExpression.end; + } + } } return node; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index f9a2fa3b7b4..187cead4842 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -737,6 +737,7 @@ namespace ts { text: string; isUnterminated?: boolean; hasExtendedUnicodeEscape?: boolean; + invalidDotExpression?: LeftHandSideExpression; // 1.toString() we attach the node but never emit it } export interface TemplateExpression extends PrimaryExpression { @@ -1881,7 +1882,7 @@ namespace ts { CarriageReturnLineFeed = 0, LineFeed = 1, } - + export interface LineAndCharacter { line: number; /* diff --git a/tests/baselines/reference/numLit.errors.txt b/tests/baselines/reference/numLit.errors.txt index 98b84791e35..66f11141c15 100644 --- a/tests/baselines/reference/numLit.errors.txt +++ b/tests/baselines/reference/numLit.errors.txt @@ -1,13 +1,24 @@ -tests/cases/compiler/numLit.ts(3,3): error TS1005: ';' expected. -tests/cases/compiler/numLit.ts(3,3): error TS2304: Cannot find name 'toString'. +tests/cases/compiler/numLit.ts(3,3): error TS9004: Numeric literal '1.' cannot be followed by an expression. +tests/cases/compiler/numLit.ts(9,15): error TS9004: Numeric literal '2.' cannot be followed by an expression. ==== tests/cases/compiler/numLit.ts (2 errors) ==== 1..toString(); 1.0.toString(); - 1.toString(); - ~~~~~~~~ -!!! error TS1005: ';' expected. - ~~~~~~~~ -!!! error TS2304: Cannot find name 'toString'. - 1.+2.0 + 3. ; \ No newline at end of file + 1.toString(); // error: Numeric literal '1.' cannot be followed by an expression. + ~~~~~~~~~~ +!!! error TS9004: Numeric literal '1.' cannot be followed by an expression. + 1.+2.0 + 3. ; + + // Preserve whitespace where important for JS compatibility + var i: number = 1; + var test1 = i.toString(); + var test2 = 2.toString(); // error: Numeric literal '2.' cannot be followed by an expression. + ~~~~~~~~~~ +!!! error TS9004: Numeric literal '2.' cannot be followed by an expression. + var test3 = 3 .toString(); // preserve whitepace + var test4 = 3.['toString'](); + var test5 = 3 + .toString(); // preserve whitepace + var test6 = new Number(4).toString(); + var test7 = 3. + 3. \ No newline at end of file diff --git a/tests/baselines/reference/numLit.js b/tests/baselines/reference/numLit.js index aaec91cde5d..a6e33a9a3c1 100644 --- a/tests/baselines/reference/numLit.js +++ b/tests/baselines/reference/numLit.js @@ -1,12 +1,32 @@ //// [numLit.ts] 1..toString(); 1.0.toString(); -1.toString(); -1.+2.0 + 3. ; +1.toString(); // error: Numeric literal '1.' cannot be followed by an expression. +1.+2.0 + 3. ; + +// Preserve whitespace where important for JS compatibility +var i: number = 1; +var test1 = i.toString(); +var test2 = 2.toString(); // error: Numeric literal '2.' cannot be followed by an expression. +var test3 = 3 .toString(); // preserve whitepace +var test4 = 3.['toString'](); +var test5 = 3 +.toString(); // preserve whitepace +var test6 = new Number(4).toString(); +var test7 = 3. + 3. //// [numLit.js] 1..toString(); 1.0.toString(); -1.; -toString(); +1.toString(); // error: Numeric literal '1.' cannot be followed by an expression. 1. + 2.0 + 3.; +// Preserve whitespace where important for JS compatibility +var i = 1; +var test1 = i.toString(); +var test2 = 2.toString(); // error: Numeric literal '2.' cannot be followed by an expression. +var test3 = 3 .toString(); // preserve whitepace +var test4 = 3.['toString'](); +var test5 = 3 + .toString(); // preserve whitepace +var test6 = new Number(4).toString(); +var test7 = 3. + 3.; diff --git a/tests/cases/compiler/numLit.ts b/tests/cases/compiler/numLit.ts index 01e19e7c8fb..d9d42f9018c 100644 --- a/tests/cases/compiler/numLit.ts +++ b/tests/cases/compiler/numLit.ts @@ -1,4 +1,15 @@ 1..toString(); 1.0.toString(); -1.toString(); -1.+2.0 + 3. ; \ No newline at end of file +1.toString(); // error: Numeric literal '1.' cannot be followed by an expression. +1.+2.0 + 3. ; + +// Preserve whitespace where important for JS compatibility +var i: number = 1; +var test1 = i.toString(); +var test2 = 2.toString(); // error: Numeric literal '2.' cannot be followed by an expression. +var test3 = 3 .toString(); // preserve whitepace +var test4 = 3.['toString'](); +var test5 = 3 +.toString(); // preserve whitepace +var test6 = new Number(4).toString(); +var test7 = 3. + 3. \ No newline at end of file From c41918116db9655f10882518db602515eaed7cad Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 07:42:40 -0700 Subject: [PATCH 159/309] Update LKG. --- bin/lib.core.d.ts | 2 +- bin/lib.core.es6.d.ts | 2 +- bin/lib.d.ts | 9 +- bin/lib.dom.d.ts | 7 +- bin/lib.es6.d.ts | 19 +- bin/lib.webworker.d.ts | 7 +- bin/tsc.js | 6127 ++++++++++++------------ bin/tsserver.js | 7914 ++++++++++++++++--------------- bin/typescript.d.ts | 349 +- bin/typescript.js | 8870 ++++++++++++++++++----------------- bin/typescriptServices.d.ts | 365 +- bin/typescriptServices.js | 8870 ++++++++++++++++++----------------- 12 files changed, 17176 insertions(+), 15365 deletions(-) diff --git a/bin/lib.core.d.ts b/bin/lib.core.d.ts index fd048630ca1..af876765ab4 100644 --- a/bin/lib.core.d.ts +++ b/bin/lib.core.d.ts @@ -1165,7 +1165,7 @@ interface ArrayConstructor { (arrayLength?: number): any[]; (arrayLength: number): T[]; (...items: T[]): T[]; - isArray(arg: any): boolean; + isArray(arg: any): arg is Array; prototype: Array; } diff --git a/bin/lib.core.es6.d.ts b/bin/lib.core.es6.d.ts index 1213967b972..1ee111caa9b 100644 --- a/bin/lib.core.es6.d.ts +++ b/bin/lib.core.es6.d.ts @@ -1165,7 +1165,7 @@ interface ArrayConstructor { (arrayLength?: number): any[]; (arrayLength: number): T[]; (...items: T[]): T[]; - isArray(arg: any): boolean; + isArray(arg: any): arg is Array; prototype: Array; } diff --git a/bin/lib.d.ts b/bin/lib.d.ts index 0e1176377b5..63a8adbeda4 100644 --- a/bin/lib.d.ts +++ b/bin/lib.d.ts @@ -1165,7 +1165,7 @@ interface ArrayConstructor { (arrayLength?: number): any[]; (arrayLength: number): T[]; (...items: T[]): T[]; - isArray(arg: any): boolean; + isArray(arg: any): arg is Array; prototype: Array; } @@ -3531,6 +3531,11 @@ declare module Intl { currency?: string; currencyDisplay?: string; useGrouping?: boolean; + minimumintegerDigits?: number; + minimumFractionDigits?: number; + maximumFractionDigits?: number; + minimumSignificantDigits?: number; + maximumSignificantDigits?: number; } interface ResolvedNumberFormatOptions { @@ -3593,7 +3598,7 @@ declare module Intl { } interface DateTimeFormat { - format(date: number): string; + format(date?: Date | number): string; resolvedOptions(): ResolvedDateTimeFormatOptions; } var DateTimeFormat: { diff --git a/bin/lib.dom.d.ts b/bin/lib.dom.d.ts index 7638f0fba4c..b05be6cbee8 100644 --- a/bin/lib.dom.d.ts +++ b/bin/lib.dom.d.ts @@ -2361,6 +2361,11 @@ declare module Intl { currency?: string; currencyDisplay?: string; useGrouping?: boolean; + minimumintegerDigits?: number; + minimumFractionDigits?: number; + maximumFractionDigits?: number; + minimumSignificantDigits?: number; + maximumSignificantDigits?: number; } interface ResolvedNumberFormatOptions { @@ -2423,7 +2428,7 @@ declare module Intl { } interface DateTimeFormat { - format(date: number): string; + format(date?: Date | number): string; resolvedOptions(): ResolvedDateTimeFormatOptions; } var DateTimeFormat: { diff --git a/bin/lib.es6.d.ts b/bin/lib.es6.d.ts index 2326b43207d..e17cb3f35cf 100644 --- a/bin/lib.es6.d.ts +++ b/bin/lib.es6.d.ts @@ -1165,7 +1165,7 @@ interface ArrayConstructor { (arrayLength?: number): any[]; (arrayLength: number): T[]; (...items: T[]): T[]; - isArray(arg: any): boolean; + isArray(arg: any): arg is Array; prototype: Array; } @@ -4909,6 +4909,11 @@ declare module Intl { currency?: string; currencyDisplay?: string; useGrouping?: boolean; + minimumintegerDigits?: number; + minimumFractionDigits?: number; + maximumFractionDigits?: number; + minimumSignificantDigits?: number; + maximumSignificantDigits?: number; } interface ResolvedNumberFormatOptions { @@ -4971,7 +4976,7 @@ declare module Intl { } interface DateTimeFormat { - format(date: number): string; + format(date?: Date | number): string; resolvedOptions(): ResolvedDateTimeFormatOptions; } var DateTimeFormat: { @@ -18015,7 +18020,17 @@ declare function addEventListener(type: "volumechange", listener: (ev: Event) => declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "wheel", listener: (ev: WheelEvent) => any, useCapture?: boolean): void; declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; +interface DOMTokenList { + [Symbol.iterator](): IterableIterator; +} +interface NodeList { + [Symbol.iterator](): IterableIterator +} + +interface NodeListOf { + [Symbol.iterator](): IterableIterator +} ///////////////////////////// /// WorkerGlobalScope APIs ///////////////////////////// diff --git a/bin/lib.webworker.d.ts b/bin/lib.webworker.d.ts index 79eac80a8fd..d0caeccff92 100644 --- a/bin/lib.webworker.d.ts +++ b/bin/lib.webworker.d.ts @@ -2361,6 +2361,11 @@ declare module Intl { currency?: string; currencyDisplay?: string; useGrouping?: boolean; + minimumintegerDigits?: number; + minimumFractionDigits?: number; + maximumFractionDigits?: number; + minimumSignificantDigits?: number; + maximumSignificantDigits?: number; } interface ResolvedNumberFormatOptions { @@ -2423,7 +2428,7 @@ declare module Intl { } interface DateTimeFormat { - format(date: number): string; + format(date?: Date | number): string; resolvedOptions(): ResolvedDateTimeFormatOptions; } var DateTimeFormat: { diff --git a/bin/tsc.js b/bin/tsc.js index 16408e9c208..e5f449c4101 100644 --- a/bin/tsc.js +++ b/bin/tsc.js @@ -31,6 +31,36 @@ var ts; /// var ts; (function (ts) { + function createFileMap(getCanonicalFileName) { + var files = {}; + return { + get: get, + set: set, + contains: contains, + remove: remove, + forEachValue: forEachValueInMap + }; + function set(fileName, value) { + files[normalizeKey(fileName)] = value; + } + function get(fileName) { + return files[normalizeKey(fileName)]; + } + function contains(fileName) { + return hasProperty(files, normalizeKey(fileName)); + } + function remove(fileName) { + var key = normalizeKey(fileName); + delete files[key]; + } + function forEachValueInMap(f) { + forEachValue(files, f); + } + function normalizeKey(key) { + return getCanonicalFileName(normalizeSlashes(key)); + } + } + ts.createFileMap = createFileMap; function forEach(array, callback) { if (array) { for (var i = 0, len = array.length; i < len; i++) { @@ -498,7 +528,7 @@ var ts; function getNormalizedPathComponents(path, currentDirectory) { path = normalizeSlashes(path); var rootLength = getRootLength(path); - if (rootLength == 0) { + if (rootLength === 0) { path = combinePaths(normalizeSlashes(currentDirectory), path); rootLength = getRootLength(path); } @@ -1116,14 +1146,26 @@ var ts; A_class_declaration_without_the_default_modifier_must_have_a_name: { code: 1211, category: ts.DiagnosticCategory.Error, key: "A class declaration without the 'default' modifier must have a name" }, Identifier_expected_0_is_a_reserved_word_in_strict_mode: { code: 1212, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode" }, Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1213, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, - Type_expected_0_is_a_reserved_word_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode" }, - Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: ts.DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: { code: 1214, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode." }, + Invalid_use_of_0_Modules_are_automatically_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Invalid use of '{0}'. Modules are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: ts.DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalDecorators_to_remove_this_warning: { code: 1219, category: ts.DiagnosticCategory.Error, key: "Experimental support for decorators is a feature that is subject to change in a future release. Specify '--experimentalDecorators' to remove this warning." }, Generators_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 1220, category: ts.DiagnosticCategory.Error, key: "Generators are only available when targeting ECMAScript 6 or higher." }, Generators_are_not_allowed_in_an_ambient_context: { code: 1221, category: ts.DiagnosticCategory.Error, key: "Generators are not allowed in an ambient context." }, An_overload_signature_cannot_be_declared_as_a_generator: { code: 1222, category: ts.DiagnosticCategory.Error, key: "An overload signature cannot be declared as a generator." }, _0_tag_already_specified: { code: 1223, category: ts.DiagnosticCategory.Error, key: "'{0}' tag already specified." }, + Signature_0_must_have_a_type_predicate: { code: 1224, category: ts.DiagnosticCategory.Error, key: "Signature '{0}' must have a type predicate." }, + Cannot_find_parameter_0: { code: 1225, category: ts.DiagnosticCategory.Error, key: "Cannot find parameter '{0}'." }, + Type_predicate_0_is_not_assignable_to_1: { code: 1226, category: ts.DiagnosticCategory.Error, key: "Type predicate '{0}' is not assignable to '{1}'." }, + Parameter_0_is_not_in_the_same_position_as_parameter_1: { code: 1227, category: ts.DiagnosticCategory.Error, key: "Parameter '{0}' is not in the same position as parameter '{1}'." }, + A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: { code: 1228, category: ts.DiagnosticCategory.Error, key: "A type predicate is only allowed in return type position for functions and methods." }, + A_type_predicate_cannot_reference_a_rest_parameter: { code: 1229, category: ts.DiagnosticCategory.Error, key: "A type predicate cannot reference a rest parameter." }, + A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: { code: 1230, category: ts.DiagnosticCategory.Error, key: "A type predicate cannot reference element '{0}' in a binding pattern." }, + An_export_assignment_can_only_be_used_in_a_module: { code: 1231, category: ts.DiagnosticCategory.Error, key: "An export assignment can only be used in a module." }, + An_import_declaration_can_only_be_used_in_a_namespace_or_module: { code: 1232, category: ts.DiagnosticCategory.Error, key: "An import declaration can only be used in a namespace or module." }, + An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, + An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, + A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.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: ts.DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -1317,6 +1359,11 @@ var ts; Cannot_find_namespace_0: { code: 2503, category: ts.DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, No_best_common_type_exists_among_yield_expressions: { code: 2504, category: ts.DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: ts.DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, + _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: { code: 2506, category: ts.DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own base expression." }, + Type_0_is_not_a_constructor_function_type: { code: 2507, category: ts.DiagnosticCategory.Error, key: "Type '{0}' is not a constructor function type." }, + No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: ts.DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." }, + Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: ts.DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." }, + Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: ts.DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: ts.DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -1526,7 +1573,7 @@ var ts; "false": 80, "finally": 81, "for": 82, - "from": 125, + "from": 126, "function": 83, "get": 116, "if": 84, @@ -1535,36 +1582,37 @@ var ts; "in": 86, "instanceof": 87, "interface": 103, + "is": 117, "let": 104, - "module": 117, - "namespace": 118, + "module": 118, + "namespace": 119, "new": 88, "null": 89, - "number": 120, + "number": 121, "package": 105, "private": 106, "protected": 107, "public": 108, - "require": 119, + "require": 120, "return": 90, - "set": 121, + "set": 122, "static": 109, - "string": 122, + "string": 123, "super": 91, "switch": 92, - "symbol": 123, + "symbol": 124, "this": 93, "throw": 94, "true": 95, "try": 96, - "type": 124, + "type": 125, "typeof": 97, "var": 98, "void": 99, "while": 100, "with": 101, "yield": 110, - "of": 126, + "of": 127, "{": 14, "}": 15, "(": 16, @@ -1767,6 +1815,25 @@ var ts; return ch >= 48 && ch <= 55; } ts.isOctalDigit = isOctalDigit; + function couldStartTrivia(text, pos) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13: + case 10: + case 9: + case 11: + case 12: + case 32: + case 47: + case 60: + case 61: + case 62: + return true; + default: + return ch > 127; + } + } + ts.couldStartTrivia = couldStartTrivia; function skipTrivia(text, pos, stopAfterLineBreak) { while (true) { var ch = text.charCodeAt(pos); @@ -2229,7 +2296,7 @@ var ts; error(ts.Diagnostics.Unexpected_end_of_text); isInvalidExtendedEscape = true; } - else if (text.charCodeAt(pos) == 125) { + else if (text.charCodeAt(pos) === 125) { pos++; } else { @@ -2750,16 +2817,16 @@ var ts; (function (ts) { ts.bindTime = 0; function getModuleInstanceState(node) { - if (node.kind === 203 || node.kind === 204) { + if (node.kind === 205 || node.kind === 206) { return 0; } else if (ts.isConstEnumDeclaration(node)) { return 2; } - else if ((node.kind === 210 || node.kind === 209) && !(node.flags & 1)) { + else if ((node.kind === 212 || node.kind === 211) && !(node.flags & 1)) { return 0; } - else if (node.kind === 207) { + else if (node.kind === 209) { var state = 0; ts.forEachChild(node, function (n) { switch (getModuleInstanceState(n)) { @@ -2775,7 +2842,7 @@ var ts; }); return state; } - else if (node.kind === 206) { + else if (node.kind === 208) { return getModuleInstanceState(node.body); } else { @@ -2794,11 +2861,14 @@ var ts; var container; var blockScopeContainer; var lastContainer; + var inStrictMode = !!file.externalModuleIndicator; var symbolCount = 0; var Symbol = ts.objectAllocator.getSymbolConstructor(); + var classifiableNames = {}; if (!file.locals) { bind(file); file.symbolCount = symbolCount; + file.classifiableNames = classifiableNames; } return; function createSymbol(flags, name) { @@ -2824,10 +2894,10 @@ var ts; } function getDeclarationName(node) { if (node.name) { - if (node.kind === 206 && node.name.kind === 8) { + if (node.kind === 208 && node.name.kind === 8) { return '"' + node.name.text + '"'; } - if (node.name.kind === 128) { + if (node.name.kind === 129) { var nameExpression = node.name.expression; ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); @@ -2835,22 +2905,22 @@ var ts; return node.name.text; } switch (node.kind) { - case 136: + case 137: return "__constructor"; - case 143: - case 139: - return "__call"; - case 144: + case 145: case 140: - return "__new"; + return "__call"; + case 146: case 141: + return "__new"; + case 142: return "__index"; - case 216: + case 218: return "__export"; - case 215: + case 217: return node.isExportEquals ? "export=" : "default"; - case 201: - case 202: + case 203: + case 204: return node.flags & 256 ? "default" : undefined; } } @@ -2865,6 +2935,9 @@ var ts; symbol = ts.hasProperty(symbolTable, name) ? symbolTable[name] : (symbolTable[name] = createSymbol(0, name)); + if (name && (includes & 788448)) { + classifiableNames[name] = name; + } if (symbol.flags & excludes) { if (node.name) { node.name.parent = node; @@ -2889,7 +2962,7 @@ var ts; function declareModuleMember(node, symbolFlags, symbolExcludes) { var hasExportModifier = ts.getCombinedNodeFlags(node) & 1; if (symbolFlags & 8388608) { - if (node.kind === 218 || (node.kind === 209 && hasExportModifier)) { + if (node.kind === 220 || (node.kind === 211 && hasExportModifier)) { return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); } else { @@ -2935,36 +3008,37 @@ var ts; } function getContainerFlags(node) { switch (node.kind) { - case 175: - case 202: - case 203: + case 177: + case 204: case 205: - case 146: - case 155: + case 207: + case 148: + case 157: return 1; - case 139: case 140: case 141: - case 135: - case 134: - case 201: + case 142: case 136: + case 135: + case 203: case 137: case 138: - case 143: - case 144: - case 163: - case 164: - case 206: - case 228: - return 5; - case 224: - case 187: - case 188: - case 189: + case 139: + case 145: + case 146: + case 165: + case 166: case 208: + case 230: + case 206: + return 5; + case 226: + case 189: + case 190: + case 191: + case 210: return 2; - case 180: + case 182: return ts.isFunctionLike(node.parent) ? 0 : 2; } return 0; @@ -2980,32 +3054,33 @@ var ts; } function declareSymbolAndAddToSymbolTableWorker(node, symbolFlags, symbolExcludes) { switch (container.kind) { - case 206: + case 208: return declareModuleMember(node, symbolFlags, symbolExcludes); - case 228: + case 230: return declareSourceFileMember(node, symbolFlags, symbolExcludes); - case 175: - case 202: + case 177: + case 204: return declareClassMember(node, symbolFlags, symbolExcludes); - case 205: + case 207: return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); - case 146: - case 155: - case 203: + case 148: + case 157: + case 205: return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes); - case 143: - case 144: - case 139: + case 145: + case 146: case 140: case 141: - case 135: - case 134: + case 142: case 136: + case 135: case 137: case 138: - case 201: - case 163: - case 164: + case 139: + case 203: + case 165: + case 166: + case 206: return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes); } } @@ -3029,11 +3104,11 @@ var ts; return false; } function hasExportDeclarations(node) { - var body = node.kind === 228 ? node : node.body; - if (body.kind === 228 || body.kind === 207) { + var body = node.kind === 230 ? node : node.body; + if (body.kind === 230 || body.kind === 209) { for (var _i = 0, _a = body.statements; _i < _a.length; _i++) { var stat = _a[_i]; - if (stat.kind === 216 || stat.kind === 215) { + if (stat.kind === 218 || stat.kind === 217) { return true; } } @@ -3078,16 +3153,41 @@ var ts; typeLiteralSymbol.members = (_a = {}, _a[symbol.name] = symbol, _a); var _a; } + function bindObjectLiteralExpression(node) { + if (inStrictMode) { + var seen = {}; + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var prop = _a[_i]; + if (prop.name.kind !== 65) { + continue; + } + var identifier = prop.name; + var currentKind = prop.kind === 227 || prop.kind === 228 || prop.kind === 136 + ? 1 + : 2; + var existingKind = seen[identifier.text]; + if (!existingKind) { + seen[identifier.text] = currentKind; + continue; + } + if (currentKind === 1 && existingKind === 1) { + var span = ts.getErrorSpanForNode(file, identifier); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode)); + } + } + } + return bindAnonymousDeclaration(node, 4096, "__object"); + } function bindAnonymousDeclaration(node, symbolFlags, name) { var symbol = createSymbol(symbolFlags, name); addDeclarationToSymbol(symbol, node, symbolFlags); } function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) { switch (blockScopeContainer.kind) { - case 206: + case 208: declareModuleMember(node, symbolFlags, symbolExcludes); break; - case 228: + case 230: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolFlags, symbolExcludes); break; @@ -3103,79 +3203,223 @@ var ts; function bindBlockScopedVariableDeclaration(node) { bindBlockScopedDeclaration(node, 2, 107455); } + function checkStrictModeIdentifier(node) { + if (inStrictMode && + node.originalKeywordKind >= 102 && + node.originalKeywordKind <= 110 && + !ts.isIdentifierName(node)) { + if (!file.parseDiagnostics.length) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node))); + } + } + } + function getStrictModeIdentifierMessage(node) { + if (ts.getAncestor(node, 204) || ts.getAncestor(node, 177)) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode; + } + function checkStrictModeBinaryExpression(node) { + if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { + checkStrictModeEvalOrArguments(node, node.left); + } + } + function checkStrictModeCatchClause(node) { + if (inStrictMode && node.variableDeclaration) { + checkStrictModeEvalOrArguments(node, node.variableDeclaration.name); + } + } + function checkStrictModeDeleteExpression(node) { + if (inStrictMode && node.expression.kind === 65) { + var span = ts.getErrorSpanForNode(file, node.expression); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode)); + } + } + function isEvalOrArgumentsIdentifier(node) { + return node.kind === 65 && + (node.text === "eval" || node.text === "arguments"); + } + function checkStrictModeEvalOrArguments(contextNode, name) { + if (name && name.kind === 65) { + var identifier = name; + if (isEvalOrArgumentsIdentifier(identifier)) { + var span = ts.getErrorSpanForNode(file, name); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), identifier.text)); + } + } + } + function getStrictModeEvalOrArgumentsMessage(node) { + if (ts.getAncestor(node, 204) || ts.getAncestor(node, 177)) { + return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Invalid_use_of_0_in_strict_mode; + } + function checkStrictModeFunctionName(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } + } + function checkStrictModeNumericLiteral(node) { + if (inStrictMode && node.flags & 16384) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode)); + } + } + function checkStrictModePostfixUnaryExpression(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + function checkStrictModePrefixUnaryExpression(node) { + if (inStrictMode) { + if (node.operator === 38 || node.operator === 39) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + } + function checkStrictModeWithStatement(node) { + if (inStrictMode) { + grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); + } + } + function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) { + var span = ts.getSpanOfTokenAtPosition(file, node.pos); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2)); + } function getDestructuringParameterName(node) { return "__" + ts.indexOf(node.parent.parameters, node); } function bind(node) { node.parent = parent; + var savedInStrictMode = inStrictMode; + if (!savedInStrictMode) { + updateStrictMode(node); + } bindWorker(node); bindChildren(node); + inStrictMode = savedInStrictMode; + } + function updateStrictMode(node) { + switch (node.kind) { + case 230: + case 209: + updateStrictModeStatementList(node.statements); + return; + case 182: + if (ts.isFunctionLike(node.parent)) { + updateStrictModeStatementList(node.statements); + } + return; + case 204: + case 177: + inStrictMode = true; + return; + } + } + function updateStrictModeStatementList(statements) { + for (var _i = 0; _i < statements.length; _i++) { + var statement = statements[_i]; + if (!ts.isPrologueDirective(statement)) { + return; + } + if (isUseStrictPrologueDirective(statement)) { + inStrictMode = true; + return; + } + } + } + function isUseStrictPrologueDirective(node) { + var nodeText = ts.getTextOfNodeFromSourceText(file.text, node.expression); + return nodeText === '"use strict"' || nodeText === "'use strict'"; } function bindWorker(node) { switch (node.kind) { - case 129: - return declareSymbolAndAddToSymbolTable(node, 262144, 530912); - case 130: - return bindParameter(node); - case 199: - case 153: - return bindVariableDeclarationOrBindingElement(node); - case 133: - case 132: - return bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455); - case 225: + case 65: + return checkStrictModeIdentifier(node); + case 172: + return checkStrictModeBinaryExpression(node); case 226: - return bindPropertyOrMethodOrAccessor(node, 4, 107455); + return checkStrictModeCatchClause(node); + case 167: + return checkStrictModeDeleteExpression(node); + case 7: + return checkStrictModeNumericLiteral(node); + case 171: + return checkStrictModePostfixUnaryExpression(node); + case 170: + return checkStrictModePrefixUnaryExpression(node); + case 195: + return checkStrictModeWithStatement(node); + case 130: + return declareSymbolAndAddToSymbolTable(node, 262144, 530912); + case 131: + return bindParameter(node); + case 201: + case 155: + return bindVariableDeclarationOrBindingElement(node); + case 134: + case 133: + return bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455); case 227: + case 228: + return bindPropertyOrMethodOrAccessor(node, 4, 107455); + case 229: return bindPropertyOrMethodOrAccessor(node, 8, 107455); - case 139: case 140: case 141: + case 142: return declareSymbolAndAddToSymbolTable(node, 131072, 0); - case 135: - case 134: - return bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263); - case 201: - return declareSymbolAndAddToSymbolTable(node, 16, 106927); case 136: - return declareSymbolAndAddToSymbolTable(node, 16384, 0); - case 137: - return bindPropertyOrMethodOrAccessor(node, 32768, 41919); - case 138: - return bindPropertyOrMethodOrAccessor(node, 65536, 74687); - case 143: - case 144: - return bindFunctionOrConstructorType(node); - case 146: - return bindAnonymousDeclaration(node, 2048, "__type"); - case 155: - return bindAnonymousDeclaration(node, 4096, "__object"); - case 163: - case 164: - return bindAnonymousDeclaration(node, 16, "__function"); - case 175: - case 202: - return bindClassLikeDeclaration(node); + case 135: + return bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263); case 203: - return bindBlockScopedDeclaration(node, 64, 792992); + checkStrictModeFunctionName(node); + return declareSymbolAndAddToSymbolTable(node, 16, 106927); + case 137: + return declareSymbolAndAddToSymbolTable(node, 16384, 0); + case 138: + return bindPropertyOrMethodOrAccessor(node, 32768, 41919); + case 139: + return bindPropertyOrMethodOrAccessor(node, 65536, 74687); + case 145: + case 146: + return bindFunctionOrConstructorType(node); + case 148: + return bindAnonymousDeclaration(node, 2048, "__type"); + case 157: + return bindObjectLiteralExpression(node); + case 165: + case 166: + checkStrictModeFunctionName(node); + return bindAnonymousDeclaration(node, 16, "__function"); + case 177: case 204: - return bindBlockScopedDeclaration(node, 524288, 793056); + return bindClassLikeDeclaration(node); case 205: - return bindEnumDeclaration(node); + return bindBlockScopedDeclaration(node, 64, 792992); case 206: + return bindBlockScopedDeclaration(node, 524288, 793056); + case 207: + return bindEnumDeclaration(node); + case 208: return bindModuleDeclaration(node); - case 209: - case 212: - case 214: - case 218: - return declareSymbolAndAddToSymbolTable(node, 8388608, 8388608); case 211: - return bindImportClause(node); + case 214: case 216: + case 220: + return declareSymbolAndAddToSymbolTable(node, 8388608, 8388608); + case 213: + return bindImportClause(node); + case 218: return bindExportDeclaration(node); - case 215: + case 217: return bindExportAssignment(node); - case 228: + case 230: return bindSourceFileIfExternalModule(); } } @@ -3186,7 +3430,10 @@ var ts; } } function bindExportAssignment(node) { - if (node.expression.kind === 65) { + if (!container.symbol || !container.symbol.exports) { + bindAnonymousDeclaration(node, 8388608, getDeclarationName(node)); + } + else if (node.expression.kind === 65) { declareSymbol(container.symbol.exports, container.symbol, node, 8388608, 107455 | 8388608); } else { @@ -3194,7 +3441,10 @@ var ts; } } function bindExportDeclaration(node) { - if (!node.exportClause) { + if (!container.symbol || !container.symbol.exports) { + bindAnonymousDeclaration(node, 1073741824, getDeclarationName(node)); + } + else if (!node.exportClause) { declareSymbol(container.symbol.exports, container.symbol, node, 1073741824, 0); } } @@ -3204,7 +3454,7 @@ var ts; } } function bindClassLikeDeclaration(node) { - if (node.kind === 202) { + if (node.kind === 204) { bindBlockScopedDeclaration(node, 32, 899583); } else { @@ -3227,6 +3477,9 @@ var ts; : bindBlockScopedDeclaration(node, 256, 899327); } function bindVariableDeclarationOrBindingElement(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } if (!ts.isBindingPattern(node.name)) { if (ts.isBlockOrCatchScoped(node)) { bindBlockScopedVariableDeclaration(node); @@ -3240,6 +3493,9 @@ var ts; } } function bindParameter(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } if (ts.isBindingPattern(node.name)) { bindAnonymousDeclaration(node, 1, getDestructuringParameterName(node)); } @@ -3247,8 +3503,8 @@ var ts; declareSymbolAndAddToSymbolTable(node, 1, 107455); } if (node.flags & 112 && - node.parent.kind === 136 && - (node.parent.parent.kind === 202 || node.parent.parent.kind === 175)) { + node.parent.kind === 137 && + (node.parent.parent.kind === 204 || node.parent.parent.kind === 177)) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); } @@ -3276,7 +3532,7 @@ var ts; ts.getDeclarationOfKind = getDeclarationOfKind; var stringWriters = []; function getSingleLineStringWriter() { - if (stringWriters.length == 0) { + if (stringWriters.length === 0) { var str = ""; var writeText = function (text) { return str += text; }; return { @@ -3323,7 +3579,7 @@ var ts; } } function getSourceFileOfNode(node) { - while (node && node.kind !== 228) { + while (node && node.kind !== 230) { node = node.parent; } return node; @@ -3412,15 +3668,15 @@ var ts; return current; } switch (current.kind) { - case 228: + case 230: + case 210: + case 226: case 208: - case 224: - case 206: - case 187: - case 188: case 189: + case 190: + case 191: return current; - case 180: + case 182: if (!isFunctionLike(current.parent)) { return current; } @@ -3431,9 +3687,9 @@ var ts; ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer; function isCatchClauseVariableDeclaration(declaration) { return declaration && - declaration.kind === 199 && + declaration.kind === 201 && declaration.parent && - declaration.parent.kind === 224; + declaration.parent.kind === 226; } ts.isCatchClauseVariableDeclaration = isCatchClauseVariableDeclaration; function declarationNameToString(name) { @@ -3469,22 +3725,22 @@ var ts; function getErrorSpanForNode(sourceFile, node) { var errorNode = node; switch (node.kind) { - case 228: + case 230: var pos_1 = ts.skipTrivia(sourceFile.text, 0, false); if (pos_1 === sourceFile.text.length) { return ts.createTextSpan(0, 0); } return getSpanOfTokenAtPosition(sourceFile, pos_1); - case 199: - case 153: - case 202: - case 175: - case 203: - case 206: - case 205: - case 227: case 201: - case 163: + case 155: + case 204: + case 177: + case 205: + case 208: + case 207: + case 229: + case 203: + case 165: errorNode = node.name; break; } @@ -3506,11 +3762,11 @@ var ts; } ts.isDeclarationFile = isDeclarationFile; function isConstEnumDeclaration(node) { - return node.kind === 205 && isConst(node); + return node.kind === 207 && isConst(node); } ts.isConstEnumDeclaration = isConstEnumDeclaration; function walkUpBindingElementsAndPatterns(node) { - while (node && (node.kind === 153 || isBindingPattern(node))) { + while (node && (node.kind === 155 || isBindingPattern(node))) { node = node.parent; } return node; @@ -3518,14 +3774,14 @@ var ts; function getCombinedNodeFlags(node) { node = walkUpBindingElementsAndPatterns(node); var flags = node.flags; - if (node.kind === 199) { + if (node.kind === 201) { node = node.parent; } - if (node && node.kind === 200) { + if (node && node.kind === 202) { flags |= node.flags; node = node.parent; } - if (node && node.kind === 181) { + if (node && node.kind === 183) { flags |= node.flags; } return flags; @@ -3540,11 +3796,11 @@ var ts; } ts.isLet = isLet; function isPrologueDirective(node) { - return node.kind === 183 && node.expression.kind === 8; + return node.kind === 185 && node.expression.kind === 8; } ts.isPrologueDirective = isPrologueDirective; function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { - if (node.kind === 130 || node.kind === 129) { + if (node.kind === 131 || node.kind === 130) { return ts.concatenate(ts.getTrailingCommentRanges(sourceFileOfNode.text, node.pos), ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); } else { @@ -3563,68 +3819,68 @@ var ts; ts.getJsDocComments = getJsDocComments; ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/; function isTypeNode(node) { - if (142 <= node.kind && node.kind <= 150) { + if (144 <= node.kind && node.kind <= 152) { return true; } switch (node.kind) { case 112: - case 120: - case 122: - case 113: + case 121: case 123: + case 113: + case 124: return true; case 99: - return node.parent.kind !== 167; + return node.parent.kind !== 169; case 8: - return node.parent.kind === 130; - case 177: - return true; + return node.parent.kind === 131; + case 179: + return !isExpressionWithTypeArgumentsInClassExtendsClause(node); case 65: - if (node.parent.kind === 127 && node.parent.right === node) { + if (node.parent.kind === 128 && node.parent.right === node) { node = node.parent; } - else if (node.parent.kind === 156 && node.parent.name === node) { + else if (node.parent.kind === 158 && node.parent.name === node) { node = node.parent; } - case 127: - case 156: - ts.Debug.assert(node.kind === 65 || node.kind === 127 || node.kind === 156, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); + case 128: + case 158: + ts.Debug.assert(node.kind === 65 || node.kind === 128 || node.kind === 158, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); var parent_1 = node.parent; - if (parent_1.kind === 145) { + if (parent_1.kind === 147) { return false; } - if (142 <= parent_1.kind && parent_1.kind <= 150) { + if (144 <= parent_1.kind && parent_1.kind <= 152) { return true; } switch (parent_1.kind) { - case 177: - return true; - case 129: - return node === parent_1.constraint; - case 133: - case 132: + case 179: + return !isExpressionWithTypeArgumentsInClassExtendsClause(parent_1); case 130: - case 199: - return node === parent_1.type; + return node === parent_1.constraint; + case 134: + case 133: + case 131: case 201: - case 163: - case 164: + return node === parent_1.type; + case 203: + case 165: + case 166: + case 137: case 136: case 135: - case 134: - case 137: case 138: - return node === parent_1.type; case 139: + return node === parent_1.type; case 140: case 141: + case 142: return node === parent_1.type; - case 161: + case 163: return node === parent_1.type; - case 158: - case 159: - return parent_1.typeArguments && ts.indexOf(parent_1.typeArguments, node) >= 0; case 160: + case 161: + return parent_1.typeArguments && ts.indexOf(parent_1.typeArguments, node) >= 0; + case 162: return false; } } @@ -3635,23 +3891,23 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 192: + case 194: return visitor(node); - case 208: - case 180: - case 184: - case 185: + case 210: + case 182: case 186: case 187: case 188: case 189: - case 193: - case 194: - case 221: - case 222: + case 190: + case 191: case 195: - case 197: + case 196: + case 223: case 224: + case 197: + case 199: + case 226: return ts.forEachChild(node, traverse); } } @@ -3661,22 +3917,22 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 173: + case 175: visitor(node); var operand = node.expression; if (operand) { traverse(operand); } + case 207: case 205: - case 203: + case 208: case 206: case 204: - case 202: return; default: if (isFunctionLike(node)) { var name_4 = node.name; - if (name_4 && name_4.kind === 128) { + if (name_4 && name_4.kind === 129) { traverse(name_4.expression); return; } @@ -3691,14 +3947,14 @@ var ts; function isVariableLike(node) { if (node) { switch (node.kind) { - case 153: + case 155: + case 229: + case 131: case 227: - case 130: - case 225: + case 134: case 133: - case 132: - case 226: - case 199: + case 228: + case 201: return true; } } @@ -3708,8 +3964,8 @@ var ts; function isAccessor(node) { if (node) { switch (node.kind) { - case 137: case 138: + case 139: return true; } } @@ -3718,26 +3974,26 @@ var ts; ts.isAccessor = isAccessor; function isClassLike(node) { if (node) { - return node.kind === 202 || node.kind === 175; + return node.kind === 204 || node.kind === 177; } } ts.isClassLike = isClassLike; function isFunctionLike(node) { if (node) { switch (node.kind) { - case 136: - case 163: - case 201: - case 164: - case 135: - case 134: case 137: + case 165: + case 203: + case 166: + case 136: + case 135: case 138: case 139: case 140: case 141: - case 143: - case 144: + case 142: + case 145: + case 146: return true; } } @@ -3745,11 +4001,11 @@ var ts; } ts.isFunctionLike = isFunctionLike; function isFunctionBlock(node) { - return node && node.kind === 180 && isFunctionLike(node.parent); + return node && node.kind === 182 && isFunctionLike(node.parent); } ts.isFunctionBlock = isFunctionBlock; function isObjectLiteralMethod(node) { - return node && node.kind === 135 && node.parent.kind === 155; + return node && node.kind === 136 && node.parent.kind === 157; } ts.isObjectLiteralMethod = isObjectLiteralMethod; function getContainingFunction(node) { @@ -3768,36 +4024,36 @@ var ts; return undefined; } switch (node.kind) { - case 128: - if (node.parent.parent.kind === 202) { + case 129: + if (node.parent.parent.kind === 204) { return node; } node = node.parent; break; - case 131: - if (node.parent.kind === 130 && isClassElement(node.parent.parent)) { + case 132: + if (node.parent.kind === 131 && isClassElement(node.parent.parent)) { node = node.parent.parent; } else if (isClassElement(node.parent)) { node = node.parent; } break; - case 164: + case 166: if (!includeArrowFunctions) { continue; } - case 201: - case 163: - case 206: - case 133: - case 132: - case 135: + case 203: + case 165: + case 208: case 134: + case 133: case 136: + case 135: case 137: case 138: - case 205: - case 228: + case 139: + case 207: + case 230: return node; } } @@ -3809,40 +4065,40 @@ var ts; if (!node) return node; switch (node.kind) { - case 128: - if (node.parent.parent.kind === 202) { + case 129: + if (node.parent.parent.kind === 204) { return node; } node = node.parent; break; - case 131: - if (node.parent.kind === 130 && isClassElement(node.parent.parent)) { + case 132: + if (node.parent.kind === 131 && isClassElement(node.parent.parent)) { node = node.parent.parent; } else if (isClassElement(node.parent)) { node = node.parent; } break; - case 201: - case 163: - case 164: + case 203: + case 165: + case 166: if (!includeFunctions) { continue; } - case 133: - case 132: - case 135: case 134: + case 133: case 136: + case 135: case 137: case 138: + case 139: return node; } } } ts.getSuperContainer = getSuperContainer; function getInvokedExpression(node) { - if (node.kind === 160) { + if (node.kind === 162) { return node.tag; } return node.expression; @@ -3850,40 +4106,40 @@ var ts; ts.getInvokedExpression = getInvokedExpression; function nodeCanBeDecorated(node) { switch (node.kind) { - case 202: + case 204: return true; - case 133: - return node.parent.kind === 202; - case 130: - return node.parent.body && node.parent.parent.kind === 202; - case 137: + case 134: + return node.parent.kind === 204; + case 131: + return node.parent.body && node.parent.parent.kind === 204; case 138: - case 135: - return node.body && node.parent.kind === 202; + case 139: + case 136: + return node.body && node.parent.kind === 204; } return false; } ts.nodeCanBeDecorated = nodeCanBeDecorated; function nodeIsDecorated(node) { switch (node.kind) { - case 202: + case 204: if (node.decorators) { return true; } return false; - case 133: - case 130: + case 134: + case 131: if (node.decorators) { return true; } return false; - case 137: + case 138: if (node.body && node.decorators) { return true; } return false; - case 135: - case 138: + case 136: + case 139: if (node.body && node.decorators) { return true; } @@ -3894,10 +4150,10 @@ var ts; ts.nodeIsDecorated = nodeIsDecorated; function childIsDecorated(node) { switch (node.kind) { - case 202: + case 204: return ts.forEach(node.members, nodeOrChildIsDecorated); - case 135: - case 138: + case 136: + case 139: return ts.forEach(node.parameters, nodeIsDecorated); } return false; @@ -3915,8 +4171,6 @@ var ts; case 95: case 80: case 9: - case 154: - case 155: case 156: case 157: case 158: @@ -3925,71 +4179,75 @@ var ts; case 161: case 162: case 163: - case 175: case 164: - case 167: case 165: + case 177: case 166: - case 168: case 169: + case 167: + case 168: case 170: case 171: - case 174: case 172: - case 10: - case 176: case 173: + case 176: + case 174: + case 10: + case 178: + case 175: return true; - case 127: - while (node.parent.kind === 127) { + case 128: + while (node.parent.kind === 128) { node = node.parent; } - return node.parent.kind === 145; + return node.parent.kind === 147; case 65: - if (node.parent.kind === 145) { + if (node.parent.kind === 147) { return true; } case 7: case 8: var parent_2 = node.parent; switch (parent_2.kind) { - case 199: - case 130: + case 201: + case 131: + case 134: case 133: - case 132: + case 229: case 227: - case 225: - case 153: + case 155: return parent_2.initializer === node; - case 183: - case 184: case 185: case 186: - case 192: - case 193: - case 194: - case 221: - case 196: - case 194: - return parent_2.expression === node; case 187: + case 188: + case 194: + case 195: + case 196: + case 223: + case 198: + case 196: + return parent_2.expression === node; + case 189: var forStatement = parent_2; - return (forStatement.initializer === node && forStatement.initializer.kind !== 200) || + return (forStatement.initializer === node && forStatement.initializer.kind !== 202) || forStatement.condition === node || forStatement.incrementor === node; - case 188: - case 189: + case 190: + case 191: var forInStatement = parent_2; - return (forInStatement.initializer === node && forInStatement.initializer.kind !== 200) || + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 202) || forInStatement.expression === node; - case 161: + case 163: return node === parent_2.expression; - case 178: + case 180: return node === parent_2.expression; - case 128: + case 129: return node === parent_2.expression; - case 131: + case 132: return true; + case 179: + return parent_2.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent_2); default: if (isExpression(parent_2)) { return true; @@ -4006,7 +4264,7 @@ var ts; } ts.isInstantiatedModule = isInstantiatedModule; function isExternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 && node.moduleReference.kind === 220; + return node.kind === 211 && node.moduleReference.kind === 222; } ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; function getExternalModuleImportEqualsDeclarationExpression(node) { @@ -4015,20 +4273,20 @@ var ts; } ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; function isInternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 && node.moduleReference.kind !== 220; + return node.kind === 211 && node.moduleReference.kind !== 222; } ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; function getExternalModuleName(node) { - if (node.kind === 210) { + if (node.kind === 212) { return node.moduleSpecifier; } - if (node.kind === 209) { + if (node.kind === 211) { var reference = node.moduleReference; - if (reference.kind === 220) { + if (reference.kind === 222) { return reference.expression; } } - if (node.kind === 216) { + if (node.kind === 218) { return node.moduleSpecifier; } } @@ -4036,15 +4294,15 @@ var ts; function hasQuestionToken(node) { if (node) { switch (node.kind) { - case 130: + case 131: return node.questionToken !== undefined; + case 136: case 135: - case 134: return node.questionToken !== undefined; - case 226: - case 225: + case 228: + case 227: + case 134: case 133: - case 132: return node.questionToken !== undefined; } } @@ -4052,9 +4310,9 @@ var ts; } ts.hasQuestionToken = hasQuestionToken; function isJSDocConstructSignature(node) { - return node.kind === 241 && + return node.kind === 243 && node.parameters.length > 0 && - node.parameters[0].type.kind === 243; + node.parameters[0].type.kind === 245; } ts.isJSDocConstructSignature = isJSDocConstructSignature; function getJSDocTag(node, kind) { @@ -4068,15 +4326,15 @@ var ts; } } function getJSDocTypeTag(node) { - return getJSDocTag(node, 249); + return getJSDocTag(node, 251); } ts.getJSDocTypeTag = getJSDocTypeTag; function getJSDocReturnTag(node) { - return getJSDocTag(node, 248); + return getJSDocTag(node, 250); } ts.getJSDocReturnTag = getJSDocReturnTag; function getJSDocTemplateTag(node) { - return getJSDocTag(node, 250); + return getJSDocTag(node, 252); } ts.getJSDocTemplateTag = getJSDocTemplateTag; function getCorrespondingJSDocParameterTag(parameter) { @@ -4085,7 +4343,7 @@ var ts; var docComment = parameter.parent.jsDocComment; if (docComment) { return ts.forEach(docComment.tags, function (t) { - if (t.kind === 247) { + if (t.kind === 249) { var parameterTag = t; var name_5 = parameterTag.preParameterName || parameterTag.postParameterName; if (name_5.text === parameterName) { @@ -4104,12 +4362,12 @@ var ts; function isRestParameter(node) { if (node) { if (node.parserContextFlags & 64) { - if (node.type && node.type.kind === 242) { + if (node.type && node.type.kind === 244) { return true; } var paramTag = getCorrespondingJSDocParameterTag(node); if (paramTag && paramTag.typeExpression) { - return paramTag.typeExpression.type.kind === 242; + return paramTag.typeExpression.type.kind === 244; } } return node.dotDotDotToken !== undefined; @@ -4130,7 +4388,7 @@ var ts; } ts.isTemplateLiteralKind = isTemplateLiteralKind; function isBindingPattern(node) { - return !!node && (node.kind === 152 || node.kind === 151); + return !!node && (node.kind === 154 || node.kind === 153); } ts.isBindingPattern = isBindingPattern; function isInAmbientContext(node) { @@ -4145,33 +4403,33 @@ var ts; ts.isInAmbientContext = isInAmbientContext; function isDeclaration(node) { switch (node.kind) { - case 164: - case 153: - case 202: - case 136: - case 205: - case 227: - case 218: - case 201: - case 163: - case 137: - case 211: - case 209: - case 214: - case 203: - case 135: - case 134: - case 206: - case 212: - case 130: - case 225: - case 133: - case 132: - case 138: - case 226: + case 166: + case 155: case 204: - case 129: - case 199: + case 137: + case 207: + case 229: + case 220: + case 203: + case 165: + case 138: + case 213: + case 211: + case 216: + case 205: + case 136: + case 135: + case 208: + case 214: + case 131: + case 227: + case 134: + case 133: + case 139: + case 228: + case 206: + case 130: + case 201: return true; } return false; @@ -4179,25 +4437,25 @@ var ts; ts.isDeclaration = isDeclaration; function isStatement(n) { switch (n.kind) { - case 191: - case 190: - case 198: - case 185: - case 183: - case 182: - case 188: - case 189: - case 187: - case 184: - case 195: - case 192: - case 194: - case 94: - case 197: - case 181: - case 186: case 193: - case 215: + case 192: + case 200: + case 187: + case 185: + case 184: + case 190: + case 191: + case 189: + case 186: + case 197: + case 194: + case 196: + case 94: + case 199: + case 183: + case 188: + case 195: + case 217: return true; default: return false; @@ -4206,13 +4464,13 @@ var ts; ts.isStatement = isStatement; function isClassElement(n) { switch (n.kind) { - case 136: - case 133: - case 135: case 137: - case 138: case 134: - case 141: + case 136: + case 138: + case 139: + case 135: + case 142: return true; default: return false; @@ -4224,7 +4482,7 @@ var ts; return false; } var parent = name.parent; - if (parent.kind === 214 || parent.kind === 218) { + if (parent.kind === 216 || parent.kind === 220) { if (parent.propertyName) { return true; } @@ -4235,13 +4493,43 @@ var ts; return false; } ts.isDeclarationName = isDeclarationName; + function isIdentifierName(node) { + var parent = node.parent; + switch (parent.kind) { + case 134: + case 133: + case 136: + case 135: + case 138: + case 139: + case 229: + case 227: + case 158: + return parent.name === node; + case 128: + if (parent.right === node) { + while (parent.kind === 128) { + parent = parent.parent; + } + return parent.kind === 147; + } + return false; + case 155: + case 216: + return parent.propertyName === node; + case 220: + return true; + } + return false; + } + ts.isIdentifierName = isIdentifierName; function isAliasSymbolDeclaration(node) { - return node.kind === 209 || - node.kind === 211 && !!node.name || - node.kind === 212 || + return node.kind === 211 || + node.kind === 213 && !!node.name || node.kind === 214 || - node.kind === 218 || - node.kind === 215 && node.expression.kind === 65; + node.kind === 216 || + node.kind === 220 || + node.kind === 217 && node.expression.kind === 65; } ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration; function getClassExtendsHeritageClauseElement(node) { @@ -4324,7 +4612,7 @@ var ts; } ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; function isKeyword(token) { - return 66 <= token && token <= 126; + return 66 <= token && token <= 127; } ts.isKeyword = isKeyword; function isTrivia(token) { @@ -4333,19 +4621,19 @@ var ts; ts.isTrivia = isTrivia; function hasDynamicName(declaration) { return declaration.name && - declaration.name.kind === 128 && + declaration.name.kind === 129 && !isWellKnownSymbolSyntactically(declaration.name.expression); } ts.hasDynamicName = hasDynamicName; function isWellKnownSymbolSyntactically(node) { - return node.kind === 156 && isESSymbolIdentifier(node.expression); + return node.kind === 158 && isESSymbolIdentifier(node.expression); } ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; function getPropertyNameForPropertyNameNode(name) { if (name.kind === 65 || name.kind === 8 || name.kind === 7) { return name.text; } - if (name.kind === 128) { + if (name.kind === 129) { var nameExpression = name.expression; if (isWellKnownSymbolSyntactically(nameExpression)) { var rightHandSideName = nameExpression.name.text; @@ -4380,18 +4668,18 @@ var ts; ts.isModifier = isModifier; function isParameterDeclaration(node) { var root = getRootDeclaration(node); - return root.kind === 130; + return root.kind === 131; } ts.isParameterDeclaration = isParameterDeclaration; function getRootDeclaration(node) { - while (node.kind === 153) { + while (node.kind === 155) { node = node.parent.parent; } return node; } ts.getRootDeclaration = getRootDeclaration; function nodeStartsNewLexicalEnvironment(n) { - return isFunctionLike(n) || n.kind === 206 || n.kind === 228; + return isFunctionLike(n) || n.kind === 208 || n.kind === 230; } ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment; function nodeIsSynthesized(node) { @@ -4615,7 +4903,7 @@ var ts; ts.getLineOfLocalPosition = getLineOfLocalPosition; function getFirstConstructorWithBody(node) { return ts.forEach(node.members, function (member) { - if (member.kind === 136 && nodeIsPresent(member.body)) { + if (member.kind === 137 && nodeIsPresent(member.body)) { return member; } }); @@ -4638,10 +4926,10 @@ var ts; var setAccessor; if (hasDynamicName(accessor)) { firstAccessor = accessor; - if (accessor.kind === 137) { + if (accessor.kind === 138) { getAccessor = accessor; } - else if (accessor.kind === 138) { + else if (accessor.kind === 139) { setAccessor = accessor; } else { @@ -4650,7 +4938,7 @@ var ts; } else { ts.forEach(declarations, function (member) { - if ((member.kind === 137 || member.kind === 138) + if ((member.kind === 138 || member.kind === 139) && (member.flags & 128) === (accessor.flags & 128)) { var memberName = getPropertyNameForPropertyNameNode(member.name); var accessorName = getPropertyNameForPropertyNameNode(accessor.name); @@ -4661,10 +4949,10 @@ var ts; else if (!secondAccessor) { secondAccessor = member; } - if (member.kind === 137 && !getAccessor) { + if (member.kind === 138 && !getAccessor) { getAccessor = member; } - if (member.kind === 138 && !setAccessor) { + if (member.kind === 139 && !setAccessor) { setAccessor = member; } } @@ -4785,22 +5073,22 @@ var ts; function isLeftHandSideExpression(expr) { if (expr) { switch (expr.kind) { - case 156: - case 157: - case 159: case 158: + case 159: + case 161: case 160: - case 154: case 162: - case 155: - case 175: - case 163: + case 156: + case 164: + case 157: + case 177: + case 165: case 65: case 9: case 7: case 8: case 10: - case 172: + case 174: case 80: case 89: case 93: @@ -4816,6 +5104,12 @@ var ts; return token >= 53 && token <= 64; } ts.isAssignmentOperator = isAssignmentOperator; + function isExpressionWithTypeArgumentsInClassExtendsClause(node) { + return node.kind === 179 && + node.parent.token === 79 && + node.parent.parent.kind === 204; + } + ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; function isSupportedExpressionWithTypeArguments(node) { return isSupportedExpressionWithTypeArgumentsRest(node.expression); } @@ -4824,7 +5118,7 @@ var ts; if (node.kind === 65) { return true; } - else if (node.kind === 156) { + else if (node.kind === 158) { return isSupportedExpressionWithTypeArgumentsRest(node.expression); } else { @@ -4832,8 +5126,8 @@ var ts; } } function isRightSideOfQualifiedNameOrPropertyAccess(node) { - return (node.parent.kind === 127 && node.parent.right === node) || - (node.parent.kind === 156 && node.parent.name === node); + return (node.parent.kind === 128 && node.parent.right === node) || + (node.parent.kind === 158 && node.parent.name === node); } ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess; function getLocalSymbolForExportDefault(symbol) { @@ -4960,6 +5254,12 @@ var ts; return start <= textSpanEnd(span) && end >= span.start; } ts.textSpanIntersectsWith = textSpanIntersectsWith; + function decodedTextSpanIntersectsWith(start1, length1, start2, length2) { + var end1 = start1 + length1; + var end2 = start2 + length2; + return start2 <= end1 && end2 >= start1; + } + ts.decodedTextSpanIntersectsWith = decodedTextSpanIntersectsWith; function textSpanIntersectsWithPosition(span, position) { return position <= textSpanEnd(span) && position >= span.start; } @@ -5030,9 +5330,9 @@ var ts; } ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions; function getTypeParameterOwner(d) { - if (d && d.kind === 129) { + if (d && d.kind === 130) { for (var current = d; current; current = current.parent) { - if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 203) { + if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 205) { return current; } } @@ -5044,7 +5344,7 @@ var ts; /// var ts; (function (ts) { - var nodeConstructors = new Array(252); + var nodeConstructors = new Array(254); ts.parseTime = 0; function getNodeConstructor(kind) { return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); @@ -5082,20 +5382,20 @@ var ts; var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; var cbNodes = cbNodeArray || cbNode; switch (node.kind) { - case 127: + case 128: return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); - case 129: + case 130: return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); - case 130: + case 131: + case 134: case 133: - case 132: - case 225: - case 226: - case 199: - case 153: + case 227: + case 228: + case 201: + case 155: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || @@ -5104,24 +5404,24 @@ var ts; visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); - case 143: - case 144: - case 139: + case 145: + case 146: case 140: case 141: + case 142: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 135: - case 134: case 136: + case 135: case 137: case 138: - case 163: - case 201: - case 164: + case 139: + case 165: + case 203: + case 166: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || @@ -5132,263 +5432,267 @@ var ts; visitNode(cbNode, node.type) || visitNode(cbNode, node.equalsGreaterThanToken) || visitNode(cbNode, node.body); - case 142: + case 144: return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); - case 145: - return visitNode(cbNode, node.exprName); - case 146: - return visitNodes(cbNodes, node.members); + case 143: + return visitNode(cbNode, node.parameterName) || + visitNode(cbNode, node.type); case 147: - return visitNode(cbNode, node.elementType); + return visitNode(cbNode, node.exprName); case 148: - return visitNodes(cbNodes, node.elementTypes); + return visitNodes(cbNodes, node.members); case 149: - return visitNodes(cbNodes, node.types); + return visitNode(cbNode, node.elementType); case 150: - return visitNode(cbNode, node.type); + return visitNodes(cbNodes, node.elementTypes); case 151: + return visitNodes(cbNodes, node.types); case 152: - return visitNodes(cbNodes, node.elements); + return visitNode(cbNode, node.type); + case 153: case 154: return visitNodes(cbNodes, node.elements); - case 155: - return visitNodes(cbNodes, node.properties); case 156: + return visitNodes(cbNodes, node.elements); + case 157: + return visitNodes(cbNodes, node.properties); + case 158: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.dotToken) || visitNode(cbNode, node.name); - case 157: + case 159: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); - case 158: - case 159: + case 160: + case 161: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); - case 160: + case 162: return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); - case 161: + case 163: return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); - case 162: - return visitNode(cbNode, node.expression); - case 165: - return visitNode(cbNode, node.expression); - case 166: + case 164: return visitNode(cbNode, node.expression); case 167: return visitNode(cbNode, node.expression); case 168: + return visitNode(cbNode, node.expression); + case 169: + return visitNode(cbNode, node.expression); + case 170: return visitNode(cbNode, node.operand); - case 173: + case 175: return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); - case 169: + case 171: return visitNode(cbNode, node.operand); - case 170: + case 172: return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); - case 171: + case 173: return visitNode(cbNode, node.condition) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.colonToken) || visitNode(cbNode, node.whenFalse); - case 174: + case 176: return visitNode(cbNode, node.expression); - case 180: - case 207: + case 182: + case 209: return visitNodes(cbNodes, node.statements); - case 228: + case 230: return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); - case 181: + case 183: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); - case 200: + case 202: return visitNodes(cbNodes, node.declarations); - case 183: + case 185: return visitNode(cbNode, node.expression); - case 184: + case 186: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); - case 185: + case 187: return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); - case 186: + case 188: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 187: + case 189: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.incrementor) || visitNode(cbNode, node.statement); - case 188: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); - case 189: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); case 190: - case 191: - return visitNode(cbNode, node.label); - case 192: - return visitNode(cbNode, node.expression); - case 193: - return visitNode(cbNode, node.expression) || + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); + case 191: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 192: + case 193: + return visitNode(cbNode, node.label); case 194: - return visitNode(cbNode, node.expression) || - visitNode(cbNode, node.caseBlock); - case 208: - return visitNodes(cbNodes, node.clauses); - case 221: - return visitNode(cbNode, node.expression) || - visitNodes(cbNodes, node.statements); - case 222: - return visitNodes(cbNodes, node.statements); + return visitNode(cbNode, node.expression); case 195: - return visitNode(cbNode, node.label) || + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 196: - return visitNode(cbNode, node.expression); + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.caseBlock); + case 210: + return visitNodes(cbNodes, node.clauses); + case 223: + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.statements); + case 224: + return visitNodes(cbNodes, node.statements); case 197: + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + case 198: + return visitNode(cbNode, node.expression); + case 199: return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); - case 224: + case 226: return visitNode(cbNode, node.variableDeclaration) || visitNode(cbNode, node.block); - case 131: + case 132: return visitNode(cbNode, node.expression); - case 202: - case 175: - return visitNodes(cbNodes, node.decorators) || - visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); - case 203: - return visitNodes(cbNodes, node.decorators) || - visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); case 204: + case 177: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || - visitNode(cbNode, node.type); + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || + visitNodes(cbNodes, node.members); case 205: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 227: - return visitNode(cbNode, node.name) || - visitNode(cbNode, node.initializer); case 206: + return visitNodes(cbNodes, node.decorators) || + visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNode(cbNode, node.type); + case 207: + return visitNodes(cbNodes, node.decorators) || + visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.members); + case 229: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + case 208: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.body); - case 209: + case 211: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); - case 210: + case 212: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.importClause) || visitNode(cbNode, node.moduleSpecifier); - case 211: + case 213: return visitNode(cbNode, node.name) || visitNode(cbNode, node.namedBindings); - case 212: + case 214: return visitNode(cbNode, node.name); - case 213: - case 217: + case 215: + case 219: return visitNodes(cbNodes, node.elements); - case 216: + case 218: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportClause) || visitNode(cbNode, node.moduleSpecifier); - case 214: - case 218: + case 216: + case 220: return visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.name); - case 215: + case 217: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.expression); - case 172: + case 174: return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); - case 178: + case 180: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); - case 128: + case 129: return visitNode(cbNode, node.expression); - case 223: + case 225: return visitNodes(cbNodes, node.types); - case 177: + case 179: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments); - case 220: + case 222: return visitNode(cbNode, node.expression); - case 219: + case 221: return visitNodes(cbNodes, node.decorators); - case 229: - return visitNode(cbNode, node.type); - case 233: - return visitNodes(cbNodes, node.types); - case 234: - return visitNodes(cbNodes, node.types); - case 232: - return visitNode(cbNode, node.elementType); - case 236: + case 231: return visitNode(cbNode, node.type); case 235: + return visitNodes(cbNodes, node.types); + case 236: + return visitNodes(cbNodes, node.types); + case 234: + return visitNode(cbNode, node.elementType); + case 238: return visitNode(cbNode, node.type); case 237: - return visitNodes(cbNodes, node.members); + return visitNode(cbNode, node.type); case 239: + return visitNodes(cbNodes, node.members); + case 241: return visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeArguments); - case 240: - return visitNode(cbNode, node.type); - case 241: - return visitNodes(cbNodes, node.parameters) || - visitNode(cbNode, node.type); case 242: return visitNode(cbNode, node.type); case 243: - return visitNode(cbNode, node.type); + return visitNodes(cbNodes, node.parameters) || + visitNode(cbNode, node.type); case 244: return visitNode(cbNode, node.type); - case 238: + case 245: + return visitNode(cbNode, node.type); + case 246: + return visitNode(cbNode, node.type); + case 240: return visitNode(cbNode, node.name) || visitNode(cbNode, node.type); - case 245: - return visitNodes(cbNodes, node.tags); case 247: + return visitNodes(cbNodes, node.tags); + case 249: return visitNode(cbNode, node.preParameterName) || visitNode(cbNode, node.typeExpression) || visitNode(cbNode, node.postParameterName); - case 248: - return visitNode(cbNode, node.typeExpression); - case 249: - return visitNode(cbNode, node.typeExpression); case 250: + return visitNode(cbNode, node.typeExpression); + case 251: + return visitNode(cbNode, node.typeExpression); + case 252: return visitNodes(cbNodes, node.typeParameters); } } @@ -5462,7 +5766,7 @@ var ts; sourceFile = createSourceFile(fileName, languageVersion); token = nextToken(); processReferenceComments(sourceFile); - sourceFile.statements = parseList(0, true, parseSourceElement); + sourceFile.statements = parseList(0, parseStatement); ts.Debug.assert(token === 1); sourceFile.endOfFileToken = parseTokenNode(); setExternalModuleIndicator(sourceFile); @@ -5483,9 +5787,9 @@ var ts; return; function visit(node) { switch (node.kind) { - case 181: - case 201: - case 130: + case 183: + case 203: + case 131: addJSDocComment(node); } forEachChild(node, visit); @@ -5523,7 +5827,7 @@ var ts; } Parser.fixupParentReferences = fixupParentReferences; function createSourceFile(fileName, languageVersion) { - var sourceFile = createNode(228, 0); + var sourceFile = createNode(230, 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; sourceFile.text = sourceText; @@ -5541,9 +5845,6 @@ var ts; contextFlags &= ~flag; } } - function setStrictModeContext(val) { - setContextFlag(val, 1); - } function setDisallowInContext(val) { setContextFlag(val, 2); } @@ -5614,9 +5915,6 @@ var ts; function inYieldContext() { return (contextFlags & 4) !== 0; } - function inStrictModeContext() { - return (contextFlags & 1) !== 0; - } function inGeneratorParameterContext() { return (contextFlags & 8) !== 0; } @@ -5825,7 +6123,7 @@ var ts; return token === 8 || token === 7 || isIdentifierOrKeyword(); } function parseComputedPropertyName() { - var node = createNode(128); + var node = createNode(129); parseExpected(18); var yieldContext = inYieldContext(); if (inGeneratorParameterContext()) { @@ -5879,23 +6177,21 @@ var ts; switch (parsingContext) { case 0: case 1: - return !(token === 22 && inErrorRecovery) && isStartOfModuleElement(); - case 2: - case 4: - return !(token === 22 && inErrorRecovery) && isStartOfStatement(); case 3: + return !(token === 22 && inErrorRecovery) && isStartOfStatement(); + case 2: return token === 67 || token === 73; - case 5: + case 4: return isStartOfTypeMember(); - case 6: + case 5: return lookAhead(isClassMemberStart) || (token === 22 && !inErrorRecovery); - case 7: + case 6: return token === 18 || isLiteralPropertyName(); - case 13: + case 12: return token === 18 || token === 35 || isLiteralPropertyName(); - case 10: + case 9: return isLiteralPropertyName(); - case 8: + case 7: if (token === 14) { return lookAhead(isValidHeritageClauseObjectLiteral); } @@ -5905,29 +6201,29 @@ var ts; else { return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword(); } - case 9: + case 8: return isIdentifierOrPattern(); - case 11: + case 10: return token === 23 || token === 21 || isIdentifierOrPattern(); - case 16: - return isIdentifier(); - case 12: - case 14: - return token === 23 || token === 21 || isStartOfExpression(); case 15: + return isIdentifier(); + case 11: + case 13: + return token === 23 || token === 21 || isStartOfExpression(); + case 14: return isStartOfParameter(); + case 16: case 17: - case 18: return token === 23 || isStartOfType(); - case 19: + case 18: return isHeritageClause(); - case 20: + case 19: return isIdentifierOrKeyword(); + case 20: case 21: - case 22: - case 24: - return JSDocParser.isJSDocType(); case 23: + return JSDocParser.isJSDocType(); + case 22: return isSimplePropertyName(); } ts.Debug.fail("Non-exhaustive case in 'isListElement'."); @@ -5962,41 +6258,40 @@ var ts; switch (kind) { case 1: case 2: - case 3: + case 4: case 5: case 6: - case 7: - case 13: - case 10: - case 20: - return token === 15; - case 4: - return token === 15 || token === 67 || token === 73; - case 8: - return token === 14 || token === 79 || token === 102; - case 9: - return isVariableDeclaratorListTerminator(); - case 16: - return token === 25 || token === 16 || token === 14 || token === 79 || token === 102; case 12: - return token === 17 || token === 22; - case 14: - case 18: - case 11: - return token === 19; - case 15: - return token === 17 || token === 19; - case 17: - return token === 25 || token === 16; + case 9: case 19: + return token === 15; + case 3: + return token === 15 || token === 67 || token === 73; + case 7: + return token === 14 || token === 79 || token === 102; + case 8: + return isVariableDeclaratorListTerminator(); + case 15: + return token === 25 || token === 16 || token === 14 || token === 79 || token === 102; + case 11: + return token === 17 || token === 22; + case 13: + case 17: + case 10: + return token === 19; + case 14: + return token === 17 || token === 19; + case 16: + return token === 25 || token === 16; + case 18: return token === 14 || token === 15; - case 21: + case 20: return token === 17 || token === 51 || token === 15; - case 22: + case 21: return token === 25 || token === 15; - case 24: - return token === 19 || token === 15; case 23: + return token === 19 || token === 15; + case 22: return token === 15; } } @@ -6013,7 +6308,7 @@ var ts; return false; } function isInSomeParsingContext() { - for (var kind = 0; kind < 25; kind++) { + for (var kind = 0; kind < 24; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, true) || isListTerminator(kind)) { return true; @@ -6022,43 +6317,25 @@ var ts; } return false; } - function parseList(kind, checkForStrictMode, parseElement) { + function parseList(kind, parseElement) { var saveParsingContext = parsingContext; parsingContext |= 1 << kind; var result = []; result.pos = getNodePos(); - var savedStrictModeContext = inStrictModeContext(); while (!isListTerminator(kind)) { if (isListElement(kind, false)) { var element = parseListElement(kind, parseElement); result.push(element); - if (checkForStrictMode && !inStrictModeContext()) { - if (ts.isPrologueDirective(element)) { - if (isUseStrictPrologueDirective(element)) { - setStrictModeContext(true); - checkForStrictMode = false; - } - } - else { - checkForStrictMode = false; - } - } continue; } if (abortParsingListOrMoveToNextToken(kind)) { break; } } - setStrictModeContext(savedStrictModeContext); result.end = getNodeEnd(); parsingContext = saveParsingContext; return result; } - function isUseStrictPrologueDirective(node) { - ts.Debug.assert(ts.isPrologueDirective(node)); - var nodeText = ts.getTextOfNodeFromSourceText(sourceText, node.expression); - return nodeText === '"use strict"' || nodeText === "'use strict'"; - } function parseListElement(parsingContext, parseElement) { var node = currentNode(parsingContext); if (node) { @@ -6083,7 +6360,7 @@ var ts; if (ts.containsParseError(node)) { return undefined; } - var nodeContextFlags = node.parserContextFlags & 63; + var nodeContextFlags = node.parserContextFlags & 62; if (nodeContextFlags !== contextFlags) { return undefined; } @@ -6099,61 +6376,47 @@ var ts; } function canReuseNode(node, parsingContext) { switch (parsingContext) { - case 1: - return isReusableModuleElement(node); - case 6: - return isReusableClassMember(node); - case 3: - return isReusableSwitchClause(node); - case 2: - case 4: - return isReusableStatement(node); - case 7: - return isReusableEnumMember(node); case 5: + return isReusableClassMember(node); + case 2: + return isReusableSwitchClause(node); + case 0: + case 1: + case 3: + return isReusableStatement(node); + case 6: + return isReusableEnumMember(node); + case 4: return isReusableTypeMember(node); - case 9: - return isReusableVariableDeclaration(node); - case 15: - return isReusableParameter(node); - case 19: - case 16: - case 18: - case 17: - case 12: - case 13: case 8: - } - return false; - } - function isReusableModuleElement(node) { - if (node) { - switch (node.kind) { - case 210: - case 209: - case 216: - case 215: - case 202: - case 203: - case 206: - case 205: - return true; - } - return isReusableStatement(node); + return isReusableVariableDeclaration(node); + case 14: + return isReusableParameter(node); + case 18: + case 15: + case 17: + case 16: + case 11: + case 12: + case 7: } return false; } function isReusableClassMember(node) { if (node) { switch (node.kind) { - case 136: - case 141: - case 135: case 137: + case 142: case 138: - case 133: - case 179: + case 139: + case 134: + case 181: return true; + case 136: + var methodDeclaration = node; + var nameIsConstructor = methodDeclaration.name.kind === 65 && + methodDeclaration.name.originalKeywordKind === 114; + return !nameIsConstructor; } } return false; @@ -6161,8 +6424,8 @@ var ts; function isReusableSwitchClause(node) { if (node) { switch (node.kind) { - case 221: - case 222: + case 223: + case 224: return true; } } @@ -6171,56 +6434,65 @@ var ts; function isReusableStatement(node) { if (node) { switch (node.kind) { - case 201: - case 181: - case 180: - case 184: + case 203: case 183: - case 196: - case 192: - case 194: - case 191: - case 190: - case 188: - case 189: - case 187: - case 186: - case 193: case 182: - case 197: - case 195: + case 186: case 185: case 198: + case 194: + case 196: + case 193: + case 192: + case 190: + case 191: + case 189: + case 188: + case 195: + case 184: + case 199: + case 197: + case 187: + case 200: + case 212: + case 211: + case 218: + case 217: + case 208: + case 204: + case 205: + case 207: + case 206: return true; } } return false; } function isReusableEnumMember(node) { - return node.kind === 227; + return node.kind === 229; } function isReusableTypeMember(node) { if (node) { switch (node.kind) { - case 140: - case 134: case 141: - case 132: - case 139: + case 135: + case 142: + case 133: + case 140: return true; } } return false; } function isReusableVariableDeclaration(node) { - if (node.kind !== 199) { + if (node.kind !== 201) { return false; } var variableDeclarator = node; return variableDeclarator.initializer === undefined; } function isReusableParameter(node) { - if (node.kind !== 130) { + if (node.kind !== 131) { return false; } var parameter = node; @@ -6238,29 +6510,28 @@ var ts; switch (context) { case 0: return ts.Diagnostics.Declaration_or_statement_expected; case 1: return ts.Diagnostics.Declaration_or_statement_expected; - case 2: return ts.Diagnostics.Statement_expected; - case 3: return ts.Diagnostics.case_or_default_expected; - case 4: return ts.Diagnostics.Statement_expected; - case 5: return ts.Diagnostics.Property_or_signature_expected; - case 6: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; - case 7: return ts.Diagnostics.Enum_member_expected; - case 8: return ts.Diagnostics.Expression_expected; - case 9: return ts.Diagnostics.Variable_declaration_expected; - case 10: return ts.Diagnostics.Property_destructuring_pattern_expected; - case 11: return ts.Diagnostics.Array_element_destructuring_pattern_expected; - case 12: return ts.Diagnostics.Argument_expression_expected; - case 13: return ts.Diagnostics.Property_assignment_expected; - case 14: return ts.Diagnostics.Expression_or_comma_expected; - case 15: return ts.Diagnostics.Parameter_declaration_expected; - case 16: return ts.Diagnostics.Type_parameter_declaration_expected; - case 17: return ts.Diagnostics.Type_argument_expected; - case 18: return ts.Diagnostics.Type_expected; - case 19: return ts.Diagnostics.Unexpected_token_expected; - case 20: return ts.Diagnostics.Identifier_expected; - case 21: return ts.Diagnostics.Parameter_declaration_expected; - case 22: return ts.Diagnostics.Type_argument_expected; - case 24: return ts.Diagnostics.Type_expected; - case 23: return ts.Diagnostics.Property_assignment_expected; + case 2: return ts.Diagnostics.case_or_default_expected; + case 3: return ts.Diagnostics.Statement_expected; + case 4: return ts.Diagnostics.Property_or_signature_expected; + case 5: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; + case 6: return ts.Diagnostics.Enum_member_expected; + case 7: return ts.Diagnostics.Expression_expected; + case 8: return ts.Diagnostics.Variable_declaration_expected; + case 9: return ts.Diagnostics.Property_destructuring_pattern_expected; + case 10: return ts.Diagnostics.Array_element_destructuring_pattern_expected; + case 11: return ts.Diagnostics.Argument_expression_expected; + case 12: return ts.Diagnostics.Property_assignment_expected; + case 13: return ts.Diagnostics.Expression_or_comma_expected; + case 14: return ts.Diagnostics.Parameter_declaration_expected; + case 15: return ts.Diagnostics.Type_parameter_declaration_expected; + case 16: return ts.Diagnostics.Type_argument_expected; + case 17: return ts.Diagnostics.Type_expected; + case 18: return ts.Diagnostics.Unexpected_token_expected; + case 19: return ts.Diagnostics.Identifier_expected; + case 20: return ts.Diagnostics.Parameter_declaration_expected; + case 21: return ts.Diagnostics.Type_argument_expected; + case 23: return ts.Diagnostics.Type_expected; + case 22: return ts.Diagnostics.Property_assignment_expected; } } ; @@ -6319,7 +6590,7 @@ var ts; function parseEntityName(allowReservedWords, diagnosticMessage) { var entity = parseIdentifier(diagnosticMessage); while (parseOptional(20)) { - var node = createNode(127, entity.pos); + var node = createNode(128, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -6327,7 +6598,7 @@ var ts; return entity; } function parseRightSideOfDot(allowIdentifierNames) { - if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord()) { + if (scanner.hasPrecedingLineBreak() && isIdentifierOrKeyword()) { var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); if (matchesPattern) { return createMissingNode(65, true, ts.Diagnostics.Identifier_expected); @@ -6336,7 +6607,7 @@ var ts; return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); } function parseTemplateExpression() { - var template = createNode(172); + var template = createNode(174); template.head = parseLiteralNode(); ts.Debug.assert(template.head.kind === 11, "Template head has wrong token kind"); var templateSpans = []; @@ -6349,7 +6620,7 @@ var ts; return finishNode(template); } function parseTemplateSpan() { - var span = createNode(178); + var span = createNode(180); span.expression = allowInAnd(parseExpression); var literal; if (token === 15) { @@ -6382,22 +6653,30 @@ var ts; } return node; } - function parseTypeReference() { - var node = createNode(142); - node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + function parseTypeReferenceOrTypePredicate() { + var typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + if (typeName.kind === 65 && token === 117 && !scanner.hasPrecedingLineBreak()) { + nextToken(); + var node_1 = createNode(143, typeName.pos); + node_1.parameterName = typeName; + node_1.type = parseType(); + return finishNode(node_1); + } + var node = createNode(144, typeName.pos); + node.typeName = typeName; if (!scanner.hasPrecedingLineBreak() && token === 24) { - node.typeArguments = parseBracketedList(17, parseType, 24, 25); + node.typeArguments = parseBracketedList(16, parseType, 24, 25); } return finishNode(node); } function parseTypeQuery() { - var node = createNode(145); + var node = createNode(147); parseExpected(97); node.exprName = parseEntityName(true); return finishNode(node); } function parseTypeParameter() { - var node = createNode(129); + var node = createNode(130); node.name = parseIdentifier(); if (parseOptional(79)) { if (isStartOfType() || !isStartOfExpression()) { @@ -6411,7 +6690,7 @@ var ts; } function parseTypeParameters() { if (token === 24) { - return parseBracketedList(16, parseTypeParameter, 24, 25); + return parseBracketedList(15, parseTypeParameter, 24, 25); } } function parseParameterType() { @@ -6432,7 +6711,7 @@ var ts; } } function parseParameter() { - var node = createNode(130); + var node = createNode(131); node.decorators = parseDecorators(); setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(21); @@ -6466,7 +6745,7 @@ var ts; var savedGeneratorParameterContext = inGeneratorParameterContext(); setYieldContext(yieldAndGeneratorParameterContext); setGeneratorParameterContext(yieldAndGeneratorParameterContext); - var result = parseDelimitedList(15, parseParameter); + var result = parseDelimitedList(14, parseParameter); setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); if (!parseExpected(17) && requireCompleteParameterList) { @@ -6484,7 +6763,7 @@ var ts; } function parseSignatureMember(kind) { var node = createNode(kind); - if (kind === 140) { + if (kind === 141) { parseExpected(88); } fillSignature(51, false, false, node); @@ -6524,10 +6803,10 @@ var ts; return token === 51 || token === 23 || token === 19; } function parseIndexSignatureDeclaration(fullStart, decorators, modifiers) { - var node = createNode(141, fullStart); + var node = createNode(142, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - node.parameters = parseBracketedList(15, parseParameter, 18, 19); + node.parameters = parseBracketedList(14, parseParameter, 18, 19); node.type = parseTypeAnnotation(); parseTypeMemberSemicolon(); return finishNode(node); @@ -6537,7 +6816,7 @@ var ts; var name = parsePropertyName(); var questionToken = parseOptionalToken(50); if (token === 16 || token === 24) { - var method = createNode(134, fullStart); + var method = createNode(135, fullStart); method.name = name; method.questionToken = questionToken; fillSignature(51, false, false, method); @@ -6545,7 +6824,7 @@ var ts; return finishNode(method); } else { - var property = createNode(132, fullStart); + var property = createNode(133, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -6587,14 +6866,14 @@ var ts; switch (token) { case 16: case 24: - return parseSignatureMember(139); + return parseSignatureMember(140); case 18: return isIndexSignature() ? parseIndexSignatureDeclaration(scanner.getStartPos(), undefined, undefined) : parsePropertyOrMethodSignature(); case 88: if (lookAhead(isStartOfConstructSignature)) { - return parseSignatureMember(140); + return parseSignatureMember(141); } case 8: case 7: @@ -6624,14 +6903,14 @@ var ts; return token === 16 || token === 24; } function parseTypeLiteral() { - var node = createNode(146); + var node = createNode(148); node.members = parseObjectTypeMembers(); return finishNode(node); } function parseObjectTypeMembers() { var members; if (parseExpected(14)) { - members = parseList(5, false, parseTypeMember); + members = parseList(4, parseTypeMember); parseExpected(15); } else { @@ -6640,12 +6919,12 @@ var ts; return members; } function parseTupleType() { - var node = createNode(148); - node.elementTypes = parseBracketedList(18, parseType, 18, 19); + var node = createNode(150); + node.elementTypes = parseBracketedList(17, parseType, 18, 19); return finishNode(node); } function parseParenthesizedType() { - var node = createNode(150); + var node = createNode(152); parseExpected(16); node.type = parseType(); parseExpected(17); @@ -6653,7 +6932,7 @@ var ts; } function parseFunctionOrConstructorType(kind) { var node = createNode(kind); - if (kind === 144) { + if (kind === 146) { parseExpected(88); } fillSignature(32, false, false, node); @@ -6666,12 +6945,12 @@ var ts; function parseNonArrayType() { switch (token) { case 112: - case 122: - case 120: - case 113: case 123: + case 121: + case 113: + case 124: var node = tryParse(parseKeywordAndNoDot); - return node || parseTypeReference(); + return node || parseTypeReferenceOrTypePredicate(); case 99: return parseTokenNode(); case 97: @@ -6683,16 +6962,16 @@ var ts; case 16: return parseParenthesizedType(); default: - return parseTypeReference(); + return parseTypeReferenceOrTypePredicate(); } } function isStartOfType() { switch (token) { case 112: - case 122: - case 120: - case 113: case 123: + case 121: + case 113: + case 124: case 99: case 97: case 14: @@ -6714,7 +6993,7 @@ var ts; var type = parseNonArrayType(); while (!scanner.hasPrecedingLineBreak() && parseOptional(18)) { parseExpected(19); - var node = createNode(147, type.pos); + var node = createNode(149, type.pos); node.elementType = type; type = finishNode(node); } @@ -6729,7 +7008,7 @@ var ts; types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(149, type.pos); + var node = createNode(151, type.pos); node.types = types; type = finishNode(node); } @@ -6774,10 +7053,10 @@ var ts; } function parseTypeWorker() { if (isStartOfFunctionType()) { - return parseFunctionOrConstructorType(143); + return parseFunctionOrConstructorType(145); } if (token === 88) { - return parseFunctionOrConstructorType(144); + return parseFunctionOrConstructorType(146); } return parseUnionTypeOrHigher(); } @@ -6898,10 +7177,7 @@ var ts; if (inYieldContext()) { return true; } - if (inStrictModeContext()) { - return true; - } - return lookAhead(nextTokenIsIdentifierOnSameLine); + return lookAhead(nextTokenIsIdentifierOrKeywordOrNumberOnSameLine); } return false; } @@ -6910,7 +7186,7 @@ var ts; return !scanner.hasPrecedingLineBreak() && isIdentifier(); } function parseYieldExpression() { - var node = createNode(173); + var node = createNode(175); nextToken(); if (!scanner.hasPrecedingLineBreak() && (token === 35 || isStartOfExpression())) { @@ -6924,8 +7200,8 @@ var ts; } function parseSimpleArrowFunctionExpression(identifier) { ts.Debug.assert(token === 32, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(164, identifier.pos); - var parameter = createNode(130, identifier.pos); + var node = createNode(166, identifier.pos); + var parameter = createNode(131, identifier.pos); parameter.name = identifier; finishNode(parameter); node.parameters = [parameter]; @@ -7003,7 +7279,7 @@ var ts; return parseParenthesizedArrowFunctionExpressionHead(false); } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { - var node = createNode(164); + var node = createNode(166); fillSignature(51, false, !allowAmbiguity, node); if (!node.parameters) { return undefined; @@ -7031,7 +7307,7 @@ var ts; if (!questionToken) { return leftOperand; } - var node = createNode(171, leftOperand.pos); + var node = createNode(173, leftOperand.pos); node.condition = leftOperand; node.questionToken = questionToken; node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher); @@ -7044,7 +7320,7 @@ var ts; return parseBinaryExpressionRest(precedence, leftOperand); } function isInOrOfKeyword(t) { - return t === 86 || t === 126; + return t === 86 || t === 127; } function parseBinaryExpressionRest(precedence, leftOperand) { while (true) { @@ -7105,33 +7381,33 @@ var ts; return -1; } function makeBinaryExpression(left, operatorToken, right) { - var node = createNode(170, left.pos); + var node = createNode(172, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; return finishNode(node); } function parsePrefixUnaryExpression() { - var node = createNode(168); + var node = createNode(170); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseDeleteExpression() { - var node = createNode(165); + var node = createNode(167); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(166); + var node = createNode(168); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(167); + var node = createNode(169); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); @@ -7161,7 +7437,7 @@ var ts; var expression = parseLeftHandSideExpressionOrHigher(); ts.Debug.assert(ts.isLeftHandSideExpression(expression)); if ((token === 38 || token === 39) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(169, expression.pos); + var node = createNode(171, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -7184,14 +7460,14 @@ var ts; if (token === 16 || token === 20) { return expression; } - var node = createNode(156, expression.pos); + var node = createNode(158, expression.pos); node.expression = expression; node.dotToken = parseExpectedToken(20, false, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); node.name = parseRightSideOfDot(true); return finishNode(node); } function parseTypeAssertion() { - var node = createNode(161); + var node = createNode(163); parseExpected(24); node.type = parseType(); parseExpected(25); @@ -7202,7 +7478,7 @@ var ts; while (true) { var dotToken = parseOptionalToken(20); if (dotToken) { - var propertyAccess = createNode(156, expression.pos); + var propertyAccess = createNode(158, expression.pos); propertyAccess.expression = expression; propertyAccess.dotToken = dotToken; propertyAccess.name = parseRightSideOfDot(true); @@ -7210,7 +7486,7 @@ var ts; continue; } if (!inDecoratorContext() && parseOptional(18)) { - var indexedAccess = createNode(157, expression.pos); + var indexedAccess = createNode(159, expression.pos); indexedAccess.expression = expression; if (token !== 19) { indexedAccess.argumentExpression = allowInAnd(parseExpression); @@ -7224,7 +7500,7 @@ var ts; continue; } if (token === 10 || token === 11) { - var tagExpression = createNode(160, expression.pos); + var tagExpression = createNode(162, expression.pos); tagExpression.tag = expression; tagExpression.template = token === 10 ? parseLiteralNode() @@ -7243,7 +7519,7 @@ var ts; if (!typeArguments) { return expression; } - var callExpr = createNode(158, expression.pos); + var callExpr = createNode(160, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); @@ -7251,7 +7527,7 @@ var ts; continue; } else if (token === 16) { - var callExpr = createNode(158, expression.pos); + var callExpr = createNode(160, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -7262,7 +7538,7 @@ var ts; } function parseArgumentList() { parseExpected(16); - var result = parseDelimitedList(12, parseArgumentExpression); + var result = parseDelimitedList(11, parseArgumentExpression); parseExpected(17); return result; } @@ -7270,7 +7546,7 @@ var ts; if (!parseOptional(24)) { return undefined; } - var typeArguments = parseDelimitedList(17, parseType); + var typeArguments = parseDelimitedList(16, parseType); if (!parseExpected(25)) { return undefined; } @@ -7341,42 +7617,42 @@ var ts; return parseIdentifier(ts.Diagnostics.Expression_expected); } function parseParenthesizedExpression() { - var node = createNode(162); + var node = createNode(164); parseExpected(16); node.expression = allowInAnd(parseExpression); parseExpected(17); return finishNode(node); } function parseSpreadElement() { - var node = createNode(174); + var node = createNode(176); parseExpected(21); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } function parseArgumentOrArrayLiteralElement() { return token === 21 ? parseSpreadElement() : - token === 23 ? createNode(176) : + token === 23 ? createNode(178) : parseAssignmentExpressionOrHigher(); } function parseArgumentExpression() { return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement); } function parseArrayLiteralExpression() { - var node = createNode(154); + var node = createNode(156); parseExpected(18); if (scanner.hasPrecedingLineBreak()) node.flags |= 512; - node.elements = parseDelimitedList(14, parseArgumentOrArrayLiteralElement); + node.elements = parseDelimitedList(13, parseArgumentOrArrayLiteralElement); parseExpected(19); return finishNode(node); } function tryParseAccessorDeclaration(fullStart, decorators, modifiers) { if (parseContextualModifier(116)) { - return parseAccessorDeclaration(137, fullStart, decorators, modifiers); - } - else if (parseContextualModifier(121)) { return parseAccessorDeclaration(138, fullStart, decorators, modifiers); } + else if (parseContextualModifier(122)) { + return parseAccessorDeclaration(139, fullStart, decorators, modifiers); + } return undefined; } function parseObjectLiteralElement() { @@ -7396,13 +7672,13 @@ var ts; return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken); } if ((token === 23 || token === 15) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(226, fullStart); + var shorthandDeclaration = createNode(228, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(225, fullStart); + var propertyAssignment = createNode(227, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; parseExpected(51); @@ -7411,12 +7687,12 @@ var ts; } } function parseObjectLiteralExpression() { - var node = createNode(155); + var node = createNode(157); parseExpected(14); if (scanner.hasPrecedingLineBreak()) { node.flags |= 512; } - node.properties = parseDelimitedList(13, parseObjectLiteralElement, true); + node.properties = parseDelimitedList(12, parseObjectLiteralElement, true); parseExpected(15); return finishNode(node); } @@ -7425,7 +7701,7 @@ var ts; if (saveDecoratorContext) { setDecoratorContext(false); } - var node = createNode(163); + var node = createNode(165); parseExpected(83); node.asteriskToken = parseOptionalToken(35); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); @@ -7440,7 +7716,7 @@ var ts; return isIdentifier() ? parseIdentifier() : undefined; } function parseNewExpression() { - var node = createNode(159); + var node = createNode(161); parseExpected(88); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); @@ -7449,10 +7725,10 @@ var ts; } return finishNode(node); } - function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { - var node = createNode(180); + function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) { + var node = createNode(182); if (parseExpected(14, diagnosticMessage) || ignoreMissingOpenBrace) { - node.statements = parseList(2, checkForStrictMode, parseStatement); + node.statements = parseList(1, parseStatement); parseExpected(15); } else { @@ -7467,7 +7743,7 @@ var ts; if (saveDecoratorContext) { setDecoratorContext(false); } - var block = parseBlock(ignoreMissingOpenBrace, true, diagnosticMessage); + var block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage); if (saveDecoratorContext) { setDecoratorContext(true); } @@ -7475,12 +7751,12 @@ var ts; return block; } function parseEmptyStatement() { - var node = createNode(182); + var node = createNode(184); parseExpected(22); return finishNode(node); } function parseIfStatement() { - var node = createNode(184); + var node = createNode(186); parseExpected(84); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -7490,7 +7766,7 @@ var ts; return finishNode(node); } function parseDoStatement() { - var node = createNode(185); + var node = createNode(187); parseExpected(75); node.statement = parseStatement(); parseExpected(100); @@ -7501,7 +7777,7 @@ var ts; return finishNode(node); } function parseWhileStatement() { - var node = createNode(186); + var node = createNode(188); parseExpected(100); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -7524,21 +7800,21 @@ var ts; } var forOrForInOrForOfStatement; if (parseOptional(86)) { - var forInStatement = createNode(188, pos); + var forInStatement = createNode(190, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); parseExpected(17); forOrForInOrForOfStatement = forInStatement; } - else if (parseOptional(126)) { - var forOfStatement = createNode(189, pos); + else if (parseOptional(127)) { + var forOfStatement = createNode(191, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(17); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(187, pos); + var forStatement = createNode(189, pos); forStatement.initializer = initializer; parseExpected(22); if (token !== 22 && token !== 17) { @@ -7556,7 +7832,7 @@ var ts; } function parseBreakOrContinueStatement(kind) { var node = createNode(kind); - parseExpected(kind === 191 ? 66 : 71); + parseExpected(kind === 193 ? 66 : 71); if (!canParseSemicolon()) { node.label = parseIdentifier(); } @@ -7564,7 +7840,7 @@ var ts; return finishNode(node); } function parseReturnStatement() { - var node = createNode(192); + var node = createNode(194); parseExpected(90); if (!canParseSemicolon()) { node.expression = allowInAnd(parseExpression); @@ -7573,7 +7849,7 @@ var ts; return finishNode(node); } function parseWithStatement() { - var node = createNode(193); + var node = createNode(195); parseExpected(101); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -7582,32 +7858,32 @@ var ts; return finishNode(node); } function parseCaseClause() { - var node = createNode(221); + var node = createNode(223); parseExpected(67); node.expression = allowInAnd(parseExpression); parseExpected(51); - node.statements = parseList(4, false, parseStatement); + node.statements = parseList(3, parseStatement); return finishNode(node); } function parseDefaultClause() { - var node = createNode(222); + var node = createNode(224); parseExpected(73); parseExpected(51); - node.statements = parseList(4, false, parseStatement); + node.statements = parseList(3, parseStatement); return finishNode(node); } function parseCaseOrDefaultClause() { return token === 67 ? parseCaseClause() : parseDefaultClause(); } function parseSwitchStatement() { - var node = createNode(194); + var node = createNode(196); parseExpected(92); parseExpected(16); node.expression = allowInAnd(parseExpression); parseExpected(17); - var caseBlock = createNode(208, scanner.getStartPos()); + var caseBlock = createNode(210, scanner.getStartPos()); parseExpected(14); - caseBlock.clauses = parseList(3, false, parseCaseOrDefaultClause); + caseBlock.clauses = parseList(2, parseCaseOrDefaultClause); parseExpected(15); node.caseBlock = finishNode(caseBlock); return finishNode(node); @@ -7615,35 +7891,35 @@ var ts; function parseThrowStatement() { // ThrowStatement[Yield] : // throw [no LineTerminator here]Expression[In, ?Yield]; - var node = createNode(196); + var node = createNode(198); parseExpected(94); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); return finishNode(node); } function parseTryStatement() { - var node = createNode(197); + var node = createNode(199); parseExpected(96); - node.tryBlock = parseBlock(false, false); + node.tryBlock = parseBlock(false); node.catchClause = token === 68 ? parseCatchClause() : undefined; if (!node.catchClause || token === 81) { parseExpected(81); - node.finallyBlock = parseBlock(false, false); + node.finallyBlock = parseBlock(false); } return finishNode(node); } function parseCatchClause() { - var result = createNode(224); + var result = createNode(226); parseExpected(68); if (parseExpected(16)) { result.variableDeclaration = parseVariableDeclaration(); } parseExpected(17); - result.block = parseBlock(false, false); + result.block = parseBlock(false); return finishNode(result); } function parseDebuggerStatement() { - var node = createNode(198); + var node = createNode(200); parseExpected(72); parseSemicolon(); return finishNode(node); @@ -7652,13 +7928,13 @@ var ts; var fullStart = scanner.getStartPos(); var expression = allowInAnd(parseExpression); if (expression.kind === 65 && parseOptional(51)) { - var labeledStatement = createNode(195, fullStart); + var labeledStatement = createNode(197, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(183, fullStart); + var expressionStatement = createNode(185, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); @@ -7671,7 +7947,11 @@ var ts; nextToken(); return isIdentifierOrKeyword() && !scanner.hasPrecedingLineBreak(); } - function parseDeclarationFlags() { + function nextTokenIsIdentifierOrKeywordOrNumberOnSameLine() { + nextToken(); + return (isIdentifierOrKeyword() || token === 7) && !scanner.hasPrecedingLineBreak(); + } + function isDeclaration() { while (true) { switch (token) { case 98: @@ -7680,28 +7960,30 @@ var ts; case 83: case 69: case 77: - return 1; + return true; case 103: - case 124: - nextToken(); - return isIdentifierOrKeyword() ? 1 : 0; - case 117: + case 125: + return nextTokenIsIdentifierOnSameLine(); case 118: + case 119: + return nextTokenIsIdentifierOrStringLiteralOnSameLine(); + case 115: nextToken(); - return isIdentifierOrKeyword() || token === 8 ? 2 : 0; + if (scanner.hasPrecedingLineBreak()) { + return false; + } + continue; case 85: nextToken(); return token === 8 || token === 35 || - token === 14 || isIdentifierOrKeyword() ? - 2 : 0; + token === 14 || isIdentifierOrKeyword(); case 78: nextToken(); if (token === 53 || token === 35 || token === 14 || token === 73) { - return 2; + return true; } continue; - case 115: case 108: case 106: case 107: @@ -7709,14 +7991,14 @@ var ts; nextToken(); continue; default: - return 0; + return false; } } } - function getDeclarationFlags() { - return lookAhead(parseDeclarationFlags); + function isStartOfDeclaration() { + return lookAhead(isDeclaration); } - function getStatementFlags() { + function isStartOfStatement() { switch (token) { case 52: case 22: @@ -7740,56 +8022,39 @@ var ts; case 72: case 68: case 81: - return 1; + return true; case 70: case 78: case 85: - return getDeclarationFlags(); + return isStartOfDeclaration(); case 115: case 103: - case 117: case 118: - case 124: - return getDeclarationFlags() || 1; + case 119: + case 125: + return true; case 108: case 106: case 107: case 109: - return getDeclarationFlags() || - (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? 0 : 1); + return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); default: - return isStartOfExpression() ? 1 : 0; + return isStartOfExpression(); } } - function isStartOfStatement() { - return (getStatementFlags() & 1) !== 0; - } - function isStartOfModuleElement() { - return (getStatementFlags() & 3) !== 0; - } - function nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine() { + function nextTokenIsIdentifierOrStartOfDestructuring() { nextToken(); - return !scanner.hasPrecedingLineBreak() && - (isIdentifier() || token === 14 || token === 18); + return isIdentifier() || token === 14 || token === 18; } function isLetDeclaration() { - return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine); + return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring); } function parseStatement() { - return parseModuleElementOfKind(1); - } - function parseModuleElement() { - return parseModuleElementOfKind(3); - } - function parseSourceElement() { - return parseModuleElementOfKind(3); - } - function parseModuleElementOfKind(flags) { switch (token) { case 22: return parseEmptyStatement(); case 14: - return parseBlock(false, false); + return parseBlock(false); case 98: return parseVariableStatement(scanner.getStartPos(), undefined, undefined); case 104: @@ -7810,9 +8075,9 @@ var ts; case 82: return parseForOrForInOrForOfStatement(); case 71: - return parseBreakOrContinueStatement(190); + return parseBreakOrContinueStatement(192); case 66: - return parseBreakOrContinueStatement(191); + return parseBreakOrContinueStatement(193); case 90: return parseReturnStatement(); case 101: @@ -7829,20 +8094,20 @@ var ts; return parseDebuggerStatement(); case 52: return parseDeclaration(); - case 70: + case 103: + case 125: + case 118: + case 119: case 115: + case 70: case 77: case 78: case 85: - case 103: - case 117: - case 118: case 106: case 107: case 108: case 109: - case 124: - if (getDeclarationFlags() & flags) { + if (isStartOfDeclaration()) { return parseDeclaration(); } break; @@ -7864,12 +8129,12 @@ var ts; return parseClassDeclaration(fullStart, decorators, modifiers); case 103: return parseInterfaceDeclaration(fullStart, decorators, modifiers); - case 124: + case 125: return parseTypeAliasDeclaration(fullStart, decorators, modifiers); case 77: return parseEnumDeclaration(fullStart, decorators, modifiers); - case 117: case 118: + case 119: return parseModuleDeclaration(fullStart, decorators, modifiers); case 85: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); @@ -7879,8 +8144,8 @@ var ts; parseExportAssignment(fullStart, decorators, modifiers) : parseExportDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { - var node = createMissingNode(219, true, ts.Diagnostics.Declaration_expected); + if (decorators || modifiers) { + var node = createMissingNode(221, true, ts.Diagnostics.Declaration_expected); node.pos = fullStart; node.decorators = decorators; setModifiers(node, modifiers); @@ -7888,6 +8153,10 @@ var ts; } } } + function nextTokenIsIdentifierOrStringLiteralOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token === 8); + } function parseFunctionBlockOrSemicolon(isGenerator, diagnosticMessage) { if (token !== 14 && canParseSemicolon()) { parseSemicolon(); @@ -7897,16 +8166,16 @@ var ts; } function parseArrayBindingElement() { if (token === 23) { - return createNode(176); + return createNode(178); } - var node = createNode(153); + var node = createNode(155); node.dotDotDotToken = parseOptionalToken(21); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(false); return finishNode(node); } function parseObjectBindingElement() { - var node = createNode(153); + var node = createNode(155); var tokenIsIdentifier = isIdentifier(); var propertyName = parsePropertyName(); if (tokenIsIdentifier && token !== 51) { @@ -7921,16 +8190,16 @@ var ts; return finishNode(node); } function parseObjectBindingPattern() { - var node = createNode(151); + var node = createNode(153); parseExpected(14); - node.elements = parseDelimitedList(10, parseObjectBindingElement); + node.elements = parseDelimitedList(9, parseObjectBindingElement); parseExpected(15); return finishNode(node); } function parseArrayBindingPattern() { - var node = createNode(152); + var node = createNode(154); parseExpected(18); - node.elements = parseDelimitedList(11, parseArrayBindingElement); + node.elements = parseDelimitedList(10, parseArrayBindingElement); parseExpected(19); return finishNode(node); } @@ -7947,7 +8216,7 @@ var ts; return parseIdentifier(); } function parseVariableDeclaration() { - var node = createNode(199); + var node = createNode(201); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -7956,7 +8225,7 @@ var ts; return finishNode(node); } function parseVariableDeclarationList(inForStatementInitializer) { - var node = createNode(200); + var node = createNode(202); switch (token) { case 98: break; @@ -7970,13 +8239,13 @@ var ts; ts.Debug.fail(); } nextToken(); - if (token === 126 && lookAhead(canFollowContextualOfKeyword)) { + if (token === 127 && lookAhead(canFollowContextualOfKeyword)) { node.declarations = createMissingList(); } else { var savedDisallowIn = inDisallowInContext(); setDisallowInContext(inForStatementInitializer); - node.declarations = parseDelimitedList(9, parseVariableDeclaration); + node.declarations = parseDelimitedList(8, parseVariableDeclaration); setDisallowInContext(savedDisallowIn); } return finishNode(node); @@ -7985,7 +8254,7 @@ var ts; return nextTokenIsIdentifier() && nextToken() === 17; } function parseVariableStatement(fullStart, decorators, modifiers) { - var node = createNode(181, fullStart); + var node = createNode(183, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(false); @@ -7993,7 +8262,7 @@ var ts; return finishNode(node); } function parseFunctionDeclaration(fullStart, decorators, modifiers) { - var node = createNode(201, fullStart); + var node = createNode(203, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(83); @@ -8004,7 +8273,7 @@ var ts; return finishNode(node); } function parseConstructorDeclaration(pos, decorators, modifiers) { - var node = createNode(136, pos); + var node = createNode(137, pos); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(114); @@ -8013,7 +8282,7 @@ var ts; return finishNode(node); } function parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { - var method = createNode(135, fullStart); + var method = createNode(136, fullStart); method.decorators = decorators; setModifiers(method, modifiers); method.asteriskToken = asteriskToken; @@ -8024,7 +8293,7 @@ var ts; return finishNode(method); } function parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken) { - var property = createNode(133, fullStart); + var property = createNode(134, fullStart); property.decorators = decorators; setModifiers(property, modifiers); property.name = name; @@ -8093,7 +8362,7 @@ var ts; return true; } if (idToken !== undefined) { - if (!ts.isKeyword(idToken) || idToken === 121 || idToken === 116) { + if (!ts.isKeyword(idToken) || idToken === 122 || idToken === 116) { return true; } switch (token) { @@ -8120,7 +8389,7 @@ var ts; decorators = []; decorators.pos = scanner.getStartPos(); } - var decorator = createNode(131, decoratorStart); + var decorator = createNode(132, decoratorStart); decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher); decorators.push(finishNode(decorator)); } @@ -8153,7 +8422,7 @@ var ts; } function parseClassElement() { if (token === 22) { - var result = createNode(179); + var result = createNode(181); nextToken(); return finishNode(result); } @@ -8177,21 +8446,19 @@ var ts; token === 18) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { var name_6 = createMissingNode(65, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_6, undefined); } ts.Debug.fail("Should not have attempted to parse class member declaration."); } function parseClassExpression() { - return parseClassDeclarationOrExpression(scanner.getStartPos(), undefined, undefined, 175); + return parseClassDeclarationOrExpression(scanner.getStartPos(), undefined, undefined, 177); } function parseClassDeclaration(fullStart, decorators, modifiers) { - return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 202); + return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 204); } function parseClassDeclarationOrExpression(fullStart, decorators, modifiers, kind) { - var savedStrictModeContext = inStrictModeContext(); - setStrictModeContext(true); var node = createNode(kind, fullStart); node.decorators = decorators; setModifiers(node, modifiers); @@ -8208,9 +8475,7 @@ var ts; else { node.members = createMissingList(); } - var finishedNode = finishNode(node); - setStrictModeContext(savedStrictModeContext); - return finishedNode; + return finishNode(node); } function parseHeritageClauses(isClassHeritageClause) { // ClassTail[Yield,GeneratorParameter] : See 14.5 @@ -8224,23 +8489,23 @@ var ts; return undefined; } function parseHeritageClausesWorker() { - return parseList(19, false, parseHeritageClause); + return parseList(18, parseHeritageClause); } function parseHeritageClause() { if (token === 79 || token === 102) { - var node = createNode(223); + var node = createNode(225); node.token = token; nextToken(); - node.types = parseDelimitedList(8, parseExpressionWithTypeArguments); + node.types = parseDelimitedList(7, parseExpressionWithTypeArguments); return finishNode(node); } return undefined; } function parseExpressionWithTypeArguments() { - var node = createNode(177); + var node = createNode(179); node.expression = parseLeftHandSideExpressionOrHigher(); if (token === 24) { - node.typeArguments = parseBracketedList(17, parseType, 24, 25); + node.typeArguments = parseBracketedList(16, parseType, 24, 25); } return finishNode(node); } @@ -8248,10 +8513,10 @@ var ts; return token === 79 || token === 102; } function parseClassMembers() { - return parseList(6, false, parseClassElement); + return parseList(5, parseClassElement); } function parseInterfaceDeclaration(fullStart, decorators, modifiers) { - var node = createNode(203, fullStart); + var node = createNode(205, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(103); @@ -8262,30 +8527,31 @@ var ts; return finishNode(node); } function parseTypeAliasDeclaration(fullStart, decorators, modifiers) { - var node = createNode(204, fullStart); + var node = createNode(206, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(124); + parseExpected(125); node.name = parseIdentifier(); + node.typeParameters = parseTypeParameters(); parseExpected(53); node.type = parseType(); parseSemicolon(); return finishNode(node); } function parseEnumMember() { - var node = createNode(227, scanner.getStartPos()); + var node = createNode(229, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart, decorators, modifiers) { - var node = createNode(205, fullStart); + var node = createNode(207, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(77); node.name = parseIdentifier(); if (parseExpected(14)) { - node.members = parseDelimitedList(7, parseEnumMember); + node.members = parseDelimitedList(6, parseEnumMember); parseExpected(15); } else { @@ -8294,9 +8560,9 @@ var ts; return finishNode(node); } function parseModuleBlock() { - var node = createNode(207, scanner.getStartPos()); + var node = createNode(209, scanner.getStartPos()); if (parseExpected(14)) { - node.statements = parseList(1, false, parseModuleElement); + node.statements = parseList(1, parseStatement); parseExpected(15); } else { @@ -8305,7 +8571,7 @@ var ts; return finishNode(node); } function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) { - var node = createNode(206, fullStart); + var node = createNode(208, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.flags |= flags; @@ -8316,7 +8582,7 @@ var ts; return finishNode(node); } function parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers) { - var node = createNode(206, fullStart); + var node = createNode(208, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.name = parseLiteralNode(true); @@ -8325,11 +8591,11 @@ var ts; } function parseModuleDeclaration(fullStart, decorators, modifiers) { var flags = modifiers ? modifiers.flags : 0; - if (parseOptional(118)) { + if (parseOptional(119)) { flags |= 32768; } else { - parseExpected(117); + parseExpected(118); if (token === 8) { return parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers); } @@ -8337,7 +8603,7 @@ var ts; return parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags); } function isExternalModuleReference() { - return token === 119 && + return token === 120 && lookAhead(nextTokenIsOpenParen); } function nextTokenIsOpenParen() { @@ -8346,7 +8612,7 @@ var ts; function nextTokenIsCommaOrFromKeyword() { nextToken(); return token === 23 || - token === 125; + token === 126; } function parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers) { parseExpected(85); @@ -8354,8 +8620,8 @@ var ts; var identifier; if (isIdentifier()) { identifier = parseIdentifier(); - if (token !== 23 && token !== 125) { - var importEqualsDeclaration = createNode(209, fullStart); + if (token !== 23 && token !== 126) { + var importEqualsDeclaration = createNode(211, fullStart); importEqualsDeclaration.decorators = decorators; setModifiers(importEqualsDeclaration, modifiers); importEqualsDeclaration.name = identifier; @@ -8365,14 +8631,14 @@ var ts; return finishNode(importEqualsDeclaration); } } - var importDeclaration = createNode(210, fullStart); + var importDeclaration = createNode(212, fullStart); importDeclaration.decorators = decorators; setModifiers(importDeclaration, modifiers); if (identifier || token === 35 || token === 14) { importDeclaration.importClause = parseImportClause(identifier, afterImportPos); - parseExpected(125); + parseExpected(126); } importDeclaration.moduleSpecifier = parseModuleSpecifier(); parseSemicolon(); @@ -8385,13 +8651,13 @@ var ts; // NamedImports // ImportedDefaultBinding, NameSpaceImport // ImportedDefaultBinding, NamedImports - var importClause = createNode(211, fullStart); + var importClause = createNode(213, fullStart); if (identifier) { importClause.name = identifier; } if (!importClause.name || parseOptional(23)) { - importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(213); + importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(215); } return finishNode(importClause); } @@ -8401,8 +8667,8 @@ var ts; : parseEntityName(false); } function parseExternalModuleReference() { - var node = createNode(220); - parseExpected(119); + var node = createNode(222); + parseExpected(120); parseExpected(16); node.expression = parseModuleSpecifier(); parseExpected(17); @@ -8416,7 +8682,7 @@ var ts; return result; } function parseNamespaceImport() { - var namespaceImport = createNode(212); + var namespaceImport = createNode(214); parseExpected(35); parseExpected(111); namespaceImport.name = parseIdentifier(); @@ -8424,14 +8690,14 @@ var ts; } function parseNamedImportsOrExports(kind) { var node = createNode(kind); - node.elements = parseBracketedList(20, kind === 213 ? parseImportSpecifier : parseExportSpecifier, 14, 15); + node.elements = parseBracketedList(19, kind === 215 ? parseImportSpecifier : parseExportSpecifier, 14, 15); return finishNode(node); } function parseExportSpecifier() { - return parseImportOrExportSpecifier(218); + return parseImportOrExportSpecifier(220); } function parseImportSpecifier() { - return parseImportOrExportSpecifier(214); + return parseImportOrExportSpecifier(216); } function parseImportOrExportSpecifier(kind) { var node = createNode(kind); @@ -8450,22 +8716,22 @@ var ts; else { node.name = identifierName; } - if (kind === 214 && checkIdentifierIsKeyword) { + if (kind === 216 && checkIdentifierIsKeyword) { parseErrorAtPosition(checkIdentifierStart, checkIdentifierEnd - checkIdentifierStart, ts.Diagnostics.Identifier_expected); } return finishNode(node); } function parseExportDeclaration(fullStart, decorators, modifiers) { - var node = createNode(216, fullStart); + var node = createNode(218, fullStart); node.decorators = decorators; setModifiers(node, modifiers); if (parseOptional(35)) { - parseExpected(125); + parseExpected(126); node.moduleSpecifier = parseModuleSpecifier(); } else { - node.exportClause = parseNamedImportsOrExports(217); - if (parseOptional(125)) { + node.exportClause = parseNamedImportsOrExports(219); + if (parseOptional(126)) { node.moduleSpecifier = parseModuleSpecifier(); } } @@ -8473,7 +8739,7 @@ var ts; return finishNode(node); } function parseExportAssignment(fullStart, decorators, modifiers) { - var node = createNode(215, fullStart); + var node = createNode(217, fullStart); node.decorators = decorators; setModifiers(node, modifiers); if (parseOptional(53)) { @@ -8538,15 +8804,15 @@ var ts; } sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { return node.flags & 1 - || node.kind === 209 && node.moduleReference.kind === 220 - || node.kind === 210 - || node.kind === 215 - || node.kind === 216 + || node.kind === 211 && node.moduleReference.kind === 222 + || node.kind === 212 + || node.kind === 217 + || node.kind === 218 ? node : undefined; }); @@ -8581,7 +8847,7 @@ var ts; function parseJSDocTypeExpression(start, length) { scanner.setText(sourceText, start, length); token = nextToken(); - var result = createNode(229); + var result = createNode(231); parseExpected(14); result.type = parseJSDocTopLevelType(); parseExpected(15); @@ -8592,12 +8858,12 @@ var ts; function parseJSDocTopLevelType() { var type = parseJSDocType(); if (token === 44) { - var unionType = createNode(233, type.pos); + var unionType = createNode(235, type.pos); unionType.types = parseJSDocTypeList(type); type = finishNode(unionType); } if (token === 53) { - var optionalType = createNode(240, type.pos); + var optionalType = createNode(242, type.pos); nextToken(); optionalType.type = type; type = finishNode(optionalType); @@ -8608,20 +8874,20 @@ var ts; var type = parseBasicTypeExpression(); while (true) { if (token === 18) { - var arrayType = createNode(232, type.pos); + var arrayType = createNode(234, type.pos); arrayType.elementType = type; nextToken(); parseExpected(19); type = finishNode(arrayType); } else if (token === 50) { - var nullableType = createNode(235, type.pos); + var nullableType = createNode(237, type.pos); nullableType.type = type; nextToken(); type = finishNode(nullableType); } else if (token === 46) { - var nonNullableType = createNode(236, type.pos); + var nonNullableType = createNode(238, type.pos); nonNullableType.type = type; nextToken(); type = finishNode(nonNullableType); @@ -8655,40 +8921,40 @@ var ts; case 93: return parseJSDocThisType(); case 112: - case 122: - case 120: - case 113: case 123: + case 121: + case 113: + case 124: case 99: return parseTokenNode(); } return parseJSDocTypeReference(); } function parseJSDocThisType() { - var result = createNode(244); + var result = createNode(246); nextToken(); parseExpected(51); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocConstructorType() { - var result = createNode(243); + var result = createNode(245); nextToken(); parseExpected(51); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocVariadicType() { - var result = createNode(242); + var result = createNode(244); nextToken(); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocFunctionType() { - var result = createNode(241); + var result = createNode(243); nextToken(); parseExpected(16); - result.parameters = parseDelimitedList(21, parseJSDocParameter); + result.parameters = parseDelimitedList(20, parseJSDocParameter); checkForTrailingComma(result.parameters); parseExpected(17); if (token === 51) { @@ -8698,18 +8964,18 @@ var ts; return finishNode(result); } function parseJSDocParameter() { - var parameter = createNode(130); + var parameter = createNode(131); parameter.type = parseJSDocType(); return finishNode(parameter); } function parseJSDocOptionalType(type) { - var result = createNode(240, type.pos); + var result = createNode(242, type.pos); nextToken(); result.type = type; return finishNode(result); } function parseJSDocTypeReference() { - var result = createNode(239); + var result = createNode(241); result.name = parseSimplePropertyName(); while (parseOptional(20)) { if (token === 24) { @@ -8724,7 +8990,7 @@ var ts; } function parseTypeArguments() { nextToken(); - var typeArguments = parseDelimitedList(22, parseJSDocType); + var typeArguments = parseDelimitedList(21, parseJSDocType); checkForTrailingComma(typeArguments); checkForEmptyTypeArgumentList(typeArguments); parseExpected(25); @@ -8738,21 +9004,21 @@ var ts; } } function parseQualifiedName(left) { - var result = createNode(127, left.pos); + var result = createNode(128, left.pos); result.left = left; result.right = parseIdentifierName(); return finishNode(result); } function parseJSDocRecordType() { - var result = createNode(237); + var result = createNode(239); nextToken(); - result.members = parseDelimitedList(23, parseJSDocRecordMember); + result.members = parseDelimitedList(22, parseJSDocRecordMember); checkForTrailingComma(result.members); parseExpected(15); return finishNode(result); } function parseJSDocRecordMember() { - var result = createNode(238); + var result = createNode(240); result.name = parseSimplePropertyName(); if (token === 51) { nextToken(); @@ -8761,15 +9027,15 @@ var ts; return finishNode(result); } function parseJSDocNonNullableType() { - var result = createNode(236); + var result = createNode(238); nextToken(); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocTupleType() { - var result = createNode(234); + var result = createNode(236); nextToken(); - result.types = parseDelimitedList(24, parseJSDocType); + result.types = parseDelimitedList(23, parseJSDocType); checkForTrailingComma(result.types); parseExpected(19); return finishNode(result); @@ -8781,7 +9047,7 @@ var ts; } } function parseJSDocUnionType() { - var result = createNode(233); + var result = createNode(235); nextToken(); result.types = parseJSDocTypeList(parseJSDocType()); parseExpected(17); @@ -8799,7 +9065,7 @@ var ts; return types; } function parseJSDocAllType() { - var result = createNode(230); + var result = createNode(232); nextToken(); return finishNode(result); } @@ -8812,11 +9078,11 @@ var ts; token === 25 || token === 53 || token === 44) { - var result = createNode(231, pos); + var result = createNode(233, pos); return finishNode(result); } else { - var result = createNode(235, pos); + var result = createNode(237, pos); result.type = parseJSDocType(); return finishNode(result); } @@ -8887,7 +9153,7 @@ var ts; if (!tags) { return undefined; } - var result = createNode(245, start); + var result = createNode(247, start); result.tags = tags; return finishNode(result, end); } @@ -8925,7 +9191,7 @@ var ts; return undefined; } function handleUnknownTag(atToken, tagName) { - var result = createNode(246, atToken.pos); + var result = createNode(248, atToken.pos); result.atToken = atToken; result.tagName = tagName; return finishNode(result, pos); @@ -8977,7 +9243,7 @@ var ts; if (!typeExpression) { typeExpression = tryParseTypeExpression(); } - var result = createNode(247, atToken.pos); + var result = createNode(249, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.preParameterName = preName; @@ -8987,27 +9253,27 @@ var ts; return finishNode(result, pos); } function handleReturnTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 248; })) { + if (ts.forEach(tags, function (t) { return t.kind === 250; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } - var result = createNode(248, atToken.pos); + var result = createNode(250, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeExpression = tryParseTypeExpression(); return finishNode(result, pos); } function handleTypeTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 249; })) { + if (ts.forEach(tags, function (t) { return t.kind === 251; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } - var result = createNode(249, atToken.pos); + var result = createNode(251, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeExpression = tryParseTypeExpression(); return finishNode(result, pos); } function handleTemplateTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 250; })) { + if (ts.forEach(tags, function (t) { return t.kind === 252; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } var typeParameters = []; @@ -9020,7 +9286,7 @@ var ts; parseErrorAtPosition(startPos, 0, ts.Diagnostics.Identifier_expected); return undefined; } - var typeParameter = createNode(129, name_7.pos); + var typeParameter = createNode(130, name_7.pos); typeParameter.name = name_7; finishNode(typeParameter, pos); typeParameters.push(typeParameter); @@ -9031,7 +9297,7 @@ var ts; pos++; } typeParameters.end = pos; - var result = createNode(250, atToken.pos); + var result = createNode(252, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeParameters = typeParameters; @@ -9426,8 +9692,8 @@ var ts; emptyGenericType.instantiations = {}; var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); - var anySignature = createSignature(undefined, undefined, emptyArray, anyType, 0, false, false); - var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, 0, false, false); + var anySignature = createSignature(undefined, undefined, emptyArray, anyType, undefined, 0, false, false); + var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, undefined, 0, false, false); var globals = {}; var globalESSymbolConstructorSymbol; var globalObjectType; @@ -9478,6 +9744,11 @@ var ts; flags: 2097152 } }; + var subtypeRelation = {}; + var assignableRelation = {}; + var identityRelation = {}; + initializeTypeChecker(); + return checker; function getEmitResolver(sourceFile) { getDiagnostics(sourceFile); return emitResolver; @@ -9617,10 +9888,10 @@ var ts; return nodeLinks[nodeId] || (nodeLinks[nodeId] = {}); } function getSourceFile(node) { - return ts.getAncestor(node, 228); + return ts.getAncestor(node, 230); } function isGlobalSourceFile(node) { - return node.kind === 228 && !ts.isExternalModule(node); + return node.kind === 230 && !ts.isExternalModule(node); } function getSymbol(symbols, name, meaning) { if (meaning && ts.hasProperty(symbols, name)) { @@ -9668,34 +9939,37 @@ var ts; } } switch (location.kind) { - case 228: + case 230: if (!ts.isExternalModule(location)) break; - case 206: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { - if (result.flags & meaning || !(result.flags & 8388608 && getDeclarationOfAliasSymbol(result).kind === 218)) { - break loop; + case 208: + var moduleExports = getSymbolOfNode(location).exports; + if (location.kind === 230 || + (location.kind === 208 && location.name.kind === 8)) { + if (ts.hasProperty(moduleExports, name) && + moduleExports[name].flags === 8388608 && + ts.getDeclarationOfKind(moduleExports[name], 220)) { + break; } - result = undefined; - } - else if (location.kind === 228 || - (location.kind === 206 && location.name.kind === 8)) { - result = getSymbolOfNode(location).exports["default"]; + result = moduleExports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + if (result = getSymbol(moduleExports, name, meaning & 8914931)) { + break loop; + } break; - case 205: + case 207: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { break loop; } break; + case 134: case 133: - case 132: - if (location.parent.kind === 202 && !(location.flags & 128)) { + if (location.parent.kind === 204 && !(location.flags & 128)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455)) { @@ -9704,8 +9978,8 @@ var ts; } } break; - case 202: - case 203: + case 204: + case 205: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056)) { if (lastLocation && lastLocation.flags & 128) { error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters); @@ -9714,28 +9988,28 @@ var ts; break loop; } break; - case 128: + case 129: grandparent = location.parent.parent; - if (grandparent.kind === 202 || grandparent.kind === 203) { + if (grandparent.kind === 204 || grandparent.kind === 205) { if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); return undefined; } } break; - case 135: - case 134: case 136: + case 135: case 137: case 138: - case 201: - case 164: + case 139: + case 203: + case 166: if (meaning & 3 && name === "arguments") { result = argumentsSymbol; break loop; } break; - case 163: + case 165: if (meaning & 3 && name === "arguments") { result = argumentsSymbol; break loop; @@ -9748,7 +10022,7 @@ var ts; } } break; - case 175: + case 177: if (meaning & 32) { var className = location.name; if (className && name === className.text) { @@ -9757,8 +10031,8 @@ var ts; } } break; - case 131: - if (location.parent && location.parent.kind === 130) { + case 132: + if (location.parent && location.parent.kind === 131) { location = location.parent; } if (location.parent && ts.isClassElement(location.parent)) { @@ -9796,14 +10070,14 @@ var ts; ts.Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined"); var isUsedBeforeDeclaration = !isDefinedBefore(declaration, errorLocation); if (!isUsedBeforeDeclaration) { - var variableDeclaration = ts.getAncestor(declaration, 199); + var variableDeclaration = ts.getAncestor(declaration, 201); var container = ts.getEnclosingBlockScopeContainer(variableDeclaration); - if (variableDeclaration.parent.parent.kind === 181 || - variableDeclaration.parent.parent.kind === 187) { + if (variableDeclaration.parent.parent.kind === 183 || + variableDeclaration.parent.parent.kind === 189) { isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, variableDeclaration, container); } - else if (variableDeclaration.parent.parent.kind === 189 || - variableDeclaration.parent.parent.kind === 188) { + else if (variableDeclaration.parent.parent.kind === 191 || + variableDeclaration.parent.parent.kind === 190) { var expression = variableDeclaration.parent.parent.expression; isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, expression, container); } @@ -9825,10 +10099,10 @@ var ts; } function getAnyImportSyntax(node) { if (ts.isAliasSymbolDeclaration(node)) { - if (node.kind === 209) { + if (node.kind === 211) { return node; } - while (node && node.kind !== 210) { + while (node && node.kind !== 212) { node = node.parent; } return node; @@ -9838,7 +10112,7 @@ var ts; return ts.forEach(symbol.declarations, function (d) { return ts.isAliasSymbolDeclaration(d) ? d : undefined; }); } function getTargetOfImportEqualsDeclaration(node) { - if (node.moduleReference.kind === 220) { + if (node.moduleReference.kind === 222) { return resolveExternalModuleSymbol(resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node))); } return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); @@ -9927,17 +10201,17 @@ var ts; } function getTargetOfAliasDeclaration(node) { switch (node.kind) { - case 209: - return getTargetOfImportEqualsDeclaration(node); case 211: + return getTargetOfImportEqualsDeclaration(node); + case 213: return getTargetOfImportClause(node); - case 212: - return getTargetOfNamespaceImport(node); case 214: + return getTargetOfNamespaceImport(node); + case 216: return getTargetOfImportSpecifier(node); - case 218: + case 220: return getTargetOfExportSpecifier(node); - case 215: + case 217: return getTargetOfExportAssignment(node); } } @@ -9979,10 +10253,10 @@ var ts; if (!links.referenced) { links.referenced = true; var node = getDeclarationOfAliasSymbol(symbol); - if (node.kind === 215) { + if (node.kind === 217) { checkExpressionCached(node.expression); } - else if (node.kind === 218) { + else if (node.kind === 220) { checkExpressionCached(node.propertyName || node.name); } else if (ts.isInternalModuleImportEqualsDeclaration(node)) { @@ -9992,17 +10266,17 @@ var ts; } function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { if (!importDeclaration) { - importDeclaration = ts.getAncestor(entityName, 209); + importDeclaration = ts.getAncestor(entityName, 211); ts.Debug.assert(importDeclaration !== undefined); } if (entityName.kind === 65 && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { entityName = entityName.parent; } - if (entityName.kind === 65 || entityName.parent.kind === 127) { + if (entityName.kind === 65 || entityName.parent.kind === 128) { return resolveEntityName(entityName, 1536); } else { - ts.Debug.assert(entityName.parent.kind === 209); + ts.Debug.assert(entityName.parent.kind === 211); return resolveEntityName(entityName, 107455 | 793056 | 1536); } } @@ -10021,9 +10295,9 @@ var ts; return undefined; } } - else if (name.kind === 127 || name.kind === 156) { - var left = name.kind === 127 ? name.left : name.expression; - var right = name.kind === 127 ? name.right : name.name; + else if (name.kind === 128 || name.kind === 158) { + var left = name.kind === 128 ? name.left : name.expression; + var right = name.kind === 128 ? name.right : name.name; var namespace = resolveEntityName(left, 1536); if (!namespace || namespace === unknownSymbol || ts.nodeIsMissing(right)) { return undefined; @@ -10168,7 +10442,7 @@ var ts; var members = node.members; for (var _i = 0; _i < members.length; _i++) { var member = members[_i]; - if (member.kind === 136 && ts.nodeIsPresent(member.body)) { + if (member.kind === 137 && ts.nodeIsPresent(member.body)) { return member; } } @@ -10233,17 +10507,17 @@ var ts; } } switch (location_1.kind) { - case 228: + case 230: if (!ts.isExternalModule(location_1)) { break; } - case 206: + case 208: if (result = callback(getSymbolOfNode(location_1).exports)) { return result; } break; - case 202: - case 203: + case 204: + case 205: if (result = callback(getSymbolOfNode(location_1).members)) { return result; } @@ -10358,8 +10632,8 @@ var ts; } } function hasExternalModuleSymbol(declaration) { - return (declaration.kind === 206 && declaration.name.kind === 8) || - (declaration.kind === 228 && ts.isExternalModule(declaration)); + return (declaration.kind === 208 && declaration.name.kind === 8) || + (declaration.kind === 230 && ts.isExternalModule(declaration)); } function hasVisibleDeclarations(symbol) { var aliasesToMakeVisible; @@ -10391,11 +10665,11 @@ var ts; } function isEntityNameVisible(entityName, enclosingDeclaration) { var meaning; - if (entityName.parent.kind === 145) { + if (entityName.parent.kind === 147) { meaning = 107455 | 1048576; } - else if (entityName.kind === 127 || entityName.kind === 156 || - entityName.parent.kind === 209) { + else if (entityName.kind === 128 || entityName.kind === 158 || + entityName.parent.kind === 211) { meaning = 1536; } else { @@ -10425,6 +10699,13 @@ var ts; ts.releaseStringWriter(writer); return result; } + function signatureToString(signature, enclosingDeclaration, flags) { + var writer = ts.getSingleLineStringWriter(); + getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); + var result = writer.string(); + ts.releaseStringWriter(writer); + return result; + } function typeToString(type, enclosingDeclaration, flags) { var writer = ts.getSingleLineStringWriter(); getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); @@ -10439,10 +10720,10 @@ var ts; function getTypeAliasForTypeLiteral(type) { if (type.symbol && type.symbol.flags & 2048) { var node = type.symbol.declarations[0].parent; - while (node.kind === 150) { + while (node.kind === 152) { node = node.parent; } - if (node.kind === 204) { + if (node.kind === 206) { return getSymbolOfNode(node); } } @@ -10649,7 +10930,7 @@ var ts; var isNonLocalFunctionSymbol = !!(symbol.flags & 16) && (symbol.parent || ts.forEach(symbol.declarations, function (declaration) { - return declaration.parent.kind === 228 || declaration.parent.kind === 207; + return declaration.parent.kind === 230 || declaration.parent.kind === 209; })); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { return !!(flags & 2) || @@ -10723,7 +11004,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 0, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 122); + writeKeyword(writer, 123); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -10736,7 +11017,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 1, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 120); + writeKeyword(writer, 121); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -10779,7 +11060,7 @@ var ts; function buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaraiton, flags) { var targetSymbol = getTargetSymbol(symbol); if (targetSymbol.flags & 32 || targetSymbol.flags & 64) { - buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags); + buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), writer, enclosingDeclaraiton, flags); } } function buildTypeParameterDisplay(tp, writer, enclosingDeclaration, flags, symbolStack) { @@ -10881,12 +11162,12 @@ var ts; function isDeclarationVisible(node) { function getContainingExternalModule(node) { for (; node; node = node.parent) { - if (node.kind === 206) { + if (node.kind === 208) { if (node.name.kind === 8) { return node; } } - else if (node.kind === 228) { + else if (node.kind === 230) { return ts.isExternalModule(node) ? node : undefined; } } @@ -10929,58 +11210,58 @@ var ts; } function determineIfDeclarationIsVisible() { switch (node.kind) { - case 153: + case 155: return isDeclarationVisible(node.parent.parent); - case 199: + case 201: if (ts.isBindingPattern(node.name) && !node.name.elements.length) { return false; } - case 206: - case 202: - case 203: + case 208: case 204: - case 201: case 205: - case 209: + case 206: + case 203: + case 207: + case 211: var parent_4 = getDeclarationContainer(node); if (!(ts.getCombinedNodeFlags(node) & 1) && - !(node.kind !== 209 && parent_4.kind !== 228 && ts.isInAmbientContext(parent_4))) { + !(node.kind !== 211 && parent_4.kind !== 230 && ts.isInAmbientContext(parent_4))) { return isGlobalSourceFile(parent_4); } return isDeclarationVisible(parent_4); - case 133: - case 132: - case 137: - case 138: - case 135: case 134: + case 133: + case 138: + case 139: + case 136: + case 135: if (node.flags & (32 | 64)) { return false; } - case 136: - case 140: - case 139: + case 137: case 141: - case 130: - case 207: - case 143: - case 144: - case 146: + case 140: case 142: - case 147: + case 131: + case 209: + case 145: + case 146: case 148: + case 144: case 149: case 150: + case 151: + case 152: return isDeclarationVisible(node.parent); - case 211: - case 212: + case 213: case 214: + case 216: return false; - case 129: - case 228: + case 130: + case 230: return true; - case 215: + case 217: return false; default: ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); @@ -10996,10 +11277,10 @@ var ts; } function collectLinkedAliases(node) { var exportSymbol; - if (node.parent && node.parent.kind === 215) { + if (node.parent && node.parent.kind === 217) { exportSymbol = resolveName(node.parent, node.text, 107455 | 793056 | 1536, ts.Diagnostics.Cannot_find_name_0, node); } - else if (node.parent.kind === 218) { + else if (node.parent.kind === 220) { exportSymbol = getTargetOfExportSpecifier(node.parent); } var result = []; @@ -11045,7 +11326,7 @@ var ts; } function getDeclarationContainer(node) { node = ts.getRootDeclaration(node); - return node.kind === 199 ? node.parent.parent.parent : node.parent; + return node.kind === 201 ? node.parent.parent.parent : node.parent; } function getTypeOfPrototypeProperty(prototype) { var classType = getDeclaredTypeOfSymbol(prototype.parent); @@ -11071,7 +11352,7 @@ var ts; return parentType; } var type; - if (pattern.kind === 151) { + if (pattern.kind === 153) { var name_9 = declaration.propertyName || declaration.name; type = getTypeOfPropertyOfType(parentType, name_9.text) || isNumericLiteralName(name_9.text) && getIndexTypeOfType(parentType, 1) || @@ -11108,10 +11389,10 @@ var ts; return type; } function getTypeForVariableLikeDeclaration(declaration) { - if (declaration.parent.parent.kind === 188) { + if (declaration.parent.parent.kind === 190) { return anyType; } - if (declaration.parent.parent.kind === 189) { + if (declaration.parent.parent.kind === 191) { return checkRightHandSideOfForOf(declaration.parent.parent.expression) || anyType; } if (ts.isBindingPattern(declaration.parent)) { @@ -11120,10 +11401,10 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130) { + if (declaration.kind === 131) { var func = declaration.parent; - if (func.kind === 138 && !ts.hasDynamicName(func)) { - var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 137); + if (func.kind === 139 && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 138); if (getter) { return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); } @@ -11136,7 +11417,7 @@ var ts; if (declaration.initializer) { return checkExpressionCached(declaration.initializer); } - if (declaration.kind === 226) { + if (declaration.kind === 228) { return checkIdentifier(declaration.name); } return undefined; @@ -11165,7 +11446,7 @@ var ts; var hasSpreadElement = false; var elementTypes = []; ts.forEach(pattern.elements, function (e) { - elementTypes.push(e.kind === 176 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + elementTypes.push(e.kind === 178 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); if (e.dotDotDotToken) { hasSpreadElement = true; } @@ -11180,7 +11461,7 @@ var ts; return createTupleType(elementTypes); } function getTypeFromBindingPattern(pattern) { - return pattern.kind === 151 + return pattern.kind === 153 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); } @@ -11190,7 +11471,7 @@ var ts; if (reportErrors) { reportErrorsFromWidening(declaration, type); } - return declaration.kind !== 225 ? getWidenedType(type) : type; + return declaration.kind !== 227 ? getWidenedType(type) : type; } if (ts.isBindingPattern(declaration.name)) { return getTypeFromBindingPattern(declaration.name); @@ -11198,7 +11479,7 @@ var ts; type = declaration.dotDotDotToken ? anyArrayType : anyType; if (reportErrors && compilerOptions.noImplicitAny) { var root = ts.getRootDeclaration(declaration); - if (!isPrivateWithinAmbient(root) && !(root.kind === 130 && isPrivateWithinAmbient(root.parent))) { + if (!isPrivateWithinAmbient(root) && !(root.kind === 131 && isPrivateWithinAmbient(root.parent))) { reportImplicitAnyError(declaration, type); } } @@ -11211,10 +11492,10 @@ var ts; return links.type = getTypeOfPrototypeProperty(symbol); } var declaration = symbol.valueDeclaration; - if (declaration.parent.kind === 224) { + if (declaration.parent.kind === 226) { return links.type = anyType; } - if (declaration.kind === 215) { + if (declaration.kind === 217) { return links.type = checkExpression(declaration.expression); } if (!pushTypeResolution(symbol)) { @@ -11242,7 +11523,7 @@ var ts; } function getAnnotatedAccessorType(accessor) { if (accessor) { - if (accessor.kind === 137) { + if (accessor.kind === 138) { return accessor.type && getTypeFromTypeNode(accessor.type); } else { @@ -11258,8 +11539,8 @@ var ts; if (!pushTypeResolution(symbol)) { return unknownType; } - var getter = ts.getDeclarationOfKind(symbol, 137); - var setter = ts.getDeclarationOfKind(symbol, 138); + var getter = ts.getDeclarationOfKind(symbol, 138); + var setter = ts.getDeclarationOfKind(symbol, 139); var type; var getterReturnType = getAnnotatedAccessorType(getter); if (getterReturnType) { @@ -11285,7 +11566,7 @@ var ts; if (!popTypeResolution()) { type = anyType; if (compilerOptions.noImplicitAny) { - var getter_1 = ts.getDeclarationOfKind(symbol, 137); + var getter_1 = ts.getDeclarationOfKind(symbol, 138); error(getter_1, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); } } @@ -11374,9 +11655,9 @@ var ts; if (!node) { return typeParameters; } - if (node.kind === 202 || node.kind === 201 || - node.kind === 163 || node.kind === 135 || - node.kind === 164) { + if (node.kind === 204 || node.kind === 203 || + node.kind === 165 || node.kind === 136 || + node.kind === 166) { var declarations = node.typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); @@ -11385,14 +11666,14 @@ var ts; } } function getOuterTypeParametersOfClassOrInterface(symbol) { - var kind = symbol.flags & 32 ? 202 : 203; + var kind = symbol.flags & 32 ? 204 : 205; return appendOuterTypeParameters(undefined, ts.getDeclarationOfKind(symbol, kind)); } - function getLocalTypeParametersOfClassOrInterface(symbol) { + function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) { var result; for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { var node = _a[_i]; - if (node.kind === 203 || node.kind === 202) { + if (node.kind === 205 || node.kind === 204 || node.kind === 206) { var declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -11402,56 +11683,109 @@ var ts; return result; } function getTypeParametersOfClassOrInterface(symbol) { - return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterface(symbol)); + return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol)); + } + function isConstructorType(type) { + return type.flags & 48128 && getSignaturesOfType(type, 1).length > 0; + } + function getBaseTypeNodeOfClass(type) { + return ts.getClassExtendsHeritageClauseElement(type.symbol.valueDeclaration); + } + function getConstructorsForTypeArguments(type, typeArgumentNodes) { + var typeArgCount = typeArgumentNodes ? typeArgumentNodes.length : 0; + return ts.filter(getSignaturesOfType(type, 1), function (sig) { return (sig.typeParameters ? sig.typeParameters.length : 0) === typeArgCount; }); + } + function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes) { + var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes); + if (typeArgumentNodes) { + var typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode); + signatures = ts.map(signatures, function (sig) { return getSignatureInstantiation(sig, typeArguments); }); + } + return signatures; + } + function getBaseConstructorTypeOfClass(type) { + if (!type.resolvedBaseConstructorType) { + var baseTypeNode = getBaseTypeNodeOfClass(type); + if (!baseTypeNode) { + return type.resolvedBaseConstructorType = undefinedType; + } + if (!pushTypeResolution(type)) { + return unknownType; + } + var baseConstructorType = checkExpression(baseTypeNode.expression); + if (baseConstructorType.flags & 48128) { + resolveObjectOrUnionTypeMembers(baseConstructorType); + } + if (!popTypeResolution()) { + error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol)); + return type.resolvedBaseConstructorType = unknownType; + } + if (baseConstructorType !== unknownType && baseConstructorType !== nullType && !isConstructorType(baseConstructorType)) { + error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType)); + return type.resolvedBaseConstructorType = unknownType; + } + type.resolvedBaseConstructorType = baseConstructorType; + } + return type.resolvedBaseConstructorType; } function getBaseTypes(type) { - var typeWithBaseTypes = type; - if (!typeWithBaseTypes.baseTypes) { + if (!type.resolvedBaseTypes) { if (type.symbol.flags & 32) { - resolveBaseTypesOfClass(typeWithBaseTypes); + resolveBaseTypesOfClass(type); } else if (type.symbol.flags & 64) { - resolveBaseTypesOfInterface(typeWithBaseTypes); + resolveBaseTypesOfInterface(type); } else { ts.Debug.fail("type must be class or interface"); } } - return typeWithBaseTypes.baseTypes; + return type.resolvedBaseTypes; } function resolveBaseTypesOfClass(type) { - type.baseTypes = []; - var declaration = ts.getDeclarationOfKind(type.symbol, 202); - var baseTypeNode = ts.getClassExtendsHeritageClauseElement(declaration); - if (baseTypeNode) { - var baseType = getTypeFromTypeNode(baseTypeNode); - if (baseType !== unknownType) { - if (getTargetType(baseType).flags & 1024) { - if (type !== baseType && !hasBaseType(baseType, type)) { - type.baseTypes.push(baseType); - } - else { - error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1)); - } - } - else { - error(baseTypeNode, ts.Diagnostics.A_class_may_only_extend_another_class); - } - } + type.resolvedBaseTypes = emptyArray; + var baseContructorType = getBaseConstructorTypeOfClass(type); + if (!(baseContructorType.flags & 48128)) { + return; } + var baseTypeNode = getBaseTypeNodeOfClass(type); + var baseType; + if (baseContructorType.symbol && baseContructorType.symbol.flags & 32) { + baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseContructorType.symbol); + } + else { + var constructors = getInstantiatedConstructorsForTypeArguments(baseContructorType, baseTypeNode.typeArguments); + if (!constructors.length) { + error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments); + return; + } + baseType = getReturnTypeOfSignature(constructors[0]); + } + if (baseType === unknownType) { + return; + } + if (!(getTargetType(baseType).flags & (1024 | 2048))) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructor_return_type_0_is_not_a_class_or_interface_type, typeToString(baseType)); + return; + } + if (type === baseType || hasBaseType(baseType, type)) { + error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1)); + return; + } + type.resolvedBaseTypes = [baseType]; } function resolveBaseTypesOfInterface(type) { - type.baseTypes = []; + type.resolvedBaseTypes = []; for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { var declaration = _a[_i]; - if (declaration.kind === 203 && ts.getInterfaceBaseTypeNodes(declaration)) { + if (declaration.kind === 205 && ts.getInterfaceBaseTypeNodes(declaration)) { for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) { var node = _c[_b]; var baseType = getTypeFromTypeNode(node); if (baseType !== unknownType) { if (getTargetType(baseType).flags & (1024 | 2048)) { if (type !== baseType && !hasBaseType(baseType, type)) { - type.baseTypes.push(baseType); + type.resolvedBaseTypes.push(baseType); } else { error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1)); @@ -11471,7 +11805,7 @@ var ts; var kind = symbol.flags & 32 ? 1024 : 2048; var type = links.declaredType = createObjectType(kind, symbol); var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol); - var localTypeParameters = getLocalTypeParametersOfClassOrInterface(symbol); + var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); if (outerTypeParameters || localTypeParameters) { type.flags |= 4096; type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters); @@ -11491,9 +11825,16 @@ var ts; if (!pushTypeResolution(links)) { return unknownType; } - var declaration = ts.getDeclarationOfKind(symbol, 204); + var declaration = ts.getDeclarationOfKind(symbol, 206); var type = getTypeFromTypeNode(declaration.type); - if (!popTypeResolution()) { + if (popTypeResolution()) { + links.typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (links.typeParameters) { + links.instantiations = {}; + links.instantiations[getTypeListId(links.typeParameters)] = type; + } + } + else { type = unknownType; error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } @@ -11515,7 +11856,7 @@ var ts; if (!links.declaredType) { var type = createType(512); type.symbol = symbol; - if (!ts.getDeclarationOfKind(symbol, 129).constraint) { + if (!ts.getDeclarationOfKind(symbol, 130).constraint) { type.constraint = noConstraintType; } links.declaredType = type; @@ -11630,34 +11971,42 @@ var ts; }); setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } - function createSignature(declaration, typeParameters, parameters, resolvedReturnType, minArgumentCount, hasRestParameter, hasStringLiterals) { + function createSignature(declaration, typeParameters, parameters, resolvedReturnType, typePredicate, minArgumentCount, hasRestParameter, hasStringLiterals) { var sig = new Signature(checker); sig.declaration = declaration; sig.typeParameters = typeParameters; sig.parameters = parameters; sig.resolvedReturnType = resolvedReturnType; + sig.typePredicate = typePredicate; sig.minArgumentCount = minArgumentCount; sig.hasRestParameter = hasRestParameter; sig.hasStringLiterals = hasStringLiterals; return sig; } function cloneSignature(sig) { - return createSignature(sig.declaration, sig.typeParameters, sig.parameters, sig.resolvedReturnType, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); + return createSignature(sig.declaration, sig.typeParameters, sig.parameters, sig.resolvedReturnType, sig.typePredicate, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); } function getDefaultConstructSignatures(classType) { - var baseTypes = getBaseTypes(classType); - if (baseTypes.length) { - var baseType = baseTypes[0]; - var baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), 1); - return ts.map(baseSignatures, function (baseSignature) { - var signature = baseType.flags & 4096 ? - getSignatureInstantiation(baseSignature, baseType.typeArguments) : cloneSignature(baseSignature); - signature.typeParameters = classType.localTypeParameters; - signature.resolvedReturnType = classType; - return signature; - }); + if (!getBaseTypes(classType).length) { + return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)]; } - return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, 0, false, false)]; + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + var baseSignatures = getSignaturesOfType(baseConstructorType, 1); + var baseTypeNode = getBaseTypeNodeOfClass(classType); + var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode); + var typeArgCount = typeArguments ? typeArguments.length : 0; + var result = []; + for (var _i = 0; _i < baseSignatures.length; _i++) { + var baseSig = baseSignatures[_i]; + var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0; + if (typeParamCount === typeArgCount) { + var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig); + sig.typeParameters = classType.localTypeParameters; + sig.resolvedReturnType = classType; + result.push(sig); + } + } + return result; } function createTupleTypeMemberSymbols(memberTypes) { var members = {}; @@ -11756,10 +12105,10 @@ var ts; if (!constructSignatures.length) { constructSignatures = getDefaultConstructSignatures(classType); } - var baseTypes = getBaseTypes(classType); - if (baseTypes.length) { + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + if (baseConstructorType.flags & 48128) { members = createSymbolTable(getNamedMembers(members)); - addInheritedMembers(members, getPropertiesOfObjectType(getTypeOfSymbol(baseTypes[0].symbol))); + addInheritedMembers(members, getPropertiesOfObjectType(baseConstructorType)); } } stringIndexType = undefined; @@ -11965,7 +12314,7 @@ var ts; function getSignatureFromDeclaration(declaration) { var links = getNodeLinks(declaration); if (!links.resolvedSignature) { - var classType = declaration.kind === 136 ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; + var classType = declaration.kind === 137 ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; var typeParameters = classType ? classType.localTypeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; var parameters = []; @@ -11987,22 +12336,31 @@ var ts; minArgumentCount = declaration.parameters.length; } var returnType; + var typePredicate; if (classType) { returnType = classType; } else if (declaration.type) { returnType = getTypeFromTypeNode(declaration.type); + if (declaration.type.kind === 143) { + var typePredicateNode = declaration.type; + typePredicate = { + parameterName: typePredicateNode.parameterName ? typePredicateNode.parameterName.text : undefined, + parameterIndex: typePredicateNode.parameterName ? getTypePredicateParameterIndex(declaration.parameters, typePredicateNode.parameterName) : undefined, + type: getTypeFromTypeNode(typePredicateNode.type) + }; + } } else { - if (declaration.kind === 137 && !ts.hasDynamicName(declaration)) { - var setter = ts.getDeclarationOfKind(declaration.symbol, 138); + if (declaration.kind === 138 && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 139); returnType = getAnnotatedAccessorType(setter); } if (!returnType && ts.nodeIsMissing(declaration.body)) { returnType = anyType; } } - links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals); + links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, typePredicate, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals); } return links.resolvedSignature; } @@ -12013,19 +12371,19 @@ var ts; for (var i = 0, len = symbol.declarations.length; i < len; i++) { var node = symbol.declarations[i]; switch (node.kind) { - case 143: - case 144: - case 201: - case 135: - case 134: + case 145: + case 146: + case 203: case 136: - case 139: + case 135: + case 137: case 140: case 141: - case 137: + case 142: case 138: - case 163: - case 164: + case 139: + case 165: + case 166: if (i > 0 && node.body) { var previous = symbol.declarations[i - 1]; if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) { @@ -12095,7 +12453,7 @@ var ts; } function getOrCreateTypeFromSignature(signature) { if (!signature.isolatedSignatureType) { - var isConstructor = signature.declaration.kind === 136 || signature.declaration.kind === 140; + var isConstructor = signature.declaration.kind === 137 || signature.declaration.kind === 141; var type = createObjectType(32768 | 131072); type.members = emptySymbols; type.properties = emptyArray; @@ -12109,7 +12467,7 @@ var ts; return symbol.members["__index"]; } function getIndexDeclarationOfSymbol(symbol, kind) { - var syntaxKind = kind === 1 ? 120 : 122; + var syntaxKind = kind === 1 ? 121 : 123; var indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { var len = indexSymbol.declarations.length; @@ -12139,13 +12497,13 @@ var ts; type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; } else { - type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 129).constraint); + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 130).constraint); } } return type.constraint === noConstraintType ? undefined : type.constraint; } function getParentSymbolOfTypeParameter(typeParameter) { - return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 129).parent); + return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 130).parent); } function getTypeListId(types) { switch (types.length) { @@ -12192,18 +12550,18 @@ var ts; while (!ts.forEach(typeParameterSymbol.declarations, function (d) { return d.parent === currentNode.parent; })) { currentNode = currentNode.parent; } - links.isIllegalTypeReferenceInConstraint = currentNode.kind === 129; + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 130; return links.isIllegalTypeReferenceInConstraint; } function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { var typeParameterSymbol; function check(n) { - if (n.kind === 142 && n.typeName.kind === 65) { + if (n.kind === 144 && n.typeName.kind === 65) { var links = getNodeLinks(n); if (links.isIllegalTypeReferenceInConstraint === undefined) { var symbol = resolveName(typeParameter, n.typeName.text, 793056, undefined, undefined); if (symbol && (symbol.flags & 262144)) { - links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent == typeParameter.parent; }); + links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent === typeParameter.parent; }); } } if (links.isIllegalTypeReferenceInConstraint) { @@ -12217,55 +12575,71 @@ var ts; check(typeParameter.constraint); } } - function getTypeFromTypeReferenceOrExpressionWithTypeArguments(node) { - var links = getNodeLinks(node); - if (!links.resolvedType) { - var type; - if (node.kind !== 177 || ts.isSupportedExpressionWithTypeArguments(node)) { - var typeNameOrExpression = node.kind === 142 - ? node.typeName - : node.expression; - var symbol = resolveEntityName(typeNameOrExpression, 793056); - if (symbol) { - if ((symbol.flags & 262144) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { - type = unknownType; - } - else { - type = createTypeReferenceIfGeneric(getDeclaredTypeOfSymbol(symbol), node, node.typeArguments); - } - } + function getTypeFromClassOrInterfaceReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var typeParameters = type.localTypeParameters; + if (typeParameters) { + if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1), typeParameters.length); + return unknownType; } - links.resolvedType = type || unknownType; + return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(node.typeArguments, getTypeFromTypeNode))); } - return links.resolvedType; - } - function createTypeReferenceIfGeneric(type, node, typeArguments) { - if (type.flags & (1024 | 2048) && type.flags & 4096) { - var localTypeParameters = type.localTypeParameters; - var expectedTypeArgCount = localTypeParameters ? localTypeParameters.length : 0; - var typeArgCount = typeArguments ? typeArguments.length : 0; - if (typeArgCount === expectedTypeArgCount) { - if (typeArgCount) { - return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(typeArguments, getTypeFromTypeNode))); - } - } - else { - error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1), expectedTypeArgCount); - return undefined; - } - } - else { - if (typeArguments) { - error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); - return undefined; - } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); + return unknownType; } return type; } + function getTypeFromTypeAliasReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var links = getSymbolLinks(symbol); + var typeParameters = links.typeParameters; + if (typeParameters) { + if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, symbolToString(symbol), typeParameters.length); + return unknownType; + } + var typeArguments = ts.map(node.typeArguments, getTypeFromTypeNode); + var id = getTypeListId(typeArguments); + return links.instantiations[id] || (links.instantiations[id] = instantiateType(type, createTypeMapper(typeParameters, typeArguments))); + } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol)); + return unknownType; + } + return type; + } + function getTypeFromNonGenericTypeReference(node, symbol) { + if (symbol.flags & 262144 && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { + return unknownType; + } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol)); + return unknownType; + } + return getDeclaredTypeOfSymbol(symbol); + } + function getTypeFromTypeReference(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var typeNameOrExpression = node.kind === 144 ? node.typeName : + ts.isSupportedExpressionWithTypeArguments(node) ? node.expression : + undefined; + var symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, 793056) || unknownSymbol; + var type = symbol === unknownSymbol ? unknownType : + symbol.flags & (32 | 64) ? getTypeFromClassOrInterfaceReference(node, symbol) : + symbol.flags & 524288 ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); + links.resolvedSymbol = symbol; + links.resolvedType = type; + } + return links.resolvedType; + } function getTypeFromTypeQueryNode(node) { var links = getNodeLinks(node); if (!links.resolvedType) { - links.resolvedType = getWidenedType(checkExpressionOrQualifiedName(node.exprName)); + links.resolvedType = getWidenedType(checkExpression(node.exprName)); } return links.resolvedType; } @@ -12275,9 +12649,9 @@ var ts; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; switch (declaration.kind) { - case 202: - case 203: + case 204: case 205: + case 207: return declaration; } } @@ -12478,38 +12852,40 @@ var ts; switch (node.kind) { case 112: return anyType; - case 122: + case 123: return stringType; - case 120: + case 121: return numberType; case 113: return booleanType; - case 123: + case 124: return esSymbolType; case 99: return voidType; case 8: return getTypeFromStringLiteral(node); - case 142: - return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 177: - return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 145: - return getTypeFromTypeQueryNode(node); - case 147: - return getTypeFromArrayTypeNode(node); - case 148: - return getTypeFromTupleTypeNode(node); - case 149: - return getTypeFromUnionTypeNode(node); - case 150: - return getTypeFromTypeNode(node.type); - case 143: case 144: + return getTypeFromTypeReference(node); + case 143: + return booleanType; + case 179: + return getTypeFromTypeReference(node); + case 147: + return getTypeFromTypeQueryNode(node); + case 149: + return getTypeFromArrayTypeNode(node); + case 150: + return getTypeFromTupleTypeNode(node); + case 151: + return getTypeFromUnionTypeNode(node); + case 152: + return getTypeFromTypeNode(node.type); + case 145: case 146: + case 148: return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); case 65: - case 127: + case 128: var symbol = getSymbolInfo(node); return symbol && getDeclaredTypeOfSymbol(symbol); default: @@ -12599,11 +12975,19 @@ var ts; } function instantiateSignature(signature, mapper, eraseTypeParameters) { var freshTypeParameters; + var freshTypePredicate; if (signature.typeParameters && !eraseTypeParameters) { freshTypeParameters = instantiateList(signature.typeParameters, mapper, instantiateTypeParameter); mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper); } - var result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); + if (signature.typePredicate) { + freshTypePredicate = { + parameterName: signature.typePredicate.parameterName, + parameterIndex: signature.typePredicate.parameterIndex, + type: instantiateType(signature.typePredicate.type, mapper) + }; + } + var result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, freshTypePredicate, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); result.target = signature; result.mapper = mapper; return result; @@ -12660,27 +13044,27 @@ var ts; return type; } function isContextSensitive(node) { - ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 || ts.isObjectLiteralMethod(node)); switch (node.kind) { - case 163: - case 164: + case 165: + case 166: return isContextSensitiveFunctionLikeDeclaration(node); - case 155: + case 157: return ts.forEach(node.properties, isContextSensitive); - case 154: + case 156: return ts.forEach(node.elements, isContextSensitive); - case 171: + case 173: return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse); - case 170: + case 172: return node.operatorToken.kind === 49 && (isContextSensitive(node.left) || isContextSensitive(node.right)); - case 225: + case 227: return isContextSensitive(node.initializer); + case 136: case 135: - case 134: return isContextSensitiveFunctionLikeDeclaration(node); - case 162: + case 164: return isContextSensitive(node.expression); } return false; @@ -12688,23 +13072,20 @@ var ts; function isContextSensitiveFunctionLikeDeclaration(node) { return !node.typeParameters && node.parameters.length && !ts.forEach(node.parameters, function (p) { return p.type; }); } - function getTypeWithoutConstructors(type) { + function getTypeWithoutSignatures(type) { if (type.flags & 48128) { var resolved = resolveObjectOrUnionTypeMembers(type); if (resolved.constructSignatures.length) { var result = createObjectType(32768, type.symbol); result.members = resolved.members; result.properties = resolved.properties; - result.callSignatures = resolved.callSignatures; + result.callSignatures = emptyArray; result.constructSignatures = emptyArray; type = result; } } return type; } - var subtypeRelation = {}; - var assignableRelation = {}; - var identityRelation = {}; function isTypeIdenticalTo(source, target) { return checkTypeRelatedTo(source, target, identityRelation, undefined); } @@ -12955,9 +13336,9 @@ var ts; maybeStack[depth][id] = 1; depth++; var saveExpandingFlags = expandingFlags; - if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack)) + if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack, depth)) expandingFlags |= 1; - if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack)) + if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack, depth)) expandingFlags |= 2; var result; if (expandingFlags === 3) { @@ -12990,21 +13371,6 @@ var ts; } return result; } - function isDeeplyNestedGeneric(type, stack) { - if (type.flags & (4096 | 65536) && depth >= 10) { - var symbol = type.symbol; - var count = 0; - for (var i = 0; i < depth; i++) { - var t = stack[i]; - if (t.flags & (4096 | 65536) && t.symbol === symbol) { - count++; - if (count >= 10) - return true; - } - } - } - return false; - } function propertiesRelatedTo(source, target, reportErrors) { if (relation === identityRelation) { return propertiesIdenticalTo(source, target); @@ -13175,6 +13541,33 @@ var ts; } result &= related; } + if (source.typePredicate && target.typePredicate) { + var hasDifferentParameterIndex = source.typePredicate.parameterIndex !== target.typePredicate.parameterIndex; + var hasDifferentTypes; + if (hasDifferentParameterIndex || + (hasDifferentTypes = !isTypeIdenticalTo(source.typePredicate.type, target.typePredicate.type))) { + if (reportErrors) { + var sourceParamText = source.typePredicate.parameterName; + var targetParamText = target.typePredicate.parameterName; + var sourceTypeText = typeToString(source.typePredicate.type); + var targetTypeText = typeToString(target.typePredicate.type); + if (hasDifferentParameterIndex) { + reportError(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, sourceParamText, targetParamText); + } + else if (hasDifferentTypes) { + reportError(ts.Diagnostics.Type_0_is_not_assignable_to_type_1, sourceTypeText, targetTypeText); + } + reportError(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, sourceParamText + " is " + sourceTypeText, targetParamText + " is " + targetTypeText); + } + return 0; + } + } + else if (!source.typePredicate && target.typePredicate) { + if (reportErrors) { + reportError(ts.Diagnostics.Signature_0_must_have_a_type_predicate, signatureToString(source)); + } + return 0; + } var t = getReturnTypeOfSignature(target); if (t === voidType) return result; @@ -13264,6 +13657,21 @@ var ts; return 0; } } + function isDeeplyNestedGeneric(type, stack, depth) { + if (type.flags & (4096 | 65536) && depth >= 5) { + var symbol = type.symbol; + var count = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (t.flags & (4096 | 65536) && t.symbol === symbol) { + count++; + if (count >= 5) + return true; + } + } + } + return false; + } function isPropertyIdenticalTo(sourceProp, targetProp) { return compareProperties(sourceProp, targetProp, compareTypes) !== 0; } @@ -13454,22 +13862,22 @@ var ts; var typeAsString = typeToString(getWidenedType(type)); var diagnostic; switch (declaration.kind) { + case 134: case 133: - case 132: diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; break; - case 130: + case 131: diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; break; - case 201: + case 203: + case 136: case 135: - case 134: - case 137: case 138: - case 163: - case 164: + case 139: + case 165: + case 166: if (!declaration.name) { error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); return; @@ -13541,20 +13949,6 @@ var ts; } return false; } - function isWithinDepthLimit(type, stack) { - if (depth >= 5) { - var target_1 = type.target; - var count = 0; - for (var i = 0; i < depth; i++) { - var t = stack[i]; - if (t.flags & 4096 && t.target === target_1) { - count++; - } - } - return count < 5; - } - return true; - } function inferFromTypes(source, target) { if (source === anyFunctionType) { return; @@ -13612,22 +14006,26 @@ var ts; } else if (source.flags & 48128 && (target.flags & (4096 | 8192) || (target.flags & 32768) && target.symbol && target.symbol.flags & (8192 | 2048))) { - if (!isInProcess(source, target) && isWithinDepthLimit(source, sourceStack) && isWithinDepthLimit(target, targetStack)) { - if (depth === 0) { - sourceStack = []; - targetStack = []; - } - sourceStack[depth] = source; - targetStack[depth] = target; - depth++; - inferFromProperties(source, target); - inferFromSignatures(source, target, 0); - inferFromSignatures(source, target, 1); - inferFromIndexTypes(source, target, 0, 0); - inferFromIndexTypes(source, target, 1, 1); - inferFromIndexTypes(source, target, 0, 1); - depth--; + if (isInProcess(source, target)) { + return; } + if (isDeeplyNestedGeneric(source, sourceStack, depth) && isDeeplyNestedGeneric(target, targetStack, depth)) { + return; + } + if (depth === 0) { + sourceStack = []; + targetStack = []; + } + sourceStack[depth] = source; + targetStack[depth] = target; + depth++; + inferFromProperties(source, target); + inferFromSignatures(source, target, 0); + inferFromSignatures(source, target, 1); + inferFromIndexTypes(source, target, 0, 0); + inferFromIndexTypes(source, target, 1, 1); + inferFromIndexTypes(source, target, 0, 1); + depth--; } } function inferFromProperties(source, target) { @@ -13652,7 +14050,14 @@ var ts; } function inferFromSignature(source, target) { forEachMatchingParameterType(source, target, inferFromTypes); - inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + if (source.typePredicate && target.typePredicate) { + if (target.typePredicate.parameterIndex === source.typePredicate.parameterIndex) { + inferFromTypes(source.typePredicate.type, target.typePredicate.type); + } + } + else { + inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } } function inferFromIndexTypes(source, target, sourceKind, targetKind) { var targetIndexType = getIndexTypeOfType(target, targetKind); @@ -13712,10 +14117,10 @@ var ts; function isInTypeQuery(node) { while (node) { switch (node.kind) { - case 145: + case 147: return true; case 65: - case 127: + case 128: node = node.parent; continue; default: @@ -13757,7 +14162,7 @@ var ts; function isAssignedInBinaryExpression(node) { if (node.operatorToken.kind >= 53 && node.operatorToken.kind <= 64) { var n = node.left; - while (n.kind === 162) { + while (n.kind === 164) { n = n.expression; } if (n.kind === 65 && getResolvedSymbol(n) === symbol) { @@ -13774,46 +14179,46 @@ var ts; } function isAssignedIn(node) { switch (node.kind) { - case 170: + case 172: return isAssignedInBinaryExpression(node); - case 199: - case 153: - return isAssignedInVariableDeclaration(node); - case 151: - case 152: - case 154: + case 201: case 155: + return isAssignedInVariableDeclaration(node); + case 153: + case 154: case 156: case 157: case 158: case 159: + case 160: case 161: - case 162: - case 168: - case 165: - case 166: + case 163: + case 164: + case 170: case 167: + case 168: case 169: case 171: - case 174: - case 180: - case 181: + case 173: + case 176: + case 182: case 183: - case 184: case 185: case 186: case 187: case 188: case 189: - case 192: - case 193: + case 190: + case 191: case 194: - case 221: - case 222: case 195: case 196: - case 197: + case 223: case 224: + case 197: + case 198: + case 199: + case 226: return ts.forEachChild(node, isAssignedIn); } return false; @@ -13850,17 +14255,17 @@ var ts; node = node.parent; var narrowedType = type; switch (node.kind) { - case 184: + case 186: if (child !== node.expression) { narrowedType = narrowType(type, node.expression, child === node.thenStatement); } break; - case 171: + case 173: if (child !== node.condition) { narrowedType = narrowType(type, node.condition, child === node.whenTrue); } break; - case 170: + case 172: if (child === node.right) { if (node.operatorToken.kind === 48) { narrowedType = narrowType(type, node.left, true); @@ -13870,14 +14275,14 @@ var ts; } } break; - case 228: - case 206: - case 201: - case 135: - case 134: - case 137: - case 138: + case 230: + case 208: + case 203: case 136: + case 135: + case 138: + case 139: + case 137: break loop; } if (narrowedType !== type) { @@ -13891,7 +14296,7 @@ var ts; } return type; function narrowTypeByEquality(type, expr, assumeTrue) { - if (expr.left.kind !== 166 || expr.right.kind !== 8) { + if (expr.left.kind !== 168 || expr.right.kind !== 8) { return type; } var left = expr.left; @@ -13970,20 +14375,44 @@ var ts; } } if (targetType) { - if (isTypeSubtypeOf(targetType, type)) { - return targetType; - } - if (type.flags & 16384) { - return getUnionType(ts.filter(type.types, function (t) { return isTypeSubtypeOf(t, targetType); })); + return getNarrowedType(type, targetType); + } + return type; + } + function getNarrowedType(originalType, narrowedTypeCandidate) { + if (isTypeSubtypeOf(narrowedTypeCandidate, originalType)) { + return narrowedTypeCandidate; + } + if (originalType.flags & 16384) { + return getUnionType(ts.filter(originalType.types, function (t) { return isTypeSubtypeOf(t, narrowedTypeCandidate); })); + } + return originalType; + } + function narrowTypeByTypePredicate(type, expr, assumeTrue) { + if (type.flags & 1) { + return type; + } + var signature = getResolvedSignature(expr); + if (signature.typePredicate && + expr.arguments[signature.typePredicate.parameterIndex] && + getSymbolAtLocation(expr.arguments[signature.typePredicate.parameterIndex]) === symbol) { + if (!assumeTrue) { + if (type.flags & 16384) { + return getUnionType(ts.filter(type.types, function (t) { return !isTypeSubtypeOf(t, signature.typePredicate.type); })); + } + return type; } + return getNarrowedType(type, signature.typePredicate.type); } return type; } function narrowType(type, expr, assumeTrue) { switch (expr.kind) { - case 162: + case 160: + return narrowTypeByTypePredicate(type, expr, assumeTrue); + case 164: return narrowType(type, expr.expression, assumeTrue); - case 170: + case 172: var operator = expr.operatorToken.kind; if (operator === 30 || operator === 31) { return narrowTypeByEquality(type, expr, assumeTrue); @@ -13998,7 +14427,7 @@ var ts; return narrowTypeByInstanceof(type, expr, assumeTrue); } break; - case 168: + case 170: if (expr.operator === 46) { return narrowType(type, expr.operand, !assumeTrue); } @@ -14009,7 +14438,7 @@ var ts; } function checkIdentifier(node) { var symbol = getResolvedSymbol(node); - if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 164 && languageVersion < 2) { + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 166 && languageVersion < 2) { error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); } if (symbol.flags & 8388608 && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { @@ -14033,15 +14462,15 @@ var ts; function checkBlockScopedBindingCapturedInLoop(node, symbol) { if (languageVersion >= 2 || (symbol.flags & 2) === 0 || - symbol.valueDeclaration.parent.kind === 224) { + symbol.valueDeclaration.parent.kind === 226) { return; } var container = symbol.valueDeclaration; - while (container.kind !== 200) { + while (container.kind !== 202) { container = container.parent; } container = container.parent; - if (container.kind === 181) { + if (container.kind === 183) { container = container.parent; } var inFunction = isInsideFunction(node.parent, container); @@ -14058,9 +14487,9 @@ var ts; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 202 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 204 ? container.parent : undefined; getNodeLinks(node).flags |= 2; - if (container.kind === 133 || container.kind === 136) { + if (container.kind === 134 || container.kind === 137) { getNodeLinks(classNode).flags |= 4; } else { @@ -14070,36 +14499,36 @@ var ts; function checkThisExpression(node) { var container = ts.getThisContainer(node, true); var needToCaptureLexicalThis = false; - if (container.kind === 164) { + if (container.kind === 166) { container = ts.getThisContainer(container, false); needToCaptureLexicalThis = (languageVersion < 2); } switch (container.kind) { - case 206: + case 208: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body); break; - case 205: + case 207: error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); break; - case 136: + case 137: if (isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); } break; + case 134: case 133: - case 132: if (container.flags & 128) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); } break; - case 128: + case 129: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name); break; } if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 202 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 204 ? container.parent : undefined; if (classNode) { var symbol = getSymbolOfNode(classNode); return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); @@ -14108,23 +14537,21 @@ var ts; } function isInConstructorArgumentInitializer(node, constructorDecl) { for (var n = node; n && n !== constructorDecl; n = n.parent) { - if (n.kind === 130) { + if (n.kind === 131) { return true; } } return false; } function checkSuperExpression(node) { - var isCallExpression = node.parent.kind === 158 && node.parent.expression === node; - var enclosingClass = ts.getAncestor(node, 202); - var baseClass; - if (enclosingClass && ts.getClassExtendsHeritageClauseElement(enclosingClass)) { - var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); - var baseTypes = getBaseTypes(classType); - baseClass = baseTypes.length && baseTypes[0]; - } - if (!baseClass) { - error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + var isCallExpression = node.parent.kind === 160 && node.parent.expression === node; + var classDeclaration = ts.getAncestor(node, 204); + var classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); + var baseClassType = classType && getBaseTypes(classType)[0]; + if (!baseClassType) { + if (!classDeclaration || !ts.getClassExtendsHeritageClauseElement(classDeclaration)) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + } return unknownType; } var container = ts.getSuperContainer(node, true); @@ -14132,31 +14559,31 @@ var ts; var canUseSuperExpression = false; var needToCaptureLexicalThis; if (isCallExpression) { - canUseSuperExpression = container.kind === 136; + canUseSuperExpression = container.kind === 137; } else { needToCaptureLexicalThis = false; - while (container && container.kind === 164) { + while (container && container.kind === 166) { container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = languageVersion < 2; } - if (container && container.parent && container.parent.kind === 202) { + if (container && container.parent && container.parent.kind === 204) { if (container.flags & 128) { canUseSuperExpression = - container.kind === 135 || - container.kind === 134 || - container.kind === 137 || - container.kind === 138; + container.kind === 136 || + container.kind === 135 || + container.kind === 138 || + container.kind === 139; } else { canUseSuperExpression = - container.kind === 135 || - container.kind === 134 || - container.kind === 137 || + container.kind === 136 || + container.kind === 135 || container.kind === 138 || + container.kind === 139 || + container.kind === 134 || container.kind === 133 || - container.kind === 132 || - container.kind === 136; + container.kind === 137; } } } @@ -14164,13 +14591,13 @@ var ts; var returnType; if ((container.flags & 128) || isCallExpression) { getNodeLinks(node).flags |= 32; - returnType = getTypeOfSymbol(baseClass.symbol); + returnType = getBaseConstructorTypeOfClass(classType); } else { getNodeLinks(node).flags |= 16; - returnType = baseClass; + returnType = baseClassType; } - if (container.kind === 136 && isInConstructorArgumentInitializer(node, container)) { + if (container.kind === 137 && isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); returnType = unknownType; } @@ -14180,7 +14607,7 @@ var ts; return returnType; } } - if (container && container.kind === 128) { + if (container && container.kind === 129) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); } else if (isCallExpression) { @@ -14218,7 +14645,7 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130) { + if (declaration.kind === 131) { var type = getContextuallyTypedParameterType(declaration); if (type) { return type; @@ -14251,8 +14678,8 @@ var ts; } function getContextualReturnType(functionDecl) { if (functionDecl.type || - functionDecl.kind === 136 || - functionDecl.kind === 137 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 138))) { + functionDecl.kind === 137 || + functionDecl.kind === 138 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 139))) { return getReturnTypeOfSignature(getSignatureFromDeclaration(functionDecl)); } var signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl); @@ -14271,7 +14698,7 @@ var ts; return undefined; } function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { - if (template.parent.kind === 160) { + if (template.parent.kind === 162) { return getContextualTypeForArgument(template.parent, substitutionExpression); } return undefined; @@ -14379,34 +14806,34 @@ var ts; } var parent = node.parent; switch (parent.kind) { - case 199: - case 130: + case 201: + case 131: + case 134: case 133: - case 132: - case 153: + case 155: return getContextualTypeForInitializerExpression(node); - case 164: - case 192: + case 166: + case 194: return getContextualTypeForReturnExpression(node); - case 173: + case 175: return getContextualTypeForYieldOperand(parent); - case 158: - case 159: - return getContextualTypeForArgument(parent, node); + case 160: case 161: + return getContextualTypeForArgument(parent, node); + case 163: return getTypeFromTypeNode(parent.type); - case 170: + case 172: return getContextualTypeForBinaryOperand(node); - case 225: + case 227: return getContextualTypeForObjectLiteralElement(parent); - case 154: + case 156: return getContextualTypeForElementExpression(node); - case 171: + case 173: return getContextualTypeForConditionalOperand(node); - case 178: - ts.Debug.assert(parent.parent.kind === 172); + case 180: + ts.Debug.assert(parent.parent.kind === 174); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case 162: + case 164: return getContextualType(parent); } return undefined; @@ -14421,7 +14848,7 @@ var ts; } } function isFunctionExpressionOrArrowFunction(node) { - return node.kind === 163 || node.kind === 164; + return node.kind === 165 || node.kind === 166; } function getContextualSignatureForFunctionLikeDeclaration(node) { return isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node) @@ -14429,7 +14856,7 @@ var ts; : undefined; } function getContextualSignature(node) { - ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 || ts.isObjectLiteralMethod(node)); var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); @@ -14473,13 +14900,13 @@ var ts; } function isAssignmentTarget(node) { var parent = node.parent; - if (parent.kind === 170 && parent.operatorToken.kind === 53 && parent.left === node) { + if (parent.kind === 172 && parent.operatorToken.kind === 53 && parent.left === node) { return true; } - if (parent.kind === 225) { + if (parent.kind === 227) { return isAssignmentTarget(parent.parent); } - if (parent.kind === 154) { + if (parent.kind === 156) { return isAssignmentTarget(parent); } return false; @@ -14498,7 +14925,7 @@ var ts; var inDestructuringPattern = isAssignmentTarget(node); for (var _i = 0; _i < elements.length; _i++) { var e = elements[_i]; - if (inDestructuringPattern && e.kind === 174) { + if (inDestructuringPattern && e.kind === 176) { var restArrayType = checkExpression(e.expression, contextualMapper); var restElementType = getIndexTypeOfType(restArrayType, 1) || (languageVersion >= 2 ? getElementTypeOfIterable(restArrayType, undefined) : undefined); @@ -14510,7 +14937,7 @@ var ts; var type = checkExpression(e, contextualMapper); elementTypes.push(type); } - hasSpreadElement = hasSpreadElement || e.kind === 174; + hasSpreadElement = hasSpreadElement || e.kind === 176; } if (!hasSpreadElement) { var contextualType = getContextualType(node); @@ -14521,7 +14948,7 @@ var ts; return createArrayType(getUnionType(elementTypes)); } function isNumericName(name) { - return name.kind === 128 ? isNumericComputedName(name) : isNumericLiteralName(name.text); + return name.kind === 129 ? isNumericComputedName(name) : isNumericLiteralName(name.text); } function isNumericComputedName(name) { return isTypeAnyOrAllConstituentTypesHaveKind(checkComputedPropertyName(name), 132); @@ -14554,18 +14981,18 @@ var ts; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var memberDecl = _a[_i]; var member = memberDecl.symbol; - if (memberDecl.kind === 225 || - memberDecl.kind === 226 || + if (memberDecl.kind === 227 || + memberDecl.kind === 228 || ts.isObjectLiteralMethod(memberDecl)) { var type = void 0; - if (memberDecl.kind === 225) { + if (memberDecl.kind === 227) { type = checkPropertyAssignment(memberDecl, contextualMapper); } - else if (memberDecl.kind === 135) { + else if (memberDecl.kind === 136) { type = checkObjectLiteralMethod(memberDecl, contextualMapper); } else { - ts.Debug.assert(memberDecl.kind === 226); + ts.Debug.assert(memberDecl.kind === 228); type = checkExpression(memberDecl.name, contextualMapper); } typeFlags |= type.flags; @@ -14580,7 +15007,7 @@ var ts; member = prop; } else { - ts.Debug.assert(memberDecl.kind === 137 || memberDecl.kind === 138); + ts.Debug.assert(memberDecl.kind === 138 || memberDecl.kind === 139); checkAccessorDeclaration(memberDecl); } if (!ts.hasDynamicName(memberDecl)) { @@ -14613,7 +15040,7 @@ var ts; } } function getDeclarationKindFromSymbol(s) { - return s.valueDeclaration ? s.valueDeclaration.kind : 133; + return s.valueDeclaration ? s.valueDeclaration.kind : 134; } function getDeclarationFlagsFromSymbol(s) { return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0; @@ -14623,7 +15050,7 @@ var ts; if (!(flags & (32 | 64))) { return; } - var enclosingClassDeclaration = ts.getAncestor(node, 202); + var enclosingClassDeclaration = ts.getAncestor(node, 204); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); if (flags & 32) { @@ -14653,7 +15080,7 @@ var ts; return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right); } function checkPropertyAccessExpressionOrQualifiedName(node, left, right) { - var type = checkExpressionOrQualifiedName(left); + var type = checkExpression(left); if (isTypeAny(type)) { return type; } @@ -14670,7 +15097,7 @@ var ts; } getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & 32) { - if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 135) { + if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 136) { error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { @@ -14680,14 +15107,14 @@ var ts; return getTypeOfSymbol(prop); } function isValidPropertyAccess(node, propertyName) { - var left = node.kind === 156 + var left = node.kind === 158 ? node.expression : node.left; - var type = checkExpressionOrQualifiedName(left); + var type = checkExpression(left); if (type !== unknownType && !isTypeAny(type)) { var prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & 32) { - if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 135) { + if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 136) { return false; } else { @@ -14702,7 +15129,7 @@ var ts; function checkIndexedAccess(node) { if (!node.argumentExpression) { var sourceFile = getSourceFile(node); - if (node.parent.kind === 159 && node.parent.expression === node) { + if (node.parent.kind === 161 && node.parent.expression === node) { var start = ts.skipTrivia(sourceFile.text, node.expression.end); var end = node.end; grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead); @@ -14798,7 +15225,7 @@ var ts; return true; } function resolveUntypedCall(node) { - if (node.kind === 160) { + if (node.kind === 162) { checkExpression(node.template); } else { @@ -14851,7 +15278,7 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 174) { + if (args[i].kind === 176) { return i; } } @@ -14861,11 +15288,11 @@ var ts; var adjustedArgCount; var typeArguments; var callIsIncomplete; - if (node.kind === 160) { + if (node.kind === 162) { var tagExpression = node; adjustedArgCount = args.length; typeArguments = undefined; - if (tagExpression.template.kind === 172) { + if (tagExpression.template.kind === 174) { var templateExpression = tagExpression.template; var lastSpan = ts.lastOrUndefined(templateExpression.templateSpans); ts.Debug.assert(lastSpan !== undefined); @@ -14880,7 +15307,7 @@ var ts; else { var callExpression = node; if (!callExpression.arguments) { - ts.Debug.assert(callExpression.kind === 159); + ts.Debug.assert(callExpression.kind === 161); return signature.minArgumentCount === 0; } adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; @@ -14932,10 +15359,10 @@ var ts; } for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176) { + if (arg.kind !== 178) { var paramType = getTypeAtPosition(signature, i); var argType = void 0; - if (i === 0 && args[i].parent.kind === 160) { + if (i === 0 && args[i].parent.kind === 162) { argType = globalTemplateStringsArrayType; } else { @@ -14975,9 +15402,9 @@ var ts; function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176) { + if (arg.kind !== 178) { var paramType = getTypeAtPosition(signature, i); - var argType = i === 0 && node.kind === 160 + var argType = i === 0 && node.kind === 162 ? globalTemplateStringsArrayType : arg.kind === 8 && !reportErrors ? getStringLiteralType(arg) @@ -14991,10 +15418,10 @@ var ts; } function getEffectiveCallArguments(node) { var args; - if (node.kind === 160) { + if (node.kind === 162) { var template = node.template; args = [template]; - if (template.kind === 172) { + if (template.kind === 174) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); @@ -15005,21 +15432,11 @@ var ts; } return args; } - function getEffectiveTypeArguments(callExpression) { - if (callExpression.expression.kind === 91) { - var containingClass = ts.getAncestor(callExpression, 202); - var baseClassTypeNode = containingClass && ts.getClassExtendsHeritageClauseElement(containingClass); - return baseClassTypeNode && baseClassTypeNode.typeArguments; - } - else { - return callExpression.typeArguments; - } - } function resolveCall(node, signatures, candidatesOutArray) { - var isTaggedTemplate = node.kind === 160; + var isTaggedTemplate = node.kind === 162; var typeArguments; if (!isTaggedTemplate) { - typeArguments = getEffectiveTypeArguments(node); + typeArguments = node.typeArguments; if (node.expression.kind !== 91) { ts.forEach(typeArguments, checkSourceElement); } @@ -15060,8 +15477,8 @@ var ts; checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && node.typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true); + if (!isTaggedTemplate && typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], true); } else { ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); @@ -15145,7 +15562,9 @@ var ts; if (node.expression.kind === 91) { var superType = checkSuperExpression(node.expression); if (superType !== unknownType) { - return resolveCall(node, getSignaturesOfType(superType, 1), candidatesOutArray); + var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getAncestor(node, 204)); + var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); + return resolveCall(node, baseConstructors, candidatesOutArray); } return resolveUntypedCall(node); } @@ -15226,13 +15645,13 @@ var ts; var links = getNodeLinks(node); if (!links.resolvedSignature || candidatesOutArray) { links.resolvedSignature = anySignature; - if (node.kind === 158) { + if (node.kind === 160) { links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); } - else if (node.kind === 159) { + else if (node.kind === 161) { links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); } - else if (node.kind === 160) { + else if (node.kind === 162) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } else { @@ -15247,12 +15666,12 @@ var ts; if (node.expression.kind === 91) { return voidType; } - if (node.kind === 159) { + if (node.kind === 161) { var declaration = signature.declaration; if (declaration && - declaration.kind !== 136 && - declaration.kind !== 140 && - declaration.kind !== 144) { + declaration.kind !== 137 && + declaration.kind !== 141 && + declaration.kind !== 146) { if (compilerOptions.noImplicitAny) { error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); } @@ -15299,7 +15718,7 @@ var ts; return unknownType; } var type; - if (func.body.kind !== 180) { + if (func.body.kind !== 182) { type = checkExpressionCached(func.body, contextualMapper); } else { @@ -15376,7 +15795,7 @@ var ts; }); } function bodyContainsSingleThrowStatement(body) { - return (body.statements.length === 1) && (body.statements[0].kind === 196); + return (body.statements.length === 1) && (body.statements[0].kind === 198); } function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) { if (!produceDiagnostics) { @@ -15385,7 +15804,7 @@ var ts; if (returnType === voidType || isTypeAny(returnType)) { return; } - if (ts.nodeIsMissing(func.body) || func.body.kind !== 180) { + if (ts.nodeIsMissing(func.body) || func.body.kind !== 182) { return; } var bodyBlock = func.body; @@ -15398,10 +15817,10 @@ var ts; error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement); } function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) { - ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); - var hasGrammarError = checkGrammarDeclarationNameInStrictMode(node) || checkGrammarFunctionLikeDeclaration(node); - if (!hasGrammarError && node.kind === 163) { - checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); + ts.Debug.assert(node.kind !== 136 || ts.isObjectLiteralMethod(node)); + var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); + if (!hasGrammarError && node.kind === 165) { + checkGrammarForGenerator(node); } if (contextualMapper === identityMapper && isContextSensitive(node)) { return anyFunctionType; @@ -15427,14 +15846,14 @@ var ts; checkSignatureDeclaration(node); } } - if (produceDiagnostics && node.kind !== 135 && node.kind !== 134) { + if (produceDiagnostics && node.kind !== 136 && node.kind !== 135) { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); } return type; } function checkFunctionExpressionOrObjectLiteralMethodBody(node) { - ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 || ts.isObjectLiteralMethod(node)); if (node.type && !node.asteriskToken) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } @@ -15442,7 +15861,7 @@ var ts; if (!node.type) { getReturnTypeOfSignature(getSignatureFromDeclaration(node)); } - if (node.body.kind === 180) { + if (node.body.kind === 182) { checkSourceElement(node.body); } else { @@ -15472,13 +15891,13 @@ var ts; var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3) !== 0; } - case 156: { + case 158: { var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || (symbol.flags & ~8) !== 0; } - case 157: + case 159: return true; - case 162: + case 164: return isReferenceOrErrorExpression(n.expression); default: return false; @@ -15487,11 +15906,11 @@ var ts; function isConstVariableReference(n) { switch (n.kind) { case 65: - case 156: { + case 158: { var symbol = findSymbol(n); return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 8192) !== 0; } - case 157: { + case 159: { var index = n.argumentExpression; var symbol = findSymbol(n.expression); if (symbol && index && index.kind === 8) { @@ -15501,7 +15920,7 @@ var ts; } return false; } - case 162: + case 164: return isConstVariableReference(n.expression); default: return false; @@ -15518,10 +15937,7 @@ var ts; return true; } function checkDeleteExpression(node) { - if (node.parserContextFlags & 1 && node.expression.kind === 65) { - grammarErrorOnNode(node.expression, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode); - } - var operandType = checkExpression(node.expression); + checkExpression(node.expression); return booleanType; } function checkTypeOfExpression(node) { @@ -15533,9 +15949,6 @@ var ts; return undefinedType; } function checkPrefixUnaryExpression(node) { - if ((node.operator === 38 || node.operator === 39)) { - checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); - } var operandType = checkExpression(node.operand); switch (node.operator) { case 33: @@ -15558,7 +15971,6 @@ var ts; return unknownType; } function checkPostfixUnaryExpression(node) { - checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); var operandType = checkExpression(node.operand); var ok = checkArithmeticOperandType(node.operand, operandType, ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type); if (ok) { @@ -15626,7 +16038,7 @@ var ts; var properties = node.properties; for (var _i = 0; _i < properties.length; _i++) { var p = properties[_i]; - if (p.kind === 225 || p.kind === 226) { + if (p.kind === 227 || p.kind === 228) { var name_12 = p.name; var type = isTypeAny(sourceType) ? sourceType @@ -15651,8 +16063,8 @@ var ts; var elements = node.elements; for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176) { - if (e.kind !== 174) { + if (e.kind !== 178) { + if (e.kind !== 176) { var propName = "" + i; var type = isTypeAny(sourceType) ? sourceType @@ -15677,7 +16089,7 @@ var ts; } else { var restExpression = e.expression; - if (restExpression.kind === 170 && restExpression.operatorToken.kind === 53) { + if (restExpression.kind === 172 && restExpression.operatorToken.kind === 53) { error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } else { @@ -15690,14 +16102,14 @@ var ts; return sourceType; } function checkDestructuringAssignment(target, sourceType, contextualMapper) { - if (target.kind === 170 && target.operatorToken.kind === 53) { + if (target.kind === 172 && target.operatorToken.kind === 53) { checkBinaryExpression(target, contextualMapper); target = target.left; } - if (target.kind === 155) { + if (target.kind === 157) { return checkObjectLiteralAssignment(target, sourceType, contextualMapper); } - if (target.kind === 154) { + if (target.kind === 156) { return checkArrayLiteralAssignment(target, sourceType, contextualMapper); } return checkReferenceAssignment(target, sourceType, contextualMapper); @@ -15710,11 +16122,8 @@ var ts; return sourceType; } function checkBinaryExpression(node, contextualMapper) { - if (ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { - checkGrammarEvalOrArgumentsInStrictMode(node, node.left); - } var operator = node.operatorToken.kind; - if (operator === 53 && (node.left.kind === 155 || node.left.kind === 154)) { + if (operator === 53 && (node.left.kind === 157 || node.left.kind === 156)) { return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); } var leftType = checkExpression(node.left, contextualMapper); @@ -15860,7 +16269,7 @@ var ts; if (ts.isFunctionLike(parent) && current === parent.body) { return false; } - else if (current.kind === 202 || current.kind === 175) { + else if (current.kind === 204 || current.kind === 177) { return true; } current = parent; @@ -15921,14 +16330,14 @@ var ts; return links.resolvedType; } function checkPropertyAssignment(node, contextualMapper) { - if (node.name.kind === 128) { + if (node.name.kind === 129) { checkComputedPropertyName(node.name); } return checkExpression(node.initializer, contextualMapper); } function checkObjectLiteralMethod(node, contextualMapper) { checkGrammarMethod(node); - if (node.name.kind === 128) { + if (node.name.kind === 129) { checkComputedPropertyName(node.name); } var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); @@ -15950,12 +16359,8 @@ var ts; return type; } function checkExpression(node, contextualMapper) { - checkGrammarIdentifierInStrictMode(node); - return checkExpressionOrQualifiedName(node, contextualMapper); - } - function checkExpressionOrQualifiedName(node, contextualMapper) { var type; - if (node.kind == 127) { + if (node.kind === 128) { type = checkQualifiedName(node); } else { @@ -15963,9 +16368,9 @@ var ts; type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper); } if (isConstEnumObjectType(type)) { - var ok = (node.parent.kind === 156 && node.parent.expression === node) || - (node.parent.kind === 157 && node.parent.expression === node) || - ((node.kind === 65 || node.kind === 127) && isInRightSideOfImportOrExportAssignment(node)); + var ok = (node.parent.kind === 158 && node.parent.expression === node) || + (node.parent.kind === 159 && node.parent.expression === node) || + ((node.kind === 65 || node.kind === 128) && isInRightSideOfImportOrExportAssignment(node)); if (!ok) { error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment); } @@ -15991,60 +16396,59 @@ var ts; return booleanType; case 7: return checkNumericLiteral(node); - case 172: + case 174: return checkTemplateExpression(node); case 8: case 10: return stringType; case 9: return globalRegExpType; - case 154: - return checkArrayLiteral(node, contextualMapper); - case 155: - return checkObjectLiteral(node, contextualMapper); case 156: - return checkPropertyAccessExpression(node); + return checkArrayLiteral(node, contextualMapper); case 157: - return checkIndexedAccess(node); + return checkObjectLiteral(node, contextualMapper); case 158: + return checkPropertyAccessExpression(node); case 159: - return checkCallExpression(node); + return checkIndexedAccess(node); case 160: - return checkTaggedTemplateExpression(node); case 161: - return checkTypeAssertion(node); + return checkCallExpression(node); case 162: - return checkExpression(node.expression, contextualMapper); - case 175: - return checkClassExpression(node); + return checkTaggedTemplateExpression(node); case 163: + return checkTypeAssertion(node); case 164: - return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); - case 166: - return checkTypeOfExpression(node); + return checkExpression(node.expression, contextualMapper); + case 177: + return checkClassExpression(node); case 165: - return checkDeleteExpression(node); - case 167: - return checkVoidExpression(node); + case 166: + return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); case 168: - return checkPrefixUnaryExpression(node); + return checkTypeOfExpression(node); + case 167: + return checkDeleteExpression(node); case 169: - return checkPostfixUnaryExpression(node); + return checkVoidExpression(node); case 170: - return checkBinaryExpression(node, contextualMapper); + return checkPrefixUnaryExpression(node); case 171: - return checkConditionalExpression(node, contextualMapper); - case 174: - return checkSpreadElementExpression(node, contextualMapper); - case 176: - return undefinedType; + return checkPostfixUnaryExpression(node); + case 172: + return checkBinaryExpression(node, contextualMapper); case 173: + return checkConditionalExpression(node, contextualMapper); + case 176: + return checkSpreadElementExpression(node, contextualMapper); + case 178: + return undefinedType; + case 175: return checkYieldExpression(node); } return unknownType; } function checkTypeParameter(node) { - checkGrammarDeclarationNameInStrictMode(node); if (node.expression) { grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected); } @@ -16059,14 +16463,12 @@ var ts; // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code // or if its FunctionBody is strict code(11.1.5). - // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a - // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) - checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + checkGrammarDecorators(node) || checkGrammarModifiers(node); checkVariableLikeDeclaration(node); var func = ts.getContainingFunction(node); if (node.flags & 112) { func = ts.getContainingFunction(node); - if (!(func.kind === 136 && ts.nodeIsPresent(func.body))) { + if (!(func.kind === 137 && ts.nodeIsPresent(func.body))) { error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } @@ -16081,32 +16483,106 @@ var ts; if (!node.asteriskToken || !node.body) { return false; } - return node.kind === 135 || - node.kind === 201 || - node.kind === 163; + return node.kind === 136 || + node.kind === 203 || + node.kind === 165; + } + function getTypePredicateParameterIndex(parameterList, parameter) { + if (parameterList) { + for (var i = 0; i < parameterList.length; i++) { + var param = parameterList[i]; + if (param.name.kind === 65 && + param.name.text === parameter.text) { + return i; + } + } + } + return -1; + } + function isInLegalTypePredicatePosition(node) { + switch (node.parent.kind) { + case 166: + case 140: + case 203: + case 165: + case 145: + case 136: + case 135: + return node === node.parent.type; + } + return false; } function checkSignatureDeclaration(node) { - if (node.kind === 141) { + if (node.kind === 142) { checkGrammarIndexSignature(node); } - else if (node.kind === 143 || node.kind === 201 || node.kind === 144 || - node.kind === 139 || node.kind === 136 || - node.kind === 140) { + else if (node.kind === 145 || node.kind === 203 || node.kind === 146 || + node.kind === 140 || node.kind === 137 || + node.kind === 141) { checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); ts.forEach(node.parameters, checkParameter); if (node.type) { - checkSourceElement(node.type); + if (node.type.kind === 143) { + var typePredicate = getSignatureFromDeclaration(node).typePredicate; + var typePredicateNode = node.type; + if (isInLegalTypePredicatePosition(typePredicateNode)) { + if (typePredicate.parameterIndex >= 0) { + if (node.parameters[typePredicate.parameterIndex].dotDotDotToken) { + error(typePredicateNode.parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter); + } + else { + checkTypeAssignableTo(typePredicate.type, getTypeAtLocation(node.parameters[typePredicate.parameterIndex]), typePredicateNode.type); + } + } + else if (typePredicateNode.parameterName) { + var hasReportedError = false; + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var param = _a[_i]; + if (hasReportedError) { + break; + } + if (param.name.kind === 153 || + param.name.kind === 154) { + (function checkBindingPattern(pattern) { + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (element.name.kind === 65 && + element.name.text === typePredicate.parameterName) { + error(typePredicateNode.parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, typePredicate.parameterName); + hasReportedError = true; + break; + } + else if (element.name.kind === 154 || + element.name.kind === 153) { + checkBindingPattern(element.name); + } + } + })(param.name); + } + } + if (!hasReportedError) { + error(typePredicateNode.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName); + } + } + } + else { + error(typePredicateNode, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + } + } + else { + checkSourceElement(node.type); + } } if (produceDiagnostics) { checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { - case 140: + case 141: error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; - case 139: + case 140: error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; } @@ -16128,7 +16604,7 @@ var ts; checkSpecializedSignatureDeclaration(node); } function checkTypeForDuplicateIndexSignatures(node) { - if (node.kind === 203) { + if (node.kind === 205) { var nodeSymbol = getSymbolOfNode(node); if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { return; @@ -16143,7 +16619,7 @@ var ts; var declaration = decl; if (declaration.parameters.length === 1 && declaration.parameters[0].type) { switch (declaration.parameters[0].type.kind) { - case 122: + case 123: if (!seenStringIndexer) { seenStringIndexer = true; } @@ -16151,7 +16627,7 @@ var ts; error(declaration, ts.Diagnostics.Duplicate_string_index_signature); } break; - case 120: + case 121: if (!seenNumericIndexer) { seenNumericIndexer = true; } @@ -16188,17 +16664,17 @@ var ts; return; } function isSuperCallExpression(n) { - return n.kind === 158 && n.expression.kind === 91; + return n.kind === 160 && n.expression.kind === 91; } function containsSuperCall(n) { if (isSuperCallExpression(n)) { return true; } switch (n.kind) { - case 163: - case 201: - case 164: - case 155: return false; + case 165: + case 203: + case 166: + case 157: return false; default: return ts.forEachChild(n, containsSuperCall); } } @@ -16206,12 +16682,12 @@ var ts; if (n.kind === 93) { error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); } - else if (n.kind !== 163 && n.kind !== 201) { + else if (n.kind !== 165 && n.kind !== 203) { ts.forEachChild(n, markThisReferencesAsErrors); } } function isInstancePropertyWithInitializer(n) { - return n.kind === 133 && + return n.kind === 134 && !(n.flags & 128) && !!n.initializer; } @@ -16221,7 +16697,7 @@ var ts; ts.forEach(node.parameters, function (p) { return p.flags & (16 | 32 | 64); }); if (superCallShouldBeFirst) { var statements = node.body.statements; - if (!statements.length || statements[0].kind !== 183 || !isSuperCallExpression(statements[0].expression)) { + if (!statements.length || statements[0].kind !== 185 || !isSuperCallExpression(statements[0].expression)) { error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties); } else { @@ -16237,13 +16713,13 @@ var ts; function checkAccessorDeclaration(node) { if (produceDiagnostics) { checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); - if (node.kind === 137) { + if (node.kind === 138) { if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) { error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement); } } if (!ts.hasDynamicName(node)) { - var otherKind = node.kind === 137 ? 138 : 137; + var otherKind = node.kind === 138 ? 139 : 138; var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); if (otherAccessor) { if (((node.flags & 112) !== (otherAccessor.flags & 112))) { @@ -16265,26 +16741,26 @@ var ts; function checkMissingDeclaration(node) { checkDecorators(node); } + function checkTypeArgumentConstraints(typeParameters, typeArguments) { + var result = true; + for (var i = 0; i < typeParameters.length; i++) { + var constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + var typeArgument = typeArguments[i]; + result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + } + } + return result; + } function checkTypeReferenceNode(node) { - checkGrammarTypeReferenceInStrictMode(node.typeName); - return checkTypeReferenceOrExpressionWithTypeArguments(node); - } - function checkExpressionWithTypeArguments(node) { - checkGrammarExpressionWithTypeArgumentsInStrictMode(node.expression); - return checkTypeReferenceOrExpressionWithTypeArguments(node); - } - function checkTypeReferenceOrExpressionWithTypeArguments(node) { checkGrammarTypeArguments(node, node.typeArguments); - var type = getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); + var type = getTypeFromTypeReference(node); if (type !== unknownType && node.typeArguments) { - var len = node.typeArguments.length; - for (var i = 0; i < len; i++) { - checkSourceElement(node.typeArguments[i]); - var constraint = getConstraintOfTypeParameter(type.target.typeParameters[i]); - if (produceDiagnostics && constraint) { - var typeArgument = type.typeArguments[i]; - checkTypeAssignableTo(typeArgument, constraint, node, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); - } + ts.forEach(node.typeArguments, checkSourceElement); + if (produceDiagnostics) { + var symbol = getNodeLinks(node).resolvedSymbol; + var typeParameters = symbol.flags & 524288 ? getSymbolLinks(symbol).typeParameters : type.target.localTypeParameters; + checkTypeArgumentConstraints(typeParameters, node.typeArguments); } } } @@ -16328,9 +16804,9 @@ var ts; return; } var signaturesToCheck; - if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 203) { - ts.Debug.assert(signatureDeclarationNode.kind === 139 || signatureDeclarationNode.kind === 140); - var signatureKind = signatureDeclarationNode.kind === 139 ? 0 : 1; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 205) { + ts.Debug.assert(signatureDeclarationNode.kind === 140 || signatureDeclarationNode.kind === 141); + var signatureKind = signatureDeclarationNode.kind === 140 ? 0 : 1; var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); var containingType = getDeclaredTypeOfSymbol(containingSymbol); signaturesToCheck = getSignaturesOfType(containingType, signatureKind); @@ -16348,7 +16824,7 @@ var ts; } function getEffectiveDeclarationFlags(n, flagsToCheck) { var flags = ts.getCombinedNodeFlags(n); - if (n.parent.kind !== 203 && ts.isInAmbientContext(n)) { + if (n.parent.kind !== 205 && ts.isInAmbientContext(n)) { if (!(flags & 2)) { flags |= 1; } @@ -16421,7 +16897,7 @@ var ts; if (subsequentNode.kind === node.kind) { var errorNode_1 = subsequentNode.name || subsequentNode; if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { - ts.Debug.assert(node.kind === 135 || node.kind === 134); + ts.Debug.assert(node.kind === 136 || node.kind === 135); ts.Debug.assert((node.flags & 128) !== (subsequentNode.flags & 128)); var diagnostic = node.flags & 128 ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static; error(errorNode_1, diagnostic); @@ -16448,11 +16924,11 @@ var ts; var current = declarations[_i]; var node = current; var inAmbientContext = ts.isInAmbientContext(node); - var inAmbientContextOrInterface = node.parent.kind === 203 || node.parent.kind === 146 || inAmbientContext; + var inAmbientContextOrInterface = node.parent.kind === 205 || node.parent.kind === 148 || inAmbientContext; if (inAmbientContextOrInterface) { previousDeclaration = undefined; } - if (node.kind === 201 || node.kind === 135 || node.kind === 134 || node.kind === 136) { + if (node.kind === 203 || node.kind === 136 || node.kind === 135 || node.kind === 137) { var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); someNodeFlags |= currentNodeFlags; allNodeFlags &= currentNodeFlags; @@ -16549,16 +17025,16 @@ var ts; } function getDeclarationSpaces(d) { switch (d.kind) { - case 203: + case 205: return 2097152; - case 206: + case 208: return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; - case 202: - case 205: + case 204: + case 207: return 2097152 | 1048576; - case 209: + case 211: var result = 0; var target = resolveAlias(getSymbolOfNode(d)); ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); @@ -16572,54 +17048,54 @@ var ts; var expression = node.expression; var exprType = checkExpression(expression); switch (node.parent.kind) { - case 202: + case 204: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); checkTypeAssignableTo(exprType, classDecoratorType, node); break; - case 133: + case 134: checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); break; - case 135: - case 137: + case 136: case 138: + case 139: var methodType = getTypeOfNode(node.parent); var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); checkTypeAssignableTo(exprType, methodDecoratorType, node); break; - case 130: + case 131: checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); break; } } function checkTypeNodeAsExpression(node) { - if (node && node.kind === 142) { + if (node && node.kind === 144) { var type = getTypeFromTypeNode(node); var shouldCheckIfUnknownType = type === unknownType && compilerOptions.isolatedModules; if (!type || (!shouldCheckIfUnknownType && type.flags & (2097279 | 132 | 258))) { return; } if (shouldCheckIfUnknownType || type.symbol.valueDeclaration) { - checkExpressionOrQualifiedName(node.typeName); + checkExpression(node.typeName); } } } function checkTypeAnnotationAsExpression(node) { switch (node.kind) { - case 133: + case 134: checkTypeNodeAsExpression(node.type); break; - case 130: + case 131: checkTypeNodeAsExpression(node.type); break; - case 135: - checkTypeNodeAsExpression(node.type); - break; - case 137: + case 136: checkTypeNodeAsExpression(node.type); break; case 138: + checkTypeNodeAsExpression(node.type); + break; + case 139: checkTypeNodeAsExpression(getSetAccessorTypeAnnotationNode(node)); break; } @@ -16642,43 +17118,40 @@ var ts; } if (compilerOptions.emitDecoratorMetadata) { switch (node.kind) { - case 202: + case 204: var constructor = ts.getFirstConstructorWithBody(node); if (constructor) { checkParameterTypeAnnotationsAsExpressions(constructor); } break; - case 135: + case 136: checkParameterTypeAnnotationsAsExpressions(node); + case 139: case 138: - case 137: - case 133: - case 130: + case 134: + case 131: checkTypeAnnotationAsExpression(node); break; } } emitDecorate = true; - if (node.kind === 130) { + if (node.kind === 131) { emitParam = true; } ts.forEach(node.decorators, checkDecorator); } function checkFunctionDeclaration(node) { if (produceDiagnostics) { - checkFunctionLikeDeclaration(node) || - checkGrammarFunctionName(node.name) || - checkGrammarForGenerator(node); + checkFunctionLikeDeclaration(node) || checkGrammarForGenerator(node); checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); } } function checkFunctionLikeDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSignatureDeclaration(node); - if (node.name && node.name.kind === 128) { + if (node.name && node.name.kind === 129) { checkComputedPropertyName(node.name); } if (!ts.hasDynamicName(node)) { @@ -16708,11 +17181,11 @@ var ts; } } function checkBlock(node) { - if (node.kind === 180) { + if (node.kind === 182) { checkGrammarStatementInAmbientContext(node); } ts.forEach(node.statements, checkSourceElement); - if (ts.isFunctionBlock(node) || node.kind === 207) { + if (ts.isFunctionBlock(node) || node.kind === 209) { checkFunctionExpressionBodies(node); } } @@ -16730,19 +17203,19 @@ var ts; if (!(identifier && identifier.text === name)) { return false; } - if (node.kind === 133 || - node.kind === 132 || + if (node.kind === 134 || + node.kind === 133 || + node.kind === 136 || node.kind === 135 || - node.kind === 134 || - node.kind === 137 || - node.kind === 138) { + node.kind === 138 || + node.kind === 139) { return false; } if (ts.isInAmbientContext(node)) { return false; } var root = ts.getRootDeclaration(node); - if (root.kind === 130 && ts.nodeIsMissing(root.parent.body)) { + if (root.kind === 131 && ts.nodeIsMissing(root.parent.body)) { return false; } return true; @@ -16772,7 +17245,7 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; } - var enclosingClass = ts.getAncestor(node, 202); + var enclosingClass = ts.getAncestor(node, 204); if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; } @@ -16790,11 +17263,11 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { return; } - if (node.kind === 206 && ts.getModuleInstanceState(node) !== 1) { + if (node.kind === 208 && ts.getModuleInstanceState(node) !== 1) { return; } var parent = getDeclarationContainer(node); - if (parent.kind === 228 && ts.isExternalModule(parent)) { + if (parent.kind === 230 && ts.isExternalModule(parent)) { error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); } } @@ -16805,7 +17278,7 @@ var ts; if ((ts.getCombinedNodeFlags(node) & 12288) !== 0 || ts.isParameterDeclaration(node)) { return; } - if (node.kind === 199 && !node.initializer) { + if (node.kind === 201 && !node.initializer) { return; } var symbol = getSymbolOfNode(node); @@ -16815,15 +17288,15 @@ var ts; localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2) { if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 12288) { - var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 200); - var container = varDeclList.parent.kind === 181 && varDeclList.parent.parent + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 202); + var container = varDeclList.parent.kind === 183 && varDeclList.parent.parent ? varDeclList.parent.parent : undefined; var namesShareScope = container && - (container.kind === 180 && ts.isFunctionLike(container.parent) || - container.kind === 207 || - container.kind === 206 || - container.kind === 228); + (container.kind === 182 && ts.isFunctionLike(container.parent) || + container.kind === 209 || + container.kind === 208 || + container.kind === 230); if (!namesShareScope) { var name_13 = symbolToString(localDeclarationSymbol); error(node, ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name_13, name_13); @@ -16833,7 +17306,7 @@ var ts; } } function checkParameterInitializer(node) { - if (ts.getRootDeclaration(node).kind !== 130) { + if (ts.getRootDeclaration(node).kind !== 131) { return; } var func = ts.getContainingFunction(node); @@ -16842,7 +17315,7 @@ var ts; if (n.kind === 65) { var referencedSymbol = getNodeLinks(n).resolvedSymbol; if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455) === referencedSymbol) { - if (referencedSymbol.valueDeclaration.kind === 130) { + if (referencedSymbol.valueDeclaration.kind === 131) { if (referencedSymbol.valueDeclaration === node) { error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); return; @@ -16860,10 +17333,9 @@ var ts; } } function checkVariableLikeDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSourceElement(node.type); - if (node.name.kind === 128) { + if (node.name.kind === 129) { checkComputedPropertyName(node.name); if (node.initializer) { checkExpressionCached(node.initializer); @@ -16872,7 +17344,7 @@ var ts; if (ts.isBindingPattern(node.name)) { ts.forEach(node.name.elements, checkSourceElement); } - if (node.initializer && ts.getRootDeclaration(node).kind === 130 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + if (node.initializer && ts.getRootDeclaration(node).kind === 131 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); return; } @@ -16900,9 +17372,9 @@ var ts; checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); } } - if (node.kind !== 133 && node.kind !== 132) { + if (node.kind !== 134 && node.kind !== 133) { checkExportsOnMergedDeclarations(node); - if (node.kind === 199 || node.kind === 153) { + if (node.kind === 201 || node.kind === 155) { checkVarDeclaredNamesNotShadowed(node); } checkCollisionWithCapturedSuperVariable(node, node.name); @@ -16931,7 +17403,7 @@ var ts; } function inBlockOrObjectLiteralExpression(node) { while (node) { - if (node.kind === 180 || node.kind === 155) { + if (node.kind === 182 || node.kind === 157) { return true; } node = node.parent; @@ -16959,12 +17431,12 @@ var ts; } function checkForStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { - if (node.initializer && node.initializer.kind == 200) { + if (node.initializer && node.initializer.kind === 202) { checkGrammarVariableDeclarationList(node.initializer); } } if (node.initializer) { - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { ts.forEach(node.initializer.declarations, checkVariableDeclaration); } else { @@ -16979,13 +17451,13 @@ var ts; } function checkForOfStatement(node) { checkGrammarForInOrForOfStatement(node); - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { checkForInOrForOfVariableDeclaration(node); } else { var varExpr = node.initializer; var iteratedType = checkRightHandSideOfForOf(node.expression); - if (varExpr.kind === 154 || varExpr.kind === 155) { + if (varExpr.kind === 156 || varExpr.kind === 157) { checkDestructuringAssignment(varExpr, iteratedType || unknownType); } else { @@ -17000,7 +17472,7 @@ var ts; } function checkForInStatement(node) { checkGrammarForInOrForOfStatement(node); - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { var variable = node.initializer.declarations[0]; if (variable && ts.isBindingPattern(variable.name)) { error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); @@ -17010,7 +17482,7 @@ var ts; else { var varExpr = node.initializer; var leftType = checkExpression(varExpr); - if (varExpr.kind === 154 || varExpr.kind === 155) { + if (varExpr.kind === 156 || varExpr.kind === 157) { error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); } else if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, 258)) { @@ -17172,7 +17644,7 @@ var ts; checkGrammarStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node); } function isGetAccessorWithAnnotatatedSetAccessor(node) { - return !!(node.kind === 137 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 138))); + return !!(node.kind === 138 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 139))); } function checkReturnStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { @@ -17184,31 +17656,28 @@ var ts; if (node.expression) { var func = ts.getContainingFunction(node); if (func) { - var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); + var signature = getSignatureFromDeclaration(func); + var returnType = getReturnTypeOfSignature(signature); var exprType = checkExpressionCached(node.expression); if (func.asteriskToken) { return; } - if (func.kind === 138) { + if (func.kind === 139) { error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); } - else if (func.kind === 136) { + else if (func.kind === 137) { if (!isTypeAssignableTo(exprType, returnType)) { error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } } - else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) { + else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) { checkTypeAssignableTo(exprType, returnType, node.expression, undefined); } } } } function checkWithStatement(node) { - if (!checkGrammarStatementInAmbientContext(node)) { - if (node.parserContextFlags & 1) { - grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); - } - } + checkGrammarStatementInAmbientContext(node); checkExpression(node.expression); error(node.expression, ts.Diagnostics.All_symbols_within_a_with_block_will_be_resolved_to_any); } @@ -17218,7 +17687,7 @@ var ts; var hasDuplicateDefaultClause = false; var expressionType = checkExpression(node.expression); ts.forEach(node.caseBlock.clauses, function (clause) { - if (clause.kind === 222 && !hasDuplicateDefaultClause) { + if (clause.kind === 224 && !hasDuplicateDefaultClause) { if (firstDefaultClause === undefined) { firstDefaultClause = clause; } @@ -17230,7 +17699,7 @@ var ts; hasDuplicateDefaultClause = true; } } - if (produceDiagnostics && clause.kind === 221) { + if (produceDiagnostics && clause.kind === 223) { var caseClause = clause; var caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { @@ -17247,7 +17716,7 @@ var ts; if (ts.isFunctionLike(current)) { break; } - if (current.kind === 195 && current.label.text === node.label.text) { + if (current.kind === 197 && current.label.text === node.label.text) { var sourceFile = ts.getSourceFileOfNode(node); grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNodeFromSourceText(sourceFile.text, node.label)); break; @@ -17291,7 +17760,6 @@ var ts; grammarErrorOnNode(localSymbol.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, identifierName); } } - checkGrammarEvalOrArgumentsInStrictMode(node, catchClause.variableDeclaration.name); } } checkBlock(catchClause.block); @@ -17311,7 +17779,7 @@ var ts; checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0); checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1); }); - if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 202) { + if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 204) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; @@ -17342,7 +17810,7 @@ var ts; return; } var errorNode; - if (prop.valueDeclaration.name.kind === 128 || prop.parent === containingType.symbol) { + if (prop.valueDeclaration.name.kind === 129 || prop.parent === containingType.symbol) { errorNode = prop.valueDeclaration; } else if (indexDeclaration) { @@ -17392,7 +17860,6 @@ var ts; return unknownType; } function checkClassDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); if (!node.name && !(node.flags & 256)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } @@ -17410,35 +17877,38 @@ var ts; var staticType = getTypeOfSymbol(symbol); var baseTypeNode = ts.getClassExtendsHeritageClauseElement(node); if (baseTypeNode) { - if (!ts.isSupportedExpressionWithTypeArguments(baseTypeNode)) { - error(baseTypeNode.expression, ts.Diagnostics.Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses); - } emitExtends = emitExtends || !ts.isInAmbientContext(node); - checkExpressionWithTypeArguments(baseTypeNode); - } - var baseTypes = getBaseTypes(type); - if (baseTypes.length) { - if (produceDiagnostics) { + var baseTypes = getBaseTypes(type); + if (baseTypes.length && produceDiagnostics) { var baseType = baseTypes[0]; + var staticBaseType = getBaseConstructorTypeOfClass(type); + if (baseTypeNode.typeArguments) { + ts.forEach(baseTypeNode.typeArguments, checkSourceElement); + for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); _i < _a.length; _i++) { + var constructor = _a[_i]; + if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) { + break; + } + } + } checkTypeAssignableTo(type, baseType, node.name || node, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1); - var staticBaseType = getTypeOfSymbol(baseType.symbol); - checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); - if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, 107455)) { - error(baseTypeNode, ts.Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType)); + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); + if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32)) { + var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); + if (ts.forEach(constructors, function (sig) { return getReturnTypeOfSignature(sig) !== baseType; })) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type); + } } checkKindsOfPropertyMemberOverrides(type, baseType); } } - if (baseTypes.length || (baseTypeNode && compilerOptions.isolatedModules)) { - checkExpressionOrQualifiedName(baseTypeNode.expression); - } var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node); if (implementedTypeNodes) { ts.forEach(implementedTypeNodes, function (typeRefNode) { if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) { error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments); } - checkExpressionWithTypeArguments(typeRefNode); + checkTypeReferenceNode(typeRefNode); if (produceDiagnostics) { var t = getTypeFromTypeNode(typeRefNode); if (t !== unknownType) { @@ -17520,7 +17990,7 @@ var ts; } } function isAccessor(kind) { - return kind === 137 || kind === 138; + return kind === 138 || kind === 139; } function areTypeParametersIdentical(list1, list2) { if (!list1 && !list2) { @@ -17580,13 +18050,13 @@ var ts; return ok; } function checkInterfaceDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); checkTypeParameters(node.typeParameters); if (produceDiagnostics) { checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 203); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 205); if (symbol.declarations.length > 1) { if (node !== firstInterfaceDecl && !areTypeParametersIdentical(firstInterfaceDecl.typeParameters, node.typeParameters)) { error(node.name, ts.Diagnostics.All_declarations_of_an_interface_must_have_identical_type_parameters); @@ -17606,7 +18076,7 @@ var ts; if (!ts.isSupportedExpressionWithTypeArguments(heritageElement)) { error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments); } - checkExpressionWithTypeArguments(heritageElement); + checkTypeReferenceNode(heritageElement); }); ts.forEach(node.members, checkSourceElement); if (produceDiagnostics) { @@ -17627,7 +18097,7 @@ var ts; var ambient = ts.isInAmbientContext(node); var enumIsConst = ts.isConst(node); ts.forEach(node.members, function (member) { - if (member.name.kind !== 128 && isNumericLiteralName(member.name.text)) { + if (member.name.kind !== 129 && isNumericLiteralName(member.name.text)) { error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); } var initializer = member.initializer; @@ -17663,7 +18133,7 @@ var ts; return evalConstant(initializer); function evalConstant(e) { switch (e.kind) { - case 168: + case 170: var value = evalConstant(e.operand); if (value === undefined) { return undefined; @@ -17674,7 +18144,7 @@ var ts; case 47: return ~value; } return undefined; - case 170: + case 172: var left = evalConstant(e.left); if (left === undefined) { return undefined; @@ -17699,11 +18169,11 @@ var ts; return undefined; case 7: return +e.text; - case 162: + case 164: return evalConstant(e.expression); case 65: - case 157: - case 156: + case 159: + case 158: var member = initializer.parent; var currentType = getTypeOfSymbol(getSymbolOfNode(member.parent)); var enumType; @@ -17714,7 +18184,7 @@ var ts; } else { var expression; - if (e.kind === 157) { + if (e.kind === 159) { if (e.argumentExpression === undefined || e.argumentExpression.kind !== 8) { return undefined; @@ -17731,7 +18201,7 @@ var ts; if (current.kind === 65) { break; } - else if (current.kind === 156) { + else if (current.kind === 158) { current = current.expression; } else { @@ -17766,7 +18236,7 @@ var ts; if (!produceDiagnostics) { return; } - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); @@ -17788,7 +18258,7 @@ var ts; } var seenEnumMissingInitialInitializer = false; ts.forEach(enumSymbol.declarations, function (declaration) { - if (declaration.kind !== 205) { + if (declaration.kind !== 207) { return false; } var enumDeclaration = declaration; @@ -17811,8 +18281,8 @@ var ts; var declarations = symbol.declarations; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; - if ((declaration.kind === 202 || - (declaration.kind === 201 && ts.nodeIsPresent(declaration.body))) && + if ((declaration.kind === 204 || + (declaration.kind === 203 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { return declaration; } @@ -17834,7 +18304,14 @@ var ts; } function checkModuleDeclaration(node) { if (produceDiagnostics) { - if (!checkGrammarDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { + var isAmbientExternalModule = node.name.kind === 8; + var contextErrorMessage = isAmbientExternalModule + ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file + : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module; + if (checkGrammarModuleElementContext(node, contextErrorMessage)) { + return; + } + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { if (!ts.isInAmbientContext(node) && node.name.kind === 8) { grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); } @@ -17856,13 +18333,13 @@ var ts; error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged); } } - var mergedClass = ts.getDeclarationOfKind(symbol, 202); + var mergedClass = ts.getDeclarationOfKind(symbol, 204); if (mergedClass && inSameLexicalScope(node, mergedClass)) { getNodeLinks(node).flags |= 2048; } } - if (node.name.kind === 8) { + if (isAmbientExternalModule) { if (!isGlobalSourceFile(node.parent)) { error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules); } @@ -17875,10 +18352,10 @@ var ts; } function getFirstIdentifier(node) { while (true) { - if (node.kind === 127) { + if (node.kind === 128) { node = node.left; } - else if (node.kind === 156) { + else if (node.kind === 158) { node = node.expression; } else { @@ -17894,9 +18371,9 @@ var ts; error(moduleName, ts.Diagnostics.String_literal_expected); return false; } - var inAmbientExternalModule = node.parent.kind === 207 && node.parent.parent.name.kind === 8; - if (node.parent.kind !== 228 && !inAmbientExternalModule) { - error(moduleName, node.kind === 216 ? + var inAmbientExternalModule = node.parent.kind === 209 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 230 && !inAmbientExternalModule) { + error(moduleName, node.kind === 218 ? ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module); return false; @@ -17915,7 +18392,7 @@ var ts; (symbol.flags & 793056 ? 793056 : 0) | (symbol.flags & 1536 ? 1536 : 0); if (target.flags & excludedMeanings) { - var message = node.kind === 218 ? + var message = node.kind === 220 ? ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0; error(node, message, symbolToString(symbol)); @@ -17928,7 +18405,10 @@ var ts; checkAliasSymbol(node); } function checkImportDeclaration(node) { - if (!checkGrammarImportDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + return; + } + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); } if (checkExternalImportOrExportDeclaration(node)) { @@ -17938,7 +18418,7 @@ var ts; checkImportBinding(importClause); } if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212) { + if (importClause.namedBindings.kind === 214) { checkImportBinding(importClause.namedBindings); } else { @@ -17949,7 +18429,10 @@ var ts; } } function checkImportEqualsDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node); + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + return; + } + checkGrammarDecorators(node) || checkGrammarModifiers(node); if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) { checkImportBinding(node); if (node.flags & 1) { @@ -17977,14 +18460,17 @@ var ts; } } function checkExportDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) { + return; + } if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); } if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { if (node.exportClause) { ts.forEach(node.exportClause.elements, checkExportSpecifier); - var inAmbientExternalModule = node.parent.kind === 207 && node.parent.parent.name.kind === 8; - if (node.parent.kind !== 228 && !inAmbientExternalModule) { + var inAmbientExternalModule = node.parent.kind === 209 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 230 && !inAmbientExternalModule) { error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace); } } @@ -17996,6 +18482,11 @@ var ts; } } } + function checkGrammarModuleElementContext(node, errorMessage) { + if (node.parent.kind !== 230 && node.parent.kind !== 209 && node.parent.kind !== 208) { + return grammarErrorOnFirstToken(node, errorMessage); + } + } function checkExportSpecifier(node) { checkAliasSymbol(node); if (!node.parent.parent.moduleSpecifier) { @@ -18003,8 +18494,11 @@ var ts; } } function checkExportAssignment(node) { - var container = node.parent.kind === 228 ? node.parent : node.parent.parent; - if (container.kind === 206 && container.name.kind === 65) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) { + return; + } + var container = node.parent.kind === 230 ? node.parent : node.parent.parent; + if (container.kind === 208 && container.name.kind === 65) { error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace); return; } @@ -18028,10 +18522,10 @@ var ts; } } function getModuleStatements(node) { - if (node.kind === 228) { + if (node.kind === 230) { return node.statements; } - if (node.kind === 206 && node.body.kind === 207) { + if (node.kind === 208 && node.body.kind === 209) { return node.body.statements; } return emptyArray; @@ -18056,170 +18550,175 @@ var ts; links.exportsChecked = true; } } + function checkTypePredicate(node) { + if (!isInLegalTypePredicatePosition(node)) { + error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + } + } function checkSourceElement(node) { if (!node) return; switch (node.kind) { - case 129: - return checkTypeParameter(node); case 130: + return checkTypeParameter(node); + case 131: return checkParameter(node); + case 134: case 133: - case 132: return checkPropertyDeclaration(node); - case 143: - case 144: - case 139: + case 145: + case 146: case 140: - return checkSignatureDeclaration(node); case 141: return checkSignatureDeclaration(node); - case 135: - case 134: - return checkMethodDeclaration(node); - case 136: - return checkConstructorDeclaration(node); - case 137: - case 138: - return checkAccessorDeclaration(node); case 142: + return checkSignatureDeclaration(node); + case 136: + case 135: + return checkMethodDeclaration(node); + case 137: + return checkConstructorDeclaration(node); + case 138: + case 139: + return checkAccessorDeclaration(node); + case 144: return checkTypeReferenceNode(node); - case 145: - return checkTypeQuery(node); - case 146: - return checkTypeLiteral(node); + case 143: + return checkTypePredicate(node); case 147: - return checkArrayType(node); + return checkTypeQuery(node); case 148: - return checkTupleType(node); + return checkTypeLiteral(node); case 149: - return checkUnionType(node); + return checkArrayType(node); case 150: + return checkTupleType(node); + case 151: + return checkUnionType(node); + case 152: return checkSourceElement(node.type); - case 201: - return checkFunctionDeclaration(node); - case 180: - case 207: - return checkBlock(node); - case 181: - return checkVariableStatement(node); - case 183: - return checkExpressionStatement(node); - case 184: - return checkIfStatement(node); - case 185: - return checkDoStatement(node); - case 186: - return checkWhileStatement(node); - case 187: - return checkForStatement(node); - case 188: - return checkForInStatement(node); - case 189: - return checkForOfStatement(node); - case 190: - case 191: - return checkBreakOrContinueStatement(node); - case 192: - return checkReturnStatement(node); - case 193: - return checkWithStatement(node); - case 194: - return checkSwitchStatement(node); - case 195: - return checkLabeledStatement(node); - case 196: - return checkThrowStatement(node); - case 197: - return checkTryStatement(node); - case 199: - return checkVariableDeclaration(node); - case 153: - return checkBindingElement(node); - case 202: - return checkClassDeclaration(node); case 203: - return checkInterfaceDeclaration(node); - case 204: - return checkTypeAliasDeclaration(node); - case 205: - return checkEnumDeclaration(node); - case 206: - return checkModuleDeclaration(node); - case 210: - return checkImportDeclaration(node); - case 209: - return checkImportEqualsDeclaration(node); - case 216: - return checkExportDeclaration(node); - case 215: - return checkExportAssignment(node); + return checkFunctionDeclaration(node); case 182: - checkGrammarStatementInAmbientContext(node); - return; + case 209: + return checkBlock(node); + case 183: + return checkVariableStatement(node); + case 185: + return checkExpressionStatement(node); + case 186: + return checkIfStatement(node); + case 187: + return checkDoStatement(node); + case 188: + return checkWhileStatement(node); + case 189: + return checkForStatement(node); + case 190: + return checkForInStatement(node); + case 191: + return checkForOfStatement(node); + case 192: + case 193: + return checkBreakOrContinueStatement(node); + case 194: + return checkReturnStatement(node); + case 195: + return checkWithStatement(node); + case 196: + return checkSwitchStatement(node); + case 197: + return checkLabeledStatement(node); case 198: + return checkThrowStatement(node); + case 199: + return checkTryStatement(node); + case 201: + return checkVariableDeclaration(node); + case 155: + return checkBindingElement(node); + case 204: + return checkClassDeclaration(node); + case 205: + return checkInterfaceDeclaration(node); + case 206: + return checkTypeAliasDeclaration(node); + case 207: + return checkEnumDeclaration(node); + case 208: + return checkModuleDeclaration(node); + case 212: + return checkImportDeclaration(node); + case 211: + return checkImportEqualsDeclaration(node); + case 218: + return checkExportDeclaration(node); + case 217: + return checkExportAssignment(node); + case 184: checkGrammarStatementInAmbientContext(node); return; - case 219: + case 200: + checkGrammarStatementInAmbientContext(node); + return; + case 221: return checkMissingDeclaration(node); } } function checkFunctionExpressionBodies(node) { switch (node.kind) { - case 163: - case 164: + case 165: + case 166: ts.forEach(node.parameters, checkFunctionExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; + case 136: case 135: - case 134: ts.forEach(node.decorators, checkFunctionExpressionBodies); ts.forEach(node.parameters, checkFunctionExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } break; - case 136: case 137: case 138: - case 201: + case 139: + case 203: ts.forEach(node.parameters, checkFunctionExpressionBodies); break; - case 193: + case 195: checkFunctionExpressionBodies(node.expression); break; - case 131: - case 130: - case 133: case 132: - case 151: - case 152: + case 131: + case 134: + case 133: case 153: case 154: case 155: - case 225: case 156: case 157: + case 227: case 158: case 159: case 160: - case 172: - case 178: case 161: case 162: - case 166: - case 167: - case 165: - case 168: - case 169: - case 170: - case 171: case 174: case 180: - case 207: - case 181: + case 163: + case 164: + case 168: + case 169: + case 167: + case 170: + case 171: + case 172: + case 173: + case 176: + case 182: + case 209: case 183: - case 184: case 185: case 186: case 187: @@ -18228,21 +18727,23 @@ var ts; case 190: case 191: case 192: + case 193: case 194: - case 208: - case 221: - case 222: - case 195: case 196: - case 197: + case 210: + case 223: case 224: + case 197: + case 198: case 199: - case 200: + case 226: + case 201: case 202: - case 205: - case 227: - case 215: - case 228: + case 204: + case 207: + case 229: + case 217: + case 230: ts.forEachChild(node, checkFunctionExpressionBodies); break; } @@ -18255,6 +18756,9 @@ var ts; function checkSourceFileWorker(node) { var links = getNodeLinks(node); if (!(links.flags & 1)) { + if (node.isDefaultLib && compilerOptions.skipDefaultLibCheck) { + return; + } checkGrammarSourceFile(node); emitExtends = false; emitDecorate = false; @@ -18302,7 +18806,7 @@ var ts; function isInsideWithStatementBody(node) { if (node) { while (node.parent) { - if (node.parent.kind === 193 && node.parent.statement === node) { + if (node.parent.kind === 195 && node.parent.statement === node) { return true; } node = node.parent; @@ -18324,23 +18828,23 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228: + case 230: if (!ts.isExternalModule(location)) { break; } - case 206: + case 208: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 205: + case 207: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 202: - case 203: + case 204: + case 205: if (!(memberFlags & 128)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 163: + case 165: if (location.name) { copySymbol(location.symbol, meaning); } @@ -18376,22 +18880,22 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228: + case 230: if (!ts.isExternalModule(location)) break; - case 206: + case 208: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 205: + case 207: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 202: - case 203: + case 204: + case 205: if (!(memberFlags & 128)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 163: + case 165: if (location.name) { copySymbol(location.symbol, meaning); } @@ -18404,42 +18908,42 @@ var ts; return symbolsToArray(symbols); } function isTypeDeclarationName(name) { - return name.kind == 65 && + return name.kind === 65 && isTypeDeclaration(name.parent) && name.parent.name === name; } function isTypeDeclaration(node) { switch (node.kind) { - case 129: - case 202: - case 203: + case 130: case 204: case 205: + case 206: + case 207: return true; } } function isTypeReferenceIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 127) { + while (node.parent && node.parent.kind === 128) { node = node.parent; } - return node.parent && node.parent.kind === 142; + return node.parent && node.parent.kind === 144; } function isHeritageClauseElementIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 156) { + while (node.parent && node.parent.kind === 158) { node = node.parent; } - return node.parent && node.parent.kind === 177; + return node.parent && node.parent.kind === 179; } function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { - while (nodeOnRightSide.parent.kind === 127) { + while (nodeOnRightSide.parent.kind === 128) { nodeOnRightSide = nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 209) { + if (nodeOnRightSide.parent.kind === 211) { return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 215) { + if (nodeOnRightSide.parent.kind === 217) { return nodeOnRightSide.parent.expression === nodeOnRightSide && nodeOnRightSide.parent; } return undefined; @@ -18451,10 +18955,10 @@ var ts; if (ts.isDeclarationName(entityName)) { return getSymbolOfNode(entityName.parent); } - if (entityName.parent.kind === 215) { + if (entityName.parent.kind === 217) { return resolveEntityName(entityName, 107455 | 793056 | 1536 | 8388608); } - if (entityName.kind !== 156) { + if (entityName.kind !== 158) { if (isInRightSideOfImportOrExportAssignment(entityName)) { return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); } @@ -18463,7 +18967,7 @@ var ts; entityName = entityName.parent; } if (isHeritageClauseElementIdentifier(entityName)) { - var meaning = entityName.parent.kind === 177 ? 793056 : 1536; + var meaning = entityName.parent.kind === 179 ? 793056 : 1536; meaning |= 8388608; return resolveEntityName(entityName, meaning); } @@ -18475,14 +18979,14 @@ var ts; var meaning = 107455 | 8388608; return resolveEntityName(entityName, meaning); } - else if (entityName.kind === 156) { + else if (entityName.kind === 158) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkPropertyAccessExpression(entityName); } return getNodeLinks(entityName).resolvedSymbol; } - else if (entityName.kind === 127) { + else if (entityName.kind === 128) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkQualifiedName(entityName); @@ -18491,7 +18995,7 @@ var ts; } } else if (isTypeReferenceIdentifier(entityName)) { - var meaning = entityName.parent.kind === 142 ? 793056 : 1536; + var meaning = entityName.parent.kind === 144 ? 793056 : 1536; meaning |= 8388608; return resolveEntityName(entityName, meaning); } @@ -18505,14 +19009,14 @@ var ts; return getSymbolOfNode(node.parent); } if (node.kind === 65 && isInRightSideOfImportOrExportAssignment(node)) { - return node.parent.kind === 215 + return node.parent.kind === 217 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); } switch (node.kind) { case 65: - case 156: - case 127: + case 158: + case 128: return getSymbolOfEntityNameOrPropertyAccessExpression(node); case 93: case 91: @@ -18520,7 +19024,7 @@ var ts; return type.symbol; case 114: var constructorDeclaration = node.parent; - if (constructorDeclaration && constructorDeclaration.kind === 136) { + if (constructorDeclaration && constructorDeclaration.kind === 137) { return constructorDeclaration.parent.symbol; } return undefined; @@ -18528,12 +19032,12 @@ var ts; var moduleName; if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) || - ((node.parent.kind === 210 || node.parent.kind === 216) && + ((node.parent.kind === 212 || node.parent.kind === 218) && node.parent.moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } case 7: - if (node.parent.kind == 157 && node.parent.argumentExpression === node) { + if (node.parent.kind === 159 && node.parent.argumentExpression === node) { var objectType = checkExpression(node.parent.expression); if (objectType === unknownType) return undefined; @@ -18547,7 +19051,7 @@ var ts; return undefined; } function getShorthandAssignmentValueSymbol(location) { - if (location && location.kind === 226) { + if (location && location.kind === 228) { return resolveEntityName(location.name, 107455); } return undefined; @@ -18562,6 +19066,9 @@ var ts; if (ts.isExpression(node)) { return getTypeOfExpression(node); } + if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(node)) { + return getBaseTypes(getDeclaredTypeOfSymbol(getSymbolOfNode(node.parent.parent)))[0]; + } if (isTypeDeclaration(node)) { var symbol = getSymbolOfNode(node); return getDeclaredTypeOfSymbol(symbol); @@ -18620,81 +19127,81 @@ var ts; } return [symbol]; } - function isExternalModuleSymbol(symbol) { - return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 228; - } - function getAliasNameSubstitution(symbol, getGeneratedNameForNode) { - if (languageVersion >= 2) { - return undefined; - } - var node = getDeclarationOfAliasSymbol(symbol); - if (node) { - if (node.kind === 211) { - var defaultKeyword; - if (languageVersion === 0) { - defaultKeyword = "[\"default\"]"; - } - else { - defaultKeyword = ".default"; - } - return getGeneratedNameForNode(node.parent) + defaultKeyword; - } - if (node.kind === 214) { - var moduleName = getGeneratedNameForNode(node.parent.parent.parent); - var propertyName = node.propertyName || node.name; - return moduleName + "." + ts.unescapeIdentifier(propertyName.text); - } - } - } - function getExportNameSubstitution(symbol, location, getGeneratedNameForNode) { - if (isExternalModuleSymbol(symbol.parent)) { - if (languageVersion >= 2 || compilerOptions.module === 4) { - return undefined; - } - return "exports." + ts.unescapeIdentifier(symbol.name); - } - var node = location; - var containerSymbol = getParentOfSymbol(symbol); - while (node) { - if ((node.kind === 206 || node.kind === 205) && getSymbolOfNode(node) === containerSymbol) { - return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); - } - node = node.parent; - } - } - function getExpressionNameSubstitution(node, getGeneratedNameForNode) { - var symbol = getNodeLinks(node).resolvedSymbol || (ts.isDeclarationName(node) ? getSymbolOfNode(node.parent) : undefined); + function getReferencedExportContainer(node) { + var symbol = getReferencedValueSymbol(node); if (symbol) { - if (symbol.parent) { - return getExportNameSubstitution(symbol, node.parent, getGeneratedNameForNode); + if (symbol.flags & 1048576) { + var exportSymbol = getMergedSymbol(symbol.exportSymbol); + if (exportSymbol.flags & 944) { + return undefined; + } + symbol = exportSymbol; } - var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); - if (symbol !== exportSymbol && !(exportSymbol.flags & 944)) { - return getExportNameSubstitution(exportSymbol, node.parent, getGeneratedNameForNode); - } - if (symbol.flags & 8388608) { - return getAliasNameSubstitution(symbol, getGeneratedNameForNode); + var parentSymbol = getParentOfSymbol(symbol); + if (parentSymbol) { + if (parentSymbol.flags & 512 && parentSymbol.valueDeclaration.kind === 230) { + return parentSymbol.valueDeclaration; + } + for (var n = node.parent; n; n = n.parent) { + if ((n.kind === 208 || n.kind === 207) && getSymbolOfNode(n) === parentSymbol) { + return n; + } + } } } } + function getReferencedImportDeclaration(node) { + var symbol = getReferencedValueSymbol(node); + return symbol && symbol.flags & 8388608 ? getDeclarationOfAliasSymbol(symbol) : undefined; + } + function isStatementWithLocals(node) { + switch (node.kind) { + case 182: + case 210: + case 189: + case 190: + case 191: + return true; + } + return false; + } + function isNestedRedeclarationSymbol(symbol) { + if (symbol.flags & 418) { + var links = getSymbolLinks(symbol); + if (links.isNestedRedeclaration === undefined) { + var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration); + links.isNestedRedeclaration = isStatementWithLocals(container) && + !!resolveName(container.parent, symbol.name, 107455, undefined, undefined); + } + return links.isNestedRedeclaration; + } + return false; + } + function getReferencedNestedRedeclaration(node) { + var symbol = getReferencedValueSymbol(node); + return symbol && isNestedRedeclarationSymbol(symbol) ? symbol.valueDeclaration : undefined; + } + function isNestedRedeclaration(node) { + return isNestedRedeclarationSymbol(getSymbolOfNode(node)); + } function isValueAliasDeclaration(node) { switch (node.kind) { - case 209: case 211: - case 212: + case 213: case 214: - case 218: - return isAliasResolvedToValue(getSymbolOfNode(node)); case 216: + case 220: + return isAliasResolvedToValue(getSymbolOfNode(node)); + case 218: var exportClause = node.exportClause; return exportClause && ts.forEach(exportClause.elements, isValueAliasDeclaration); - case 215: + case 217: return node.expression && node.expression.kind === 65 ? isAliasResolvedToValue(getSymbolOfNode(node)) : true; } return false; } function isTopLevelValueImportEqualsWithEntityName(node) { - if (node.parent.kind !== 228 || !ts.isInternalModuleImportEqualsDeclaration(node)) { + if (node.parent.kind !== 230 || !ts.isInternalModuleImportEqualsDeclaration(node)) { return false; } var isValue = isAliasResolvedToValue(getSymbolOfNode(node)); @@ -18739,7 +19246,7 @@ var ts; return getNodeLinks(node).enumMemberValue; } function getConstantValue(node) { - if (node.kind === 227) { + if (node.kind === 229) { return getEnumMemberValue(node); } var symbol = getNodeLinks(node).resolvedSymbol; @@ -18750,10 +19257,9 @@ var ts; } return undefined; } - function serializeEntityName(node, getGeneratedNameForNode, fallbackPath) { + function serializeEntityName(node, fallbackPath) { if (node.kind === 65) { - var substitution = getExpressionNameSubstitution(node, getGeneratedNameForNode); - var text = substitution || node.text; + var text = node.text; if (fallbackPath) { fallbackPath.push(text); } @@ -18762,14 +19268,14 @@ var ts; } } else { - var left = serializeEntityName(node.left, getGeneratedNameForNode, fallbackPath); - var right = serializeEntityName(node.right, getGeneratedNameForNode, fallbackPath); + var left = serializeEntityName(node.left, fallbackPath); + var right = serializeEntityName(node.right, fallbackPath); if (!fallbackPath) { return left + "." + right; } } } - function serializeTypeReferenceNode(node, getGeneratedNameForNode) { + function serializeTypeReferenceNode(node) { var type = getTypeFromTypeNode(node); if (type.flags & 16) { return "void 0"; @@ -18791,42 +19297,42 @@ var ts; } else if (type === unknownType) { var fallbackPath = []; - serializeEntityName(node.typeName, getGeneratedNameForNode, fallbackPath); + serializeEntityName(node.typeName, fallbackPath); return fallbackPath; } else if (type.symbol && type.symbol.valueDeclaration) { - return serializeEntityName(node.typeName, getGeneratedNameForNode); + return serializeEntityName(node.typeName); } else if (typeHasCallOrConstructSignatures(type)) { return "Function"; } return "Object"; } - function serializeTypeNode(node, getGeneratedNameForNode) { + function serializeTypeNode(node) { if (node) { switch (node.kind) { case 99: return "void 0"; - case 150: - return serializeTypeNode(node.type, getGeneratedNameForNode); - case 143: - case 144: + case 152: + return serializeTypeNode(node.type); + case 145: + case 146: return "Function"; - case 147: - case 148: + case 149: + case 150: return "Array"; case 113: return "Boolean"; - case 122: + case 123: case 8: return "String"; - case 120: + case 121: return "Number"; - case 142: - return serializeTypeReferenceNode(node, getGeneratedNameForNode); - case 145: - case 146: - case 149: + case 144: + return serializeTypeReferenceNode(node); + case 147: + case 148: + case 151: case 112: break; default: @@ -18836,23 +19342,23 @@ var ts; } return "Object"; } - function serializeTypeOfNode(node, getGeneratedNameForNode) { + function serializeTypeOfNode(node) { switch (node.kind) { - case 202: return "Function"; - case 133: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 130: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 137: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 138: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node), getGeneratedNameForNode); + case 204: return "Function"; + case 134: return serializeTypeNode(node.type); + case 131: return serializeTypeNode(node.type); + case 138: return serializeTypeNode(node.type); + case 139: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node)); } if (ts.isFunctionLike(node)) { return "Function"; } return "void 0"; } - function serializeParameterTypesOfNode(node, getGeneratedNameForNode) { + function serializeParameterTypesOfNode(node) { if (node) { var valueDeclaration; - if (node.kind === 202) { + if (node.kind === 204) { valueDeclaration = ts.getFirstConstructorWithBody(node); } else if (ts.isFunctionLike(node) && ts.nodeIsPresent(node.body)) { @@ -18867,19 +19373,19 @@ var ts; for (var i = 0; i < parameterCount; i++) { if (parameters[i].dotDotDotToken) { var parameterType = parameters[i].type; - if (parameterType.kind === 147) { + if (parameterType.kind === 149) { parameterType = parameterType.elementType; } - else if (parameterType.kind === 142 && parameterType.typeArguments && parameterType.typeArguments.length === 1) { + else if (parameterType.kind === 144 && parameterType.typeArguments && parameterType.typeArguments.length === 1) { parameterType = parameterType.typeArguments[0]; } else { parameterType = undefined; } - result[i] = serializeTypeNode(parameterType, getGeneratedNameForNode); + result[i] = serializeTypeNode(parameterType); } else { - result[i] = serializeTypeOfNode(parameters[i], getGeneratedNameForNode); + result[i] = serializeTypeOfNode(parameters[i]); } } return result; @@ -18888,9 +19394,9 @@ var ts; } return emptyArray; } - function serializeReturnTypeOfNode(node, getGeneratedNameForNode) { + function serializeReturnTypeOfNode(node) { if (node && ts.isFunctionLike(node)) { - return serializeTypeNode(node.type, getGeneratedNameForNode); + return serializeTypeNode(node.type); } return "void 0"; } @@ -18912,25 +19418,24 @@ var ts; function hasGlobalName(name) { return ts.hasProperty(globals, name); } - function resolvesToSomeValue(location, name) { - ts.Debug.assert(!ts.nodeIsSynthesized(location), "resolvesToSomeValue called with a synthesized location"); - return !!resolveName(location, name, 107455, undefined, undefined); + function getReferencedValueSymbol(reference) { + return getNodeLinks(reference).resolvedSymbol || + resolveName(reference, reference.text, 107455 | 1048576 | 8388608, undefined, undefined); } function getReferencedValueDeclaration(reference) { ts.Debug.assert(!ts.nodeIsSynthesized(reference)); - var symbol = getNodeLinks(reference).resolvedSymbol || - resolveName(reference, reference.text, 107455 | 8388608, undefined, undefined); + var symbol = getReferencedValueSymbol(reference); return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration; } function getBlockScopedVariableId(n) { ts.Debug.assert(!ts.nodeIsSynthesized(n)); - var isVariableDeclarationOrBindingElement = n.parent.kind === 153 || (n.parent.kind === 199 && n.parent.name === n); + var isVariableDeclarationOrBindingElement = n.parent.kind === 155 || (n.parent.kind === 201 && n.parent.name === n); var symbol = (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) || getNodeLinks(n).resolvedSymbol || resolveName(n, n.text, 107455 | 8388608, undefined, undefined); var isLetOrConst = symbol && (symbol.flags & 2) && - symbol.valueDeclaration.parent.kind !== 224; + symbol.valueDeclaration.parent.kind !== 226; if (isLetOrConst) { getSymbolLinks(symbol); return symbol.id; @@ -18950,7 +19455,10 @@ var ts; } function createResolver() { return { - getExpressionNameSubstitution: getExpressionNameSubstitution, + getReferencedExportContainer: getReferencedExportContainer, + getReferencedImportDeclaration: getReferencedImportDeclaration, + getReferencedNestedRedeclaration: getReferencedNestedRedeclaration, + isNestedRedeclaration: isNestedRedeclaration, isValueAliasDeclaration: isValueAliasDeclaration, hasGlobalName: hasGlobalName, isReferencedAliasDeclaration: isReferencedAliasDeclaration, @@ -18964,7 +19472,6 @@ var ts; isSymbolAccessible: isSymbolAccessible, isEntityNameVisible: isEntityNameVisible, getConstantValue: getConstantValue, - resolvesToSomeValue: resolvesToSomeValue, collectLinkedAliases: collectLinkedAliases, getBlockScopedVariableId: getBlockScopedVariableId, getReferencedValueDeclaration: getReferencedValueDeclaration, @@ -19015,105 +19522,6 @@ var ts; } anyArrayType = createArrayType(anyType); } - function isReservedWordInStrictMode(node) { - return (node.parserContextFlags & 1) && - (102 <= node.originalKeywordKind && node.originalKeywordKind <= 110); - } - function reportStrictModeGrammarErrorInClassDeclaration(identifier, message, arg0, arg1, arg2) { - if (ts.getAncestor(identifier, 202) || ts.getAncestor(identifier, 175)) { - return grammarErrorOnNode(identifier, message, arg0); - } - return false; - } - function checkGrammarImportDeclarationNameInStrictMode(node) { - if (node.importClause) { - var impotClause = node.importClause; - if (impotClause.namedBindings) { - var nameBindings = impotClause.namedBindings; - if (nameBindings.kind === 212) { - var name_15 = nameBindings.name; - if (isReservedWordInStrictMode(name_15)) { - var nameText = ts.declarationNameToString(name_15); - return grammarErrorOnNode(name_15, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - else if (nameBindings.kind === 213) { - var reportError = false; - for (var _i = 0, _a = nameBindings.elements; _i < _a.length; _i++) { - var element = _a[_i]; - var name_16 = element.name; - if (isReservedWordInStrictMode(name_16)) { - var nameText = ts.declarationNameToString(name_16); - reportError = reportError || grammarErrorOnNode(name_16, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - return reportError; - } - } - } - return false; - } - function checkGrammarDeclarationNameInStrictMode(node) { - var name = node.name; - if (name && name.kind === 65 && isReservedWordInStrictMode(name)) { - var nameText = ts.declarationNameToString(name); - switch (node.kind) { - case 130: - case 199: - case 201: - case 129: - case 153: - case 203: - case 204: - case 205: - return checkGrammarIdentifierInStrictMode(name); - case 202: - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText); - case 206: - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - case 209: - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - return false; - } - function checkGrammarTypeReferenceInStrictMode(typeName) { - if (typeName.kind === 65) { - checkGrammarTypeNameInStrictMode(typeName); - } - else if (typeName.kind === 127) { - checkGrammarTypeNameInStrictMode(typeName.right); - checkGrammarTypeReferenceInStrictMode(typeName.left); - } - } - function checkGrammarExpressionWithTypeArgumentsInStrictMode(expression) { - if (expression && expression.kind === 65) { - return checkGrammarIdentifierInStrictMode(expression); - } - else if (expression && expression.kind === 156) { - checkGrammarExpressionWithTypeArgumentsInStrictMode(expression.expression); - } - } - function checkGrammarIdentifierInStrictMode(node, nameText) { - if (node && node.kind === 65 && isReservedWordInStrictMode(node)) { - if (!nameText) { - nameText = ts.declarationNameToString(node); - } - var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || - grammarErrorOnNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - return errorReport; - } - return false; - } - function checkGrammarTypeNameInStrictMode(node) { - if (node && node.kind === 65 && isReservedWordInStrictMode(node)) { - var nameText = ts.declarationNameToString(node); - var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || - grammarErrorOnNode(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode, nameText); - return errorReport; - } - return false; - } function checkGrammarDecorators(node) { if (!node.decorators) { return false; @@ -19124,7 +19532,7 @@ var ts; else if (languageVersion < 1) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher); } - else if (node.kind === 137 || node.kind === 138) { + else if (node.kind === 138 || node.kind === 139) { var accessors = ts.getAllAccessorDeclarations(node.parent.members, node); if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name); @@ -19134,33 +19542,33 @@ var ts; } function checkGrammarModifiers(node) { switch (node.kind) { - case 137: case 138: - case 136: - case 133: - case 132: - case 135: + case 139: + case 137: case 134: - case 141: - case 206: - case 210: - case 209: - case 216: - case 215: - case 130: + case 133: + case 136: + case 135: + case 142: + case 208: + case 212: + case 211: + case 218: + case 217: + case 131: break; - case 202: - case 203: - case 181: - case 201: case 204: - if (node.modifiers && node.parent.kind !== 207 && node.parent.kind !== 228) { + case 205: + case 183: + case 203: + case 206: + if (node.modifiers && node.parent.kind !== 209 && node.parent.kind !== 230) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); } break; - case 205: + case 207: if (node.modifiers && (node.modifiers.length > 1 || node.modifiers[0].kind !== 70) && - node.parent.kind !== 207 && node.parent.kind !== 228) { + node.parent.kind !== 209 && node.parent.kind !== 230) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); } break; @@ -19196,7 +19604,7 @@ var ts; else if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } - else if (node.parent.kind === 207 || node.parent.kind === 228) { + else if (node.parent.kind === 209 || node.parent.kind === 230) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } flags |= ts.modifierToFlag(modifier.kind); @@ -19205,10 +19613,10 @@ var ts; if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); } - else if (node.parent.kind === 207 || node.parent.kind === 228) { + else if (node.parent.kind === 209 || node.parent.kind === 230) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } - else if (node.kind === 130) { + else if (node.kind === 131) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } flags |= 128; @@ -19221,10 +19629,10 @@ var ts; else if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } - else if (node.parent.kind === 202) { + else if (node.parent.kind === 204) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } - else if (node.kind === 130) { + else if (node.kind === 131) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); } flags |= 1; @@ -19233,13 +19641,13 @@ var ts; if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); } - else if (node.parent.kind === 202) { + else if (node.parent.kind === 204) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } - else if (node.kind === 130) { + else if (node.kind === 131) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); } - else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 207) { + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 209) { return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } flags |= 2; @@ -19247,7 +19655,7 @@ var ts; break; } } - if (node.kind === 136) { + if (node.kind === 137) { if (flags & 128) { return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } @@ -19258,10 +19666,10 @@ var ts; return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } } - else if ((node.kind === 210 || node.kind === 209) && flags & 2) { + else if ((node.kind === 212 || node.kind === 211) && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); } - else if (node.kind === 130 && (flags & 112) && ts.isBindingPattern(node.name)) { + else if (node.kind === 131 && (flags & 112) && ts.isBindingPattern(node.name)) { return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } } @@ -19324,7 +19732,7 @@ var ts; checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file); } function checkGrammarArrowFunction(node, file) { - if (node.kind === 164) { + if (node.kind === 166) { var arrowFunction = node; var startLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.pos).line; var endLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.end).line; @@ -19359,7 +19767,7 @@ var ts; if (!parameter.type) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation); } - if (parameter.type.kind !== 122 && parameter.type.kind !== 120) { + if (parameter.type.kind !== 123 && parameter.type.kind !== 121) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); } if (!node.type) { @@ -19391,7 +19799,7 @@ var ts; var sourceFile = ts.getSourceFileOfNode(node); for (var _i = 0; _i < arguments.length; _i++) { var arg = arguments[_i]; - if (arg.kind === 176) { + if (arg.kind === 178) { return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); } } @@ -19462,19 +19870,19 @@ var ts; return false; } function checkGrammarComputedPropertyName(node) { - if (node.kind !== 128) { + if (node.kind !== 129) { return false; } var computedPropertyName = node; - if (computedPropertyName.expression.kind === 170 && computedPropertyName.expression.operatorToken.kind === 23) { + if (computedPropertyName.expression.kind === 172 && computedPropertyName.expression.operatorToken.kind === 23) { return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); } } function checkGrammarForGenerator(node) { if (node.asteriskToken) { - ts.Debug.assert(node.kind === 201 || - node.kind === 163 || - node.kind === 135); + ts.Debug.assert(node.kind === 203 || + node.kind === 165 || + node.kind === 136); if (ts.isInAmbientContext(node)) { return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context); } @@ -19486,9 +19894,6 @@ var ts; } } } - function checkGrammarFunctionName(name) { - return checkGrammarEvalOrArgumentsInStrictMode(name, name); - } function checkGrammarForInvalidQuestionMark(node, questionToken, message) { if (questionToken) { return grammarErrorOnNode(questionToken, message); @@ -19500,55 +19905,52 @@ var ts; var GetAccessor = 2; var SetAccesor = 4; var GetOrSetAccessor = GetAccessor | SetAccesor; - var inStrictMode = (node.parserContextFlags & 1) !== 0; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var prop = _a[_i]; - var name_17 = prop.name; - if (prop.kind === 176 || - name_17.kind === 128) { - checkGrammarComputedPropertyName(name_17); + var name_15 = prop.name; + if (prop.kind === 178 || + name_15.kind === 129) { + checkGrammarComputedPropertyName(name_15); continue; } var currentKind = void 0; - if (prop.kind === 225 || prop.kind === 226) { + if (prop.kind === 227 || prop.kind === 228) { checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); - if (name_17.kind === 7) { - checkGrammarNumericLiteral(name_17); + if (name_15.kind === 7) { + checkGrammarNumericLiteral(name_15); } currentKind = Property; } - else if (prop.kind === 135) { + else if (prop.kind === 136) { currentKind = Property; } - else if (prop.kind === 137) { + else if (prop.kind === 138) { currentKind = GetAccessor; } - else if (prop.kind === 138) { + else if (prop.kind === 139) { currentKind = SetAccesor; } else { ts.Debug.fail("Unexpected syntax kind:" + prop.kind); } - if (!ts.hasProperty(seen, name_17.text)) { - seen[name_17.text] = currentKind; + if (!ts.hasProperty(seen, name_15.text)) { + seen[name_15.text] = currentKind; } else { - var existingKind = seen[name_17.text]; + var existingKind = seen[name_15.text]; if (currentKind === Property && existingKind === Property) { - if (inStrictMode) { - grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode); - } + continue; } else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) { if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) { - seen[name_17.text] = currentKind | existingKind; + seen[name_15.text] = currentKind | existingKind; } else { - return grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); + return grammarErrorOnNode(name_15, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); } } else { - return grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); + return grammarErrorOnNode(name_15, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); } } } @@ -19557,24 +19959,24 @@ var ts; if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; } - if (forInOrOfStatement.initializer.kind === 200) { + if (forInOrOfStatement.initializer.kind === 202) { var variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { if (variableList.declarations.length > 1) { - var diagnostic = forInOrOfStatement.kind === 188 + var diagnostic = forInOrOfStatement.kind === 190 ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement; return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic); } var firstDeclaration = variableList.declarations[0]; if (firstDeclaration.initializer) { - var diagnostic = forInOrOfStatement.kind === 188 + var diagnostic = forInOrOfStatement.kind === 190 ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer; return grammarErrorOnNode(firstDeclaration.name, diagnostic); } if (firstDeclaration.type) { - var diagnostic = forInOrOfStatement.kind === 188 + var diagnostic = forInOrOfStatement.kind === 190 ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation; return grammarErrorOnNode(firstDeclaration, diagnostic); @@ -19597,10 +19999,10 @@ var ts; else if (accessor.typeParameters) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); } - else if (kind === 137 && accessor.parameters.length) { + else if (kind === 138 && accessor.parameters.length) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); } - else if (kind === 138) { + else if (kind === 139) { if (accessor.type) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); } @@ -19625,7 +20027,7 @@ var ts; } } function checkGrammarForNonSymbolComputedProperty(node, message) { - if (node.kind === 128 && !ts.isWellKnownSymbolSyntactically(node.expression)) { + if (node.kind === 129 && !ts.isWellKnownSymbolSyntactically(node.expression)) { return grammarErrorOnNode(node, message); } } @@ -19635,7 +20037,7 @@ var ts; checkGrammarForGenerator(node)) { return true; } - if (node.parent.kind === 155) { + if (node.parent.kind === 157) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -19643,7 +20045,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 202) { + if (node.parent.kind === 204) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -19654,22 +20056,22 @@ var ts; return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol); } } - else if (node.parent.kind === 203) { + else if (node.parent.kind === 205) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol); } - else if (node.parent.kind === 146) { + else if (node.parent.kind === 148) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol); } } function isIterationStatement(node, lookInLabeledStatements) { switch (node.kind) { + case 189: + case 190: + case 191: case 187: case 188: - case 189: - case 185: - case 186: return true; - case 195: + case 197: return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); } return false; @@ -19681,9 +20083,9 @@ var ts; return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); } switch (current.kind) { - case 195: + case 197: if (node.label && current.label.text === node.label.text) { - var isMisplacedContinueLabel = node.kind === 190 + var isMisplacedContinueLabel = node.kind === 192 && !isIterationStatement(current.statement, true); if (isMisplacedContinueLabel) { return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement); @@ -19691,8 +20093,8 @@ var ts; return false; } break; - case 194: - if (node.kind === 191 && !node.label) { + case 196: + if (node.kind === 193 && !node.label) { return false; } break; @@ -19705,13 +20107,13 @@ var ts; current = current.parent; } if (node.label) { - var message = node.kind === 191 + var message = node.kind === 193 ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); } else { - var message = node.kind === 191 + var message = node.kind === 193 ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); @@ -19723,17 +20125,16 @@ var ts; if (node !== ts.lastOrUndefined(elements)) { return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern); } - if (node.name.kind === 152 || node.name.kind === 151) { + if (node.name.kind === 154 || node.name.kind === 153) { return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern); } if (node.initializer) { return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } } - return checkGrammarEvalOrArgumentsInStrictMode(node, node.name); } function checkGrammarVariableDeclaration(node) { - if (node.parent.parent.kind !== 188 && node.parent.parent.kind !== 189) { + if (node.parent.parent.kind !== 190 && node.parent.parent.kind !== 191) { if (ts.isInAmbientContext(node)) { if (node.initializer) { var equalsTokenLength = "=".length; @@ -19750,8 +20151,7 @@ var ts; } } var checkLetConstNames = languageVersion >= 2 && (ts.isLet(node) || ts.isConst(node)); - return (checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name)) || - checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name); } function checkGrammarNameInLetOrConstDeclarations(name) { if (name.kind === 65) { @@ -19763,7 +20163,7 @@ var ts; var elements = name.elements; for (var _i = 0; _i < elements.length; _i++) { var element = elements[_i]; - if (element.kind !== 176) { + if (element.kind !== 178) { checkGrammarNameInLetOrConstDeclarations(element.name); } } @@ -19780,15 +20180,15 @@ var ts; } function allowLetAndConstDeclarations(parent) { switch (parent.kind) { - case 184: - case 185: case 186: - case 193: case 187: case 188: - case 189: - return false; case 195: + case 189: + case 190: + case 191: + return false; + case 197: return allowLetAndConstDeclarations(parent.parent); } return true; @@ -19804,7 +20204,7 @@ var ts; } } function isIntegerLiteral(expression) { - if (expression.kind === 168) { + if (expression.kind === 170) { var unaryExpression = expression; if (unaryExpression.operator === 33 || unaryExpression.operator === 34) { expression = unaryExpression.operand; @@ -19823,7 +20223,7 @@ var ts; var inAmbientContext = ts.isInAmbientContext(enumDecl); for (var _i = 0, _a = enumDecl.members; _i < _a.length; _i++) { var node = _a[_i]; - if (node.name.kind === 128) { + if (node.name.kind === 129) { hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); } else if (inAmbientContext) { @@ -19865,23 +20265,6 @@ var ts; return true; } } - function checkGrammarEvalOrArgumentsInStrictMode(contextNode, name) { - if (name && name.kind === 65) { - var identifier = name; - if (contextNode && (contextNode.parserContextFlags & 1) && isEvalOrArgumentsIdentifier(identifier)) { - var nameText = ts.declarationNameToString(identifier); - var reportErrorInClassDeclaration = reportStrictModeGrammarErrorInClassDeclaration(identifier, ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode, nameText); - if (!reportErrorInClassDeclaration) { - return grammarErrorOnNode(identifier, ts.Diagnostics.Invalid_use_of_0_in_strict_mode, nameText); - } - return reportErrorInClassDeclaration; - } - } - } - function isEvalOrArgumentsIdentifier(node) { - return node.kind === 65 && - (node.text === "eval" || node.text === "arguments"); - } function checkGrammarConstructorTypeParameters(node) { if (node.typeParameters) { return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration); @@ -19893,18 +20276,18 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 202) { + if (node.parent.kind === 204) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 203) { + else if (node.parent.kind === 205) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 146) { + else if (node.parent.kind === 148) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { return true; } @@ -19914,11 +20297,11 @@ var ts; } } function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { - if (node.kind === 203 || - node.kind === 210 || - node.kind === 209 || - node.kind === 216 || - node.kind === 215 || + if (node.kind === 205 || + node.kind === 212 || + node.kind === 211 || + node.kind === 218 || + node.kind === 217 || (node.flags & 2) || (node.flags & (1 | 256))) { return false; @@ -19928,7 +20311,7 @@ var ts; function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { var decl = _a[_i]; - if (ts.isDeclaration(decl) || decl.kind === 181) { + if (ts.isDeclaration(decl) || decl.kind === 183) { if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { return true; } @@ -19947,7 +20330,7 @@ var ts; if (!links.hasReportedStatementInAmbientContext && ts.isFunctionLike(node.parent)) { return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); } - if (node.parent.kind === 180 || node.parent.kind === 207 || node.parent.kind === 228) { + if (node.parent.kind === 182 || node.parent.kind === 209 || node.parent.kind === 230) { var links_1 = getNodeLinks(node.parent); if (!links_1.hasReportedStatementInAmbientContext) { return links_1.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); @@ -19958,13 +20341,8 @@ var ts; } } function checkGrammarNumericLiteral(node) { - if (node.flags & 16384) { - if (node.parserContextFlags & 1) { - return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode); - } - else if (languageVersion >= 1) { - return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); - } + if (node.flags & 16384 && languageVersion >= 1) { + return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); } } function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) { @@ -19975,8 +20353,6 @@ var ts; return true; } } - initializeTypeChecker(); - return checker; } ts.createTypeChecker = createTypeChecker; })(ts || (ts = {})); @@ -20028,7 +20404,7 @@ var ts; var oldWriter = writer; ts.forEach(moduleElementDeclarationEmitInfo, function (aliasEmitInfo) { if (aliasEmitInfo.isVisible) { - ts.Debug.assert(aliasEmitInfo.node.kind === 210); + ts.Debug.assert(aliasEmitInfo.node.kind === 212); createAndSetNewTextWriterWithSymbolWriter(); ts.Debug.assert(aliasEmitInfo.indent === 0); writeImportDeclaration(aliasEmitInfo.node); @@ -20101,10 +20477,10 @@ var ts; var oldWriter = writer; ts.forEach(nodes, function (declaration) { var nodeToCheck; - if (declaration.kind === 199) { + if (declaration.kind === 201) { nodeToCheck = declaration.parent.parent; } - else if (declaration.kind === 213 || declaration.kind === 214 || declaration.kind === 211) { + else if (declaration.kind === 215 || declaration.kind === 216 || declaration.kind === 213) { ts.Debug.fail("We should be getting ImportDeclaration instead to write"); } else { @@ -20115,7 +20491,7 @@ var ts; moduleElementEmitInfo = ts.forEach(asynchronousSubModuleDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined; }); } if (moduleElementEmitInfo) { - if (moduleElementEmitInfo.node.kind === 210) { + if (moduleElementEmitInfo.node.kind === 212) { moduleElementEmitInfo.isVisible = true; } else { @@ -20123,12 +20499,12 @@ var ts; for (var declarationIndent = moduleElementEmitInfo.indent; declarationIndent; declarationIndent--) { increaseIndent(); } - if (nodeToCheck.kind === 206) { + if (nodeToCheck.kind === 208) { ts.Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined); asynchronousSubModuleDeclarationEmitInfo = []; } writeModuleElement(nodeToCheck); - if (nodeToCheck.kind === 206) { + if (nodeToCheck.kind === 208) { moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo; asynchronousSubModuleDeclarationEmitInfo = undefined; } @@ -20216,39 +20592,39 @@ var ts; function emitType(type) { switch (type.kind) { case 112: - case 122: - case 120: - case 113: case 123: + case 121: + case 113: + case 124: case 99: case 8: return writeTextOfNode(currentSourceFile, type); - case 177: + case 179: return emitExpressionWithTypeArguments(type); - case 142: - return emitTypeReference(type); - case 145: - return emitTypeQuery(type); - case 147: - return emitArrayType(type); - case 148: - return emitTupleType(type); - case 149: - return emitUnionType(type); - case 150: - return emitParenType(type); - case 143: case 144: - return emitSignatureDeclarationWithJsDocComments(type); + return emitTypeReference(type); + case 147: + return emitTypeQuery(type); + case 149: + return emitArrayType(type); + case 150: + return emitTupleType(type); + case 151: + return emitUnionType(type); + case 152: + return emitParenType(type); + case 145: case 146: + return emitSignatureDeclarationWithJsDocComments(type); + case 148: return emitTypeLiteral(type); case 65: return emitEntityName(type); - case 127: + case 128: return emitEntityName(type); } function emitEntityName(entityName) { - var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 209 ? entityName.parent : enclosingDeclaration); + var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 211 ? entityName.parent : enclosingDeclaration); handleSymbolAccessibilityError(visibilityResult); writeEntityName(entityName); function writeEntityName(entityName) { @@ -20256,8 +20632,8 @@ var ts; writeTextOfNode(currentSourceFile, entityName); } else { - var left = entityName.kind === 127 ? entityName.left : entityName.expression; - var right = entityName.kind === 127 ? entityName.right : entityName.name; + var left = entityName.kind === 128 ? entityName.left : entityName.expression; + var right = entityName.kind === 128 ? entityName.right : entityName.name; writeEntityName(left); write("."); writeTextOfNode(currentSourceFile, right); @@ -20266,7 +20642,7 @@ var ts; } function emitExpressionWithTypeArguments(node) { if (ts.isSupportedExpressionWithTypeArguments(node)) { - ts.Debug.assert(node.expression.kind === 65 || node.expression.kind === 156); + ts.Debug.assert(node.expression.kind === 65 || node.expression.kind === 158); emitEntityName(node.expression); if (node.typeArguments) { write("<"); @@ -20327,9 +20703,9 @@ var ts; } var count = 0; while (true) { - var name_18 = baseName + "_" + (++count); - if (!ts.hasProperty(currentSourceFile.identifiers, name_18)) { - return name_18; + var name_16 = baseName + "_" + (++count); + if (!ts.hasProperty(currentSourceFile.identifiers, name_16)) { + return name_16; } } } @@ -20370,10 +20746,10 @@ var ts; if (isModuleElementVisible) { writeModuleElement(node); } - else if (node.kind === 209 || - (node.parent.kind === 228 && ts.isExternalModule(currentSourceFile))) { + else if (node.kind === 211 || + (node.parent.kind === 230 && ts.isExternalModule(currentSourceFile))) { var isVisible; - if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 228) { + if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 230) { asynchronousSubModuleDeclarationEmitInfo.push({ node: node, outputPos: writer.getTextPos(), @@ -20382,7 +20758,7 @@ var ts; }); } else { - if (node.kind === 210) { + if (node.kind === 212) { var importDeclaration = node; if (importDeclaration.importClause) { isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) || @@ -20400,23 +20776,23 @@ var ts; } function writeModuleElement(node) { switch (node.kind) { - case 201: - return writeFunctionDeclaration(node); - case 181: - return writeVariableStatement(node); case 203: - return writeInterfaceDeclaration(node); - case 202: - return writeClassDeclaration(node); - case 204: - return writeTypeAliasDeclaration(node); + return writeFunctionDeclaration(node); + case 183: + return writeVariableStatement(node); case 205: - return writeEnumDeclaration(node); + return writeInterfaceDeclaration(node); + case 204: + return writeClassDeclaration(node); case 206: + return writeTypeAliasDeclaration(node); + case 207: + return writeEnumDeclaration(node); + case 208: return writeModuleDeclaration(node); - case 209: + case 211: return writeImportEqualsDeclaration(node); - case 210: + case 212: return writeImportDeclaration(node); default: ts.Debug.fail("Unknown symbol kind"); @@ -20430,7 +20806,7 @@ var ts; if (node.flags & 256) { write("default "); } - else if (node.kind !== 203) { + else if (node.kind !== 205) { write("declare "); } } @@ -20474,7 +20850,7 @@ var ts; } function isVisibleNamedBinding(namedBindings) { if (namedBindings) { - if (namedBindings.kind === 212) { + if (namedBindings.kind === 214) { return resolver.isDeclarationVisible(namedBindings); } else { @@ -20500,7 +20876,7 @@ var ts; if (currentWriterPos !== writer.getTextPos()) { write(", "); } - if (node.importClause.namedBindings.kind === 212) { + if (node.importClause.namedBindings.kind === 214) { write("* as "); writeTextOfNode(currentSourceFile, node.importClause.namedBindings.name); } @@ -20549,9 +20925,14 @@ var ts; function writeModuleDeclaration(node) { emitJsDocComments(node); emitModuleElementDeclarationFlags(node); - write("module "); + if (node.flags & 32768) { + write("namespace "); + } + else { + write("module "); + } writeTextOfNode(currentSourceFile, node.name); - while (node.body.kind !== 207) { + while (node.body.kind !== 209) { node = node.body; write("."); writeTextOfNode(currentSourceFile, node.name); @@ -20612,7 +20993,7 @@ var ts; writeLine(); } function isPrivateMethodTypeParameter(node) { - return node.parent.kind === 135 && (node.parent.flags & 32); + return node.parent.kind === 136 && (node.parent.flags & 32); } function emitTypeParameters(typeParameters) { function emitTypeParameter(node) { @@ -20622,15 +21003,15 @@ var ts; writeTextOfNode(currentSourceFile, node.name); if (node.constraint && !isPrivateMethodTypeParameter(node)) { write(" extends "); - if (node.parent.kind === 143 || - node.parent.kind === 144 || - (node.parent.parent && node.parent.parent.kind === 146)) { - ts.Debug.assert(node.parent.kind === 135 || - node.parent.kind === 134 || - node.parent.kind === 143 || - node.parent.kind === 144 || - node.parent.kind === 139 || - node.parent.kind === 140); + if (node.parent.kind === 145 || + node.parent.kind === 146 || + (node.parent.parent && node.parent.parent.kind === 148)) { + ts.Debug.assert(node.parent.kind === 136 || + node.parent.kind === 135 || + node.parent.kind === 145 || + node.parent.kind === 146 || + node.parent.kind === 140 || + node.parent.kind === 141); emitType(node.constraint); } else { @@ -20640,31 +21021,31 @@ var ts; function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.parent.kind) { - case 202: + case 204: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; break; - case 203: + case 205: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; break; - case 140: + case 141: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 139: + case 140: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; break; + case 136: case 135: - case 134: if (node.parent.flags & 128) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202) { + else if (node.parent.parent.kind === 204) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } break; - case 201: + case 203: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -20694,7 +21075,7 @@ var ts; } function getHeritageClauseVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (node.parent.parent.kind === 202) { + if (node.parent.parent.kind === 204) { diagnosticMessage = isImplementsList ? ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : ts.Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1; @@ -20771,16 +21152,16 @@ var ts; writeLine(); } function emitVariableDeclaration(node) { - if (node.kind !== 199 || resolver.isDeclarationVisible(node)) { + if (node.kind !== 201 || resolver.isDeclarationVisible(node)) { if (ts.isBindingPattern(node.name)) { emitBindingPattern(node.name); } else { writeTextOfNode(currentSourceFile, node.name); - if ((node.kind === 133 || node.kind === 132) && ts.hasQuestionToken(node)) { + if ((node.kind === 134 || node.kind === 133) && ts.hasQuestionToken(node)) { write("?"); } - if ((node.kind === 133 || node.kind === 132) && node.parent.kind === 146) { + if ((node.kind === 134 || node.kind === 133) && node.parent.kind === 148) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.flags & 32)) { @@ -20789,14 +21170,14 @@ var ts; } } function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { - if (node.kind === 199) { + if (node.kind === 201) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1; } - else if (node.kind === 133 || node.kind === 132) { + else if (node.kind === 134 || node.kind === 133) { if (node.flags & 128) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? @@ -20804,7 +21185,7 @@ var ts; ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.kind === 202) { + else if (node.parent.kind === 204) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -20830,7 +21211,7 @@ var ts; var elements = []; for (var _i = 0, _a = bindingPattern.elements; _i < _a.length; _i++) { var element = _a[_i]; - if (element.kind !== 176) { + if (element.kind !== 178) { elements.push(element); } } @@ -20896,7 +21277,7 @@ var ts; accessorWithTypeAnnotation = node; var type = getTypeAnnotationFromAccessor(node); if (!type) { - var anotherAccessor = node.kind === 137 ? accessors.setAccessor : accessors.getAccessor; + var anotherAccessor = node.kind === 138 ? accessors.setAccessor : accessors.getAccessor; type = getTypeAnnotationFromAccessor(anotherAccessor); if (type) { accessorWithTypeAnnotation = anotherAccessor; @@ -20909,7 +21290,7 @@ var ts; } function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 137 + return accessor.kind === 138 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type @@ -20918,7 +21299,7 @@ var ts; } function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (accessorWithTypeAnnotation.kind === 138) { + if (accessorWithTypeAnnotation.kind === 139) { if (accessorWithTypeAnnotation.parent.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 : @@ -20964,17 +21345,17 @@ var ts; } if (!resolver.isImplementationOfOverload(node)) { emitJsDocComments(node); - if (node.kind === 201) { + if (node.kind === 203) { emitModuleElementDeclarationFlags(node); } - else if (node.kind === 135) { + else if (node.kind === 136) { emitClassMemberDeclarationFlags(node); } - if (node.kind === 201) { + if (node.kind === 203) { write("function "); writeTextOfNode(currentSourceFile, node.name); } - else if (node.kind === 136) { + else if (node.kind === 137) { write("constructor"); } else { @@ -20991,11 +21372,11 @@ var ts; emitSignatureDeclaration(node); } function emitSignatureDeclaration(node) { - if (node.kind === 140 || node.kind === 144) { + if (node.kind === 141 || node.kind === 146) { write("new "); } emitTypeParameters(node.typeParameters); - if (node.kind === 141) { + if (node.kind === 142) { write("["); } else { @@ -21004,20 +21385,20 @@ var ts; var prevEnclosingDeclaration = enclosingDeclaration; enclosingDeclaration = node; emitCommaList(node.parameters, emitParameterDeclaration); - if (node.kind === 141) { + if (node.kind === 142) { write("]"); } else { write(")"); } - var isFunctionTypeOrConstructorType = node.kind === 143 || node.kind === 144; - if (isFunctionTypeOrConstructorType || node.parent.kind === 146) { + var isFunctionTypeOrConstructorType = node.kind === 145 || node.kind === 146; + if (isFunctionTypeOrConstructorType || node.parent.kind === 148) { if (node.type) { write(isFunctionTypeOrConstructorType ? " => " : ": "); emitType(node.type); } } - else if (node.kind !== 136 && !(node.flags & 32)) { + else if (node.kind !== 137 && !(node.flags & 32)) { writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); } enclosingDeclaration = prevEnclosingDeclaration; @@ -21028,23 +21409,23 @@ var ts; function getReturnTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.kind) { - case 140: + case 141: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 139: + case 140: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 141: + case 142: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0; break; + case 136: case 135: - case 134: if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? @@ -21052,7 +21433,7 @@ var ts; ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0; } - else if (node.parent.kind === 202) { + else if (node.parent.kind === 204) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : @@ -21065,7 +21446,7 @@ var ts; ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; } break; - case 201: + case 203: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : @@ -21097,9 +21478,9 @@ var ts; write("?"); } decreaseIndent(); - if (node.parent.kind === 143 || - node.parent.kind === 144 || - node.parent.parent.kind === 146) { + if (node.parent.kind === 145 || + node.parent.kind === 146 || + node.parent.parent.kind === 148) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.parent.flags & 32)) { @@ -21115,22 +21496,22 @@ var ts; } function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { switch (node.parent.kind) { - case 136: + case 137: return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1; - case 140: + case 141: return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; - case 139: + case 140: return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + case 136: case 135: - case 134: if (node.parent.flags & 128) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? @@ -21138,7 +21519,7 @@ var ts; ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202) { + else if (node.parent.parent.kind === 204) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -21150,7 +21531,7 @@ var ts; ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } - case 201: + case 203: return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -21161,12 +21542,12 @@ var ts; } } function emitBindingPattern(bindingPattern) { - if (bindingPattern.kind === 151) { + if (bindingPattern.kind === 153) { write("{"); emitCommaList(bindingPattern.elements, emitBindingElement); write("}"); } - else if (bindingPattern.kind === 152) { + else if (bindingPattern.kind === 154) { write("["); var elements = bindingPattern.elements; emitCommaList(elements, emitBindingElement); @@ -21185,10 +21566,10 @@ var ts; typeName: bindingElement.name } : undefined; } - if (bindingElement.kind === 176) { + if (bindingElement.kind === 178) { write(" "); } - else if (bindingElement.kind === 153) { + else if (bindingElement.kind === 155) { if (bindingElement.propertyName) { writeTextOfNode(currentSourceFile, bindingElement.propertyName); write(": "); @@ -21211,39 +21592,39 @@ var ts; } function emitNode(node) { switch (node.kind) { - case 201: - case 206: - case 209: case 203: - case 202: - case 204: + case 208: + case 211: case 205: + case 204: + case 206: + case 207: return emitModuleElement(node, isModuleElementVisible(node)); - case 181: + case 183: return emitModuleElement(node, isVariableStatementVisible(node)); - case 210: + case 212: return emitModuleElement(node, !node.importClause); - case 216: + case 218: return emitExportDeclaration(node); + case 137: case 136: case 135: - case 134: return writeFunctionDeclaration(node); - case 140: - case 139: case 141: + case 140: + case 142: return emitSignatureDeclarationWithJsDocComments(node); - case 137: case 138: + case 139: return emitAccessorDeclaration(node); + case 134: case 133: - case 132: return emitPropertyDeclaration(node); - case 227: + case 229: return emitEnumMemberDeclaration(node); - case 215: + case 217: return emitExportAssignment(node); - case 228: + case 230: return emitSourceFile(node); } } @@ -21289,7 +21670,7 @@ var ts; } ts.isExternalModuleOrDeclarationFile = isExternalModuleOrDeclarationFile; function emitFiles(resolver, host, targetSourceFile) { - var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n __.prototype = b.prototype;\n d.prototype = new __();\n};"; + var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};"; var decorateHelper = "\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") return Reflect.decorate(decorators, target, key, desc);\n switch (arguments.length) {\n case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);\n case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);\n case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);\n }\n};"; var metadataHelper = "\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};"; var paramHelper = "\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); }\n};"; @@ -21353,7 +21734,6 @@ var ts; var exportFunctionForFile; var generatedNameSet = {}; var nodeToGeneratedName = []; - var blockScopedVariableToGeneratedName; var computedPropertyNamesToGeneratedNames; var extendsEmitted = false; var decorateEmitted = false; @@ -21413,9 +21793,9 @@ var ts; var count = tempFlags & 268435455; tempFlags++; if (count !== 8 && count !== 13) { - var name_19 = count < 26 ? "_" + String.fromCharCode(97 + count) : "_" + (count - 26); - if (isUniqueName(name_19)) { - return name_19; + var name_17 = count < 26 ? "_" + String.fromCharCode(97 + count) : "_" + (count - 26); + if (isUniqueName(name_17)) { + return name_17; } } } @@ -21433,72 +21813,39 @@ var ts; i++; } } - function assignGeneratedName(node, name) { - nodeToGeneratedName[ts.getNodeId(node)] = ts.unescapeIdentifier(name); - } - function generateNameForFunctionOrClassDeclaration(node) { - if (!node.name) { - assignGeneratedName(node, makeUniqueName("default")); - } - } function generateNameForModuleOrEnum(node) { - if (node.name.kind === 65) { - var name_20 = node.name.text; - assignGeneratedName(node, isUniqueLocalName(name_20, node) ? name_20 : makeUniqueName(name_20)); - } + var name = node.name.text; + return isUniqueLocalName(name, node) ? name : makeUniqueName(name); } function generateNameForImportOrExportDeclaration(node) { var expr = ts.getExternalModuleName(node); var baseName = expr.kind === 8 ? ts.escapeIdentifier(ts.makeIdentifierFromModuleName(expr.text)) : "module"; - assignGeneratedName(node, makeUniqueName(baseName)); + return makeUniqueName(baseName); } - function generateNameForImportDeclaration(node) { - if (node.importClause) { - generateNameForImportOrExportDeclaration(node); - } - } - function generateNameForExportDeclaration(node) { - if (node.moduleSpecifier) { - generateNameForImportOrExportDeclaration(node); - } - } - function generateNameForExportAssignment(node) { - if (node.expression && node.expression.kind !== 65) { - assignGeneratedName(node, makeUniqueName("default")); - } + function generateNameForExportDefault() { + return makeUniqueName("default"); } function generateNameForNode(node) { switch (node.kind) { - case 201: - case 202: - case 175: - generateNameForFunctionOrClassDeclaration(node); - break; - case 206: - generateNameForModuleOrEnum(node); - generateNameForNode(node.body); - break; - case 205: - generateNameForModuleOrEnum(node); - break; - case 210: - generateNameForImportDeclaration(node); - break; - case 216: - generateNameForExportDeclaration(node); - break; - case 215: - generateNameForExportAssignment(node); - break; + case 65: + return makeUniqueName(node.text); + case 208: + case 207: + return generateNameForModuleOrEnum(node); + case 212: + case 218: + return generateNameForImportOrExportDeclaration(node); + case 203: + case 204: + case 177: + case 217: + return generateNameForExportDefault(); } } function getGeneratedNameForNode(node) { - var nodeId = ts.getNodeId(node); - if (!nodeToGeneratedName[nodeId]) { - generateNameForNode(node); - } - return nodeToGeneratedName[nodeId]; + var id = ts.getNodeId(node); + return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = ts.unescapeIdentifier(generateNameForNode(node))); } function initializeEmitterWithSourceMaps() { var sourceMapDir; @@ -21522,7 +21869,7 @@ var ts; return; } var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; - if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) { + if (lastEncodedSourceMapSpan.emittedLine === lastRecordedSourceMapSpan.emittedLine) { if (sourceMapData.sourceMapMappings) { sourceMapData.sourceMapMappings += ","; } @@ -21575,8 +21922,8 @@ var ts; var emittedLine = writer.getLine(); var emittedColumn = writer.getColumn(); if (!lastRecordedSourceMapSpan || - lastRecordedSourceMapSpan.emittedLine != emittedLine || - lastRecordedSourceMapSpan.emittedColumn != emittedColumn || + lastRecordedSourceMapSpan.emittedLine !== emittedLine || + lastRecordedSourceMapSpan.emittedColumn !== emittedColumn || (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex && (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line || (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) { @@ -21630,8 +21977,8 @@ var ts; if (scopeName) { var parentIndex = getSourceMapNameIndex(); if (parentIndex !== -1) { - var name_21 = node.name; - if (!name_21 || name_21.kind !== 128) { + var name_18 = node.name; + if (!name_18 || name_18.kind !== 129) { scopeName = "." + scopeName; } scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; @@ -21648,19 +21995,19 @@ var ts; if (scopeName) { recordScopeNameStart(scopeName); } - else if (node.kind === 201 || - node.kind === 163 || + else if (node.kind === 203 || + node.kind === 165 || + node.kind === 136 || node.kind === 135 || - node.kind === 134 || - node.kind === 137 || node.kind === 138 || - node.kind === 206 || - node.kind === 202 || - node.kind === 205) { + node.kind === 139 || + node.kind === 208 || + node.kind === 204 || + node.kind === 207) { if (node.name) { - var name_22 = node.name; - scopeName = name_22.kind === 128 - ? ts.getTextOfNode(name_22) + var name_19 = node.name; + scopeName = name_19.kind === 129 + ? ts.getTextOfNode(name_19) : node.name.text; } recordScopeNameStart(scopeName); @@ -21753,19 +22100,19 @@ var ts; else { sourceMapDir = ts.getDirectoryPath(ts.normalizePath(jsFilePath)); } - function emitNodeWithSourceMap(node, allowGeneratedIdentifiers) { + function emitNodeWithSourceMap(node) { if (node) { if (ts.nodeIsSynthesized(node)) { - return emitNodeWithoutSourceMap(node, false); + return emitNodeWithoutSourceMap(node); } - if (node.kind != 228) { + if (node.kind !== 230) { recordEmitNodeStartSpan(node); - emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers); + emitNodeWithoutSourceMap(node); recordEmitNodeEndSpan(node); } else { recordNewSourceFileStart(node); - emitNodeWithoutSourceMap(node, false); + emitNodeWithoutSourceMap(node); } } } @@ -22003,10 +22350,10 @@ var ts; emitParenthesizedIf(node.tag, needsParenthesisForPropertyAccessOrInvocation(node.tag)); write("("); emit(tempVariable); - if (node.template.kind === 172) { + if (node.template.kind === 174) { ts.forEach(node.template.templateSpans, function (templateSpan) { write(", "); - var needsParens = templateSpan.expression.kind === 170 + var needsParens = templateSpan.expression.kind === 172 && templateSpan.expression.operatorToken.kind === 23; emitParenthesizedIf(templateSpan.expression, needsParens); }); @@ -22030,7 +22377,7 @@ var ts; } for (var i = 0, n = node.templateSpans.length; i < n; i++) { var templateSpan = node.templateSpans[i]; - var needsParens = templateSpan.expression.kind !== 162 + var needsParens = templateSpan.expression.kind !== 164 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; if (i > 0 || headEmitted) { write(" + "); @@ -22063,11 +22410,11 @@ var ts; } function templateNeedsParens(template, parent) { switch (parent.kind) { - case 158: - case 159: - return parent.expression === template; case 160: + case 161: + return parent.expression === template; case 162: + case 164: return false; default: return comparePrecedenceToBinaryPlus(parent) !== -1; @@ -22075,7 +22422,7 @@ var ts; } function comparePrecedenceToBinaryPlus(expression) { switch (expression.kind) { - case 170: + case 172: switch (expression.operatorToken.kind) { case 35: case 36: @@ -22087,8 +22434,8 @@ var ts; default: return -1; } + case 175: case 173: - case 171: return -1; default: return 1; @@ -22100,11 +22447,11 @@ var ts; emit(span.literal); } function emitExpressionForPropertyName(node) { - ts.Debug.assert(node.kind !== 153); + ts.Debug.assert(node.kind !== 155); if (node.kind === 8) { emitLiteral(node); } - else if (node.kind === 128) { + else if (node.kind === 129) { if (ts.nodeIsDecorated(node.parent)) { if (!computedPropertyNamesToGeneratedNames) { computedPropertyNamesToGeneratedNames = []; @@ -22132,75 +22479,122 @@ var ts; write("\""); } } - function isNotExpressionIdentifier(node) { + function isExpressionIdentifier(node) { var parent = node.parent; switch (parent.kind) { - case 130: - case 199: - case 153: - case 133: + case 156: + case 172: + case 160: + case 223: + case 129: + case 173: case 132: - case 225: - case 226: + case 167: + case 187: + case 159: + case 217: + case 185: + case 179: + case 189: + case 190: + case 191: + case 186: + case 161: + case 164: + case 171: + case 170: + case 194: + case 228: + case 176: + case 196: + case 162: + case 180: + case 198: + case 163: + case 168: + case 169: + case 188: + case 195: + case 175: + return true; + case 155: + case 229: + case 131: case 227: - case 135: case 134: case 201: - case 137: - case 138: - case 163: - case 202: - case 203: - case 205: - case 206: - case 209: + return parent.initializer === node; + case 158: + return parent.expression === node; + case 166: + case 165: + return parent.body === node; case 211: - case 212: - return parent.name === node; - case 214: - case 218: - return parent.name === node || parent.propertyName === node; - case 191: - case 190: - case 215: - return false; - case 195: - return node.parent.label === node; + return parent.moduleReference === node; + case 128: + return parent.left === node; } + return false; } function emitExpressionIdentifier(node) { - var substitution = resolver.getExpressionNameSubstitution(node, getGeneratedNameForNode); - if (substitution) { - write(substitution); + var container = resolver.getReferencedExportContainer(node); + if (container) { + if (container.kind === 230) { + if (languageVersion < 2 && compilerOptions.module !== 4) { + write("exports."); + } + } + else { + write(getGeneratedNameForNode(container)); + write("."); + } } - else { - writeTextOfNode(currentSourceFile, node); - } - } - function getGeneratedNameForIdentifier(node) { - if (ts.nodeIsSynthesized(node) || !blockScopedVariableToGeneratedName) { - return undefined; - } - var variableId = resolver.getBlockScopedVariableId(node); - if (variableId === undefined) { - return undefined; - } - return blockScopedVariableToGeneratedName[variableId]; - } - function emitIdentifier(node, allowGeneratedIdentifiers) { - if (allowGeneratedIdentifiers) { - var generatedName = getGeneratedNameForIdentifier(node); - if (generatedName) { - write(generatedName); + else if (languageVersion < 2) { + var declaration = resolver.getReferencedImportDeclaration(node); + if (declaration) { + if (declaration.kind === 213) { + write(getGeneratedNameForNode(declaration.parent)); + write(languageVersion === 0 ? '["default"]' : ".default"); + return; + } + else if (declaration.kind === 216) { + write(getGeneratedNameForNode(declaration.parent.parent.parent)); + write("."); + writeTextOfNode(currentSourceFile, declaration.propertyName || declaration.name); + return; + } + } + declaration = resolver.getReferencedNestedRedeclaration(node); + if (declaration) { + write(getGeneratedNameForNode(declaration.name)); return; } } + writeTextOfNode(currentSourceFile, node); + } + function isNameOfNestedRedeclaration(node) { + if (languageVersion < 2) { + var parent_7 = node.parent; + switch (parent_7.kind) { + case 155: + case 204: + case 207: + case 201: + return parent_7.name === node && resolver.isNestedRedeclaration(parent_7); + } + } + return false; + } + function emitIdentifier(node) { if (!node.parent) { write(node.text); } - else if (!isNotExpressionIdentifier(node)) { + else if (isExpressionIdentifier(node)) { emitExpressionIdentifier(node); } + else if (isNameOfNestedRedeclaration(node)) { + write(getGeneratedNameForNode(node)); + } else { writeTextOfNode(currentSourceFile, node); } @@ -22241,7 +22635,7 @@ var ts; } function emitBindingElement(node) { if (node.propertyName) { - emit(node.propertyName, false); + emit(node.propertyName); write(": "); } if (node.dotDotDotToken) { @@ -22272,11 +22666,11 @@ var ts; function needsParenthesisForPropertyAccessOrInvocation(node) { switch (node.kind) { case 65: - case 154: case 156: - case 157: case 158: - case 162: + case 159: + case 160: + case 164: return false; } return true; @@ -22293,17 +22687,17 @@ var ts; write(", "); } var e = elements[pos]; - if (e.kind === 174) { + if (e.kind === 176) { e = e.expression; emitParenthesizedIf(e, group === 0 && needsParenthesisForPropertyAccessOrInvocation(e)); pos++; - if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 154) { + if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 156) { write(".slice()"); } } else { var i = pos; - while (i < length && elements[i].kind !== 174) { + while (i < length && elements[i].kind !== 176) { i++; } write("["); @@ -22326,7 +22720,7 @@ var ts; } } function isSpreadElementExpression(node) { - return node.kind === 174; + return node.kind === 176; } function emitArrayLiteral(node) { var elements = node.elements; @@ -22387,7 +22781,7 @@ var ts; writeComma(); var property = properties[i]; emitStart(property); - if (property.kind === 137 || property.kind === 138) { + if (property.kind === 138 || property.kind === 139) { var accessors = ts.getAllAccessorDeclarations(node.properties, property); if (property !== accessors.firstAccessor) { continue; @@ -22438,13 +22832,13 @@ var ts; emitMemberAccessForPropertyName(property.name); emitEnd(property.name); write(" = "); - if (property.kind === 225) { + if (property.kind === 227) { emit(property.initializer); } - else if (property.kind === 226) { + else if (property.kind === 228) { emitExpressionIdentifier(property.name); } - else if (property.kind === 135) { + else if (property.kind === 136) { emitFunctionDeclaration(property); } else { @@ -22476,7 +22870,7 @@ var ts; var numProperties = properties.length; var numInitialNonComputedProperties = numProperties; for (var i = 0, n = properties.length; i < n; i++) { - if (properties[i].name.kind === 128) { + if (properties[i].name.kind === 129) { numInitialNonComputedProperties = i; break; } @@ -22490,35 +22884,35 @@ var ts; emitObjectLiteralBody(node, properties.length); } function createBinaryExpression(left, operator, right, startsOnNewLine) { - var result = ts.createSynthesizedNode(170, startsOnNewLine); + var result = ts.createSynthesizedNode(172, startsOnNewLine); result.operatorToken = ts.createSynthesizedNode(operator); result.left = left; result.right = right; return result; } function createPropertyAccessExpression(expression, name) { - var result = ts.createSynthesizedNode(156); + var result = ts.createSynthesizedNode(158); result.expression = parenthesizeForAccess(expression); result.dotToken = ts.createSynthesizedNode(20); result.name = name; return result; } function createElementAccessExpression(expression, argumentExpression) { - var result = ts.createSynthesizedNode(157); + var result = ts.createSynthesizedNode(159); result.expression = parenthesizeForAccess(expression); result.argumentExpression = argumentExpression; return result; } function parenthesizeForAccess(expr) { - while (expr.kind === 161) { + while (expr.kind === 163) { expr = expr.expression; } if (ts.isLeftHandSideExpression(expr) && - expr.kind !== 159 && + expr.kind !== 161 && expr.kind !== 7) { return expr; } - var node = ts.createSynthesizedNode(162); + var node = ts.createSynthesizedNode(164); node.expression = expr; return node; } @@ -22531,32 +22925,26 @@ var ts; if (languageVersion >= 2 && node.asteriskToken) { write("*"); } - emit(node.name, false); + emit(node.name); if (languageVersion < 2) { write(": function "); } emitSignatureAndBody(node); } function emitPropertyAssignment(node) { - emit(node.name, false); + emit(node.name); write(": "); emit(node.initializer); } + function isNamespaceExportReference(node) { + var container = resolver.getReferencedExportContainer(node); + return container && container.kind !== 230; + } function emitShorthandPropertyAssignment(node) { - emit(node.name, false); - if (languageVersion < 2) { + writeTextOfNode(currentSourceFile, node.name); + if (languageVersion < 2 || isNamespaceExportReference(node.name)) { write(": "); - var generatedName = getGeneratedNameForIdentifier(node.name); - if (generatedName) { - write(generatedName); - } - else { - emitExpressionIdentifier(node.name); - } - } - else if (resolver.getExpressionNameSubstitution(node.name, getGeneratedNameForNode)) { - write(": "); - emitExpressionIdentifier(node.name); + emit(node.name); } } function tryEmitConstantValue(node) { @@ -22567,7 +22955,7 @@ var ts; if (constantValue !== undefined) { write(constantValue.toString()); if (!compilerOptions.removeComments) { - var propertyName = node.kind === 156 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + var propertyName = node.kind === 158 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); write(" /* " + propertyName + " */"); } return true; @@ -22597,7 +22985,7 @@ var ts; var indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, node.dotToken); write("."); var indentedAfterDot = indentIfOnDifferentLines(node, node.dotToken, node.name); - emit(node.name, false); + emit(node.name); decreaseIndentIf(indentedBeforeDot, indentedAfterDot); } function emitQualifiedName(node) { @@ -22615,10 +23003,10 @@ var ts; write("]"); } function hasSpreadElement(elements) { - return ts.forEach(elements, function (e) { return e.kind === 174; }); + return ts.forEach(elements, function (e) { return e.kind === 176; }); } function skipParentheses(node) { - while (node.kind === 162 || node.kind === 161) { + while (node.kind === 164 || node.kind === 163) { node = node.expression; } return node; @@ -22639,12 +23027,12 @@ var ts; function emitCallWithSpread(node) { var target; var expr = skipParentheses(node.expression); - if (expr.kind === 156) { + if (expr.kind === 158) { target = emitCallTarget(expr.expression); write("."); emit(expr.name); } - else if (expr.kind === 157) { + else if (expr.kind === 159) { target = emitCallTarget(expr.expression); write("["); emit(expr.argumentExpression); @@ -22685,7 +23073,7 @@ var ts; } else { emit(node.expression); - superCall = node.expression.kind === 156 && node.expression.expression.kind === 91; + superCall = node.expression.kind === 158 && node.expression.expression.kind === 91; } if (superCall && languageVersion < 2) { write(".call("); @@ -22736,20 +23124,20 @@ var ts; } } function emitParenExpression(node) { - if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 164) { - if (node.expression.kind === 161) { + if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 166) { + if (node.expression.kind === 163) { var operand = node.expression.expression; - while (operand.kind == 161) { + while (operand.kind === 163) { operand = operand.expression; } - if (operand.kind !== 168 && - operand.kind !== 167 && - operand.kind !== 166 && - operand.kind !== 165 && + if (operand.kind !== 170 && operand.kind !== 169 && - operand.kind !== 159 && - !(operand.kind === 158 && node.parent.kind === 159) && - !(operand.kind === 163 && node.parent.kind === 158)) { + operand.kind !== 168 && + operand.kind !== 167 && + operand.kind !== 171 && + operand.kind !== 161 && + !(operand.kind === 160 && node.parent.kind === 161) && + !(operand.kind === 165 && node.parent.kind === 160)) { emit(operand); return; } @@ -22778,7 +23166,7 @@ var ts; if (!isCurrentFileSystemExternalModule() || node.kind !== 65 || ts.nodeIsSynthesized(node)) { return false; } - var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 199 || node.parent.kind === 153); + var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 201 || node.parent.kind === 155); var targetDeclaration = isVariableDeclarationOrBindingElement ? node.parent : resolver.getReferencedValueDeclaration(node); @@ -22792,7 +23180,7 @@ var ts; write("\", "); } write(ts.tokenToString(node.operator)); - if (node.operand.kind === 168) { + if (node.operand.kind === 170) { var operand = node.operand; if (node.operator === 33 && (operand.operator === 33 || operand.operator === 38)) { write(" "); @@ -22835,10 +23223,10 @@ var ts; } var current = node; while (current) { - if (current.kind === 228) { + if (current.kind === 230) { return !isExported || ((ts.getCombinedNodeFlags(node) & 1) !== 0); } - else if (ts.isFunctionLike(current) || current.kind === 207) { + else if (ts.isFunctionLike(current) || current.kind === 209) { return false; } else { @@ -22848,8 +23236,8 @@ var ts; } function emitBinaryExpression(node) { if (languageVersion < 2 && node.operatorToken.kind === 53 && - (node.left.kind === 155 || node.left.kind === 154)) { - emitDestructuring(node, node.parent.kind === 183); + (node.left.kind === 157 || node.left.kind === 156)) { + emitDestructuring(node, node.parent.kind === 185); } else { var exportChanged = node.operatorToken.kind >= 53 && @@ -22896,7 +23284,7 @@ var ts; } } function isSingleLineEmptyBlock(node) { - if (node && node.kind === 180) { + if (node && node.kind === 182) { var block = node; return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); } @@ -22911,12 +23299,12 @@ var ts; emitToken(14, node.pos); increaseIndent(); scopeEmitStart(node.parent); - if (node.kind === 207) { - ts.Debug.assert(node.parent.kind === 206); + if (node.kind === 209) { + ts.Debug.assert(node.parent.kind === 208); emitCaptureThisForNodeIfNecessary(node.parent); } emitLines(node.statements); - if (node.kind === 207) { + if (node.kind === 209) { emitTempDeclarations(true); } decreaseIndent(); @@ -22925,7 +23313,7 @@ var ts; scopeEmitEnd(); } function emitEmbeddedStatement(node) { - if (node.kind === 180) { + if (node.kind === 182) { write(" "); emit(node); } @@ -22937,7 +23325,7 @@ var ts; } } function emitExpressionStatement(node) { - emitParenthesizedIf(node.expression, node.expression.kind === 164); + emitParenthesizedIf(node.expression, node.expression.kind === 166); write(";"); } function emitIfStatement(node) { @@ -22950,7 +23338,7 @@ var ts; if (node.elseStatement) { writeLine(); emitToken(76, node.thenStatement.end); - if (node.elseStatement.kind === 184) { + if (node.elseStatement.kind === 186) { write(" "); emit(node.elseStatement); } @@ -22962,7 +23350,7 @@ var ts; function emitDoStatement(node) { write("do"); emitEmbeddedStatement(node.statement); - if (node.statement.kind === 180) { + if (node.statement.kind === 182) { write(" "); } else { @@ -23031,7 +23419,7 @@ var ts; var endPos = emitToken(82, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer && node.initializer.kind === 200) { + if (node.initializer && node.initializer.kind === 202) { var variableDeclarationList = node.initializer; var startIsEmitted = tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); if (startIsEmitted) { @@ -23052,13 +23440,13 @@ var ts; emitEmbeddedStatement(node.statement); } function emitForInOrForOfStatement(node) { - if (languageVersion < 2 && node.kind === 189) { + if (languageVersion < 2 && node.kind === 191) { return emitDownLevelForOfStatement(node); } var endPos = emitToken(82, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); @@ -23068,7 +23456,7 @@ var ts; else { emit(node.initializer); } - if (node.kind === 188) { + if (node.kind === 190) { write(" in "); } else { @@ -23136,7 +23524,7 @@ var ts; increaseIndent(); var rhsIterationValue = createElementAccessExpression(rhsReference, counter); emitStart(node.initializer); - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { write("var "); var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length > 0) { @@ -23158,7 +23546,7 @@ var ts; } else { var assignmentExpression = createBinaryExpression(node.initializer, 53, rhsIterationValue, false); - if (node.initializer.kind === 154 || node.initializer.kind === 155) { + if (node.initializer.kind === 156 || node.initializer.kind === 157) { emitDestructuring(assignmentExpression, true, undefined); } else { @@ -23167,7 +23555,7 @@ var ts; } emitEnd(node.initializer); write(";"); - if (node.statement.kind === 180) { + if (node.statement.kind === 182) { emitLines(node.statement.statements); } else { @@ -23179,7 +23567,7 @@ var ts; write("}"); } function emitBreakOrContinueStatement(node) { - emitToken(node.kind === 191 ? 66 : 71, node.pos); + emitToken(node.kind === 193 ? 66 : 71, node.pos); emitOptional(" ", node.label); write(";"); } @@ -23224,7 +23612,7 @@ var ts; ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); } function emitCaseOrDefaultClause(node) { - if (node.kind === 221) { + if (node.kind === 223) { write("case "); emit(node.expression); write(":"); @@ -23279,7 +23667,7 @@ var ts; function getContainingModule(node) { do { node = node.parent; - } while (node && node.kind !== 206); + } while (node && node.kind !== 208); return node; } function emitContainingModuleName(node) { @@ -23304,7 +23692,7 @@ var ts; function createVoidZero() { var zero = ts.createSynthesizedNode(7); zero.text = "0"; - var result = ts.createSynthesizedNode(167); + var result = ts.createSynthesizedNode(169); result.expression = zero; return result; } @@ -23373,15 +23761,15 @@ var ts; function emitDestructuring(root, isAssignmentExpressionStatement, value) { var emitCount = 0; var canDefineTempVariablesInPlace = false; - if (root.kind === 199) { + if (root.kind === 201) { var isExported = ts.getCombinedNodeFlags(root) & 1; var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root); canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind; } - else if (root.kind === 130) { + else if (root.kind === 131) { canDefineTempVariablesInPlace = true; } - if (root.kind === 170) { + if (root.kind === 172) { emitAssignmentExpression(root); } else { @@ -23392,8 +23780,7 @@ var ts; if (emitCount++) { write(", "); } - renameNonTopLevelLetAndConst(name); - var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 199 || name.parent.kind === 153); + var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 201 || name.parent.kind === 155); var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name); if (exportChanged) { write(exportFunctionForFile + "(\""); @@ -23425,14 +23812,14 @@ var ts; } function createDefaultValueCheck(value, defaultValue) { value = ensureIdentifier(value); - var equals = ts.createSynthesizedNode(170); + var equals = ts.createSynthesizedNode(172); equals.left = value; equals.operatorToken = ts.createSynthesizedNode(30); equals.right = createVoidZero(); return createConditionalExpression(equals, defaultValue, value); } function createConditionalExpression(condition, whenTrue, whenFalse) { - var cond = ts.createSynthesizedNode(171); + var cond = ts.createSynthesizedNode(173); cond.condition = condition; cond.questionToken = ts.createSynthesizedNode(50); cond.whenTrue = whenTrue; @@ -23446,13 +23833,15 @@ var ts; return node; } function createPropertyAccessForDestructuringProperty(object, propName) { - if (propName.kind !== 65) { - return createElementAccessExpression(object, propName); + var syntheticName = ts.createSynthesizedNode(propName.kind); + syntheticName.text = propName.text; + if (syntheticName.kind !== 65) { + return createElementAccessExpression(object, syntheticName); } - return createPropertyAccessExpression(object, propName); + return createPropertyAccessExpression(object, syntheticName); } function createSliceCall(value, sliceIndex) { - var call = ts.createSynthesizedNode(158); + var call = ts.createSynthesizedNode(160); var sliceIdentifier = ts.createSynthesizedNode(65); sliceIdentifier.text = "slice"; call.expression = createPropertyAccessExpression(value, sliceIdentifier); @@ -23467,8 +23856,8 @@ var ts; } for (var _a = 0; _a < properties.length; _a++) { var p = properties[_a]; - if (p.kind === 225 || p.kind === 226) { - var propName = (p.name); + if (p.kind === 227 || p.kind === 228) { + var propName = p.name; emitDestructuringAssignment(p.initializer || propName, createPropertyAccessForDestructuringProperty(value, propName)); } } @@ -23480,8 +23869,8 @@ var ts; } for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176) { - if (e.kind !== 174) { + if (e.kind !== 178) { + if (e.kind !== 176) { emitDestructuringAssignment(e, createElementAccessExpression(value, createNumericLiteral(i))); } else if (i === elements.length - 1) { @@ -23491,14 +23880,14 @@ var ts; } } function emitDestructuringAssignment(target, value) { - if (target.kind === 170 && target.operatorToken.kind === 53) { + if (target.kind === 172 && target.operatorToken.kind === 53) { value = createDefaultValueCheck(value, target.right); target = target.left; } - if (target.kind === 155) { + if (target.kind === 157) { emitObjectLiteralAssignment(target, value); } - else if (target.kind === 154) { + else if (target.kind === 156) { emitArrayLiteralAssignment(target, value); } else { @@ -23512,14 +23901,14 @@ var ts; emitDestructuringAssignment(target, value); } else { - if (root.parent.kind !== 162) { + if (root.parent.kind !== 164) { write("("); } value = ensureIdentifier(value); emitDestructuringAssignment(target, value); write(", "); emit(value); - if (root.parent.kind !== 162) { + if (root.parent.kind !== 164) { write(")"); } } @@ -23539,11 +23928,11 @@ var ts; } for (var i = 0; i < elements.length; i++) { var element = elements[i]; - if (pattern.kind === 151) { + if (pattern.kind === 153) { var propName = element.propertyName || element.name; emitBindingElement(element, createPropertyAccessForDestructuringProperty(value, propName)); } - else if (element.kind !== 176) { + else if (element.kind !== 178) { if (!element.dotDotDotToken) { emitBindingElement(element, createElementAccessExpression(value, createNumericLiteral(i))); } @@ -23569,14 +23958,13 @@ var ts; } } else { - renameNonTopLevelLetAndConst(node.name); var initializer = node.initializer; if (!initializer && languageVersion < 2) { var isUninitializedLet = (resolver.getNodeCheckFlags(node) & 256) && (getCombinedFlagsForIdentifier(node.name) & 4096); if (isUninitializedLet && - node.parent.parent.kind !== 188 && - node.parent.parent.kind !== 189) { + node.parent.parent.kind !== 190 && + node.parent.parent.kind !== 191) { initializer = createVoidZero(); } } @@ -23594,7 +23982,7 @@ var ts; } } function emitExportVariableAssignments(node) { - if (node.kind === 176) { + if (node.kind === 178) { return; } var name = node.name; @@ -23606,48 +23994,15 @@ var ts; } } function getCombinedFlagsForIdentifier(node) { - if (!node.parent || (node.parent.kind !== 199 && node.parent.kind !== 153)) { + if (!node.parent || (node.parent.kind !== 201 && node.parent.kind !== 155)) { return 0; } return ts.getCombinedNodeFlags(node.parent); } - function renameNonTopLevelLetAndConst(node) { - if (languageVersion >= 2 || - ts.nodeIsSynthesized(node) || - node.kind !== 65 || - (node.parent.kind !== 199 && node.parent.kind !== 153)) { - return; - } - var combinedFlags = getCombinedFlagsForIdentifier(node); - if (((combinedFlags & 12288) === 0) || combinedFlags & 1) { - return; - } - var list = ts.getAncestor(node, 200); - if (list.parent.kind === 181) { - var isSourceFileLevelBinding = list.parent.parent.kind === 228; - var isModuleLevelBinding = list.parent.parent.kind === 207; - var isFunctionLevelBinding = list.parent.parent.kind === 180 && ts.isFunctionLike(list.parent.parent.parent); - if (isSourceFileLevelBinding || isModuleLevelBinding || isFunctionLevelBinding) { - return; - } - } - var blockScopeContainer = ts.getEnclosingBlockScopeContainer(node); - var parent = blockScopeContainer.kind === 228 - ? blockScopeContainer - : blockScopeContainer.parent; - if (resolver.resolvesToSomeValue(parent, node.text)) { - var variableId = resolver.getBlockScopedVariableId(node); - if (!blockScopedVariableToGeneratedName) { - blockScopedVariableToGeneratedName = []; - } - var generatedName = makeUniqueName(node.text); - blockScopedVariableToGeneratedName[variableId] = generatedName; - } - } function isES6ExportedDeclaration(node) { return !!(node.flags & 1) && languageVersion >= 2 && - node.parent.kind === 228; + node.parent.kind === 230; } function emitVariableStatement(node) { var startIsEmitted = false; @@ -23692,12 +24047,12 @@ var ts; function emitParameter(node) { if (languageVersion < 2) { if (ts.isBindingPattern(node.name)) { - var name_23 = createTempVariable(0); + var name_20 = createTempVariable(0); if (!tempParameters) { tempParameters = []; } - tempParameters.push(name_23); - emit(name_23); + tempParameters.push(name_20); + emit(name_20); } else { emit(node.name); @@ -23785,12 +24140,12 @@ var ts; } } function emitAccessor(node) { - write(node.kind === 137 ? "get " : "set "); - emit(node.name, false); + write(node.kind === 138 ? "get " : "set "); + emit(node.name); emitSignatureAndBody(node); } function shouldEmitAsArrowFunction(node) { - return node.kind === 164 && languageVersion >= 2; + return node.kind === 166 && languageVersion >= 2; } function emitDeclarationName(node) { if (node.name) { @@ -23801,10 +24156,10 @@ var ts; } } function shouldEmitFunctionName(node) { - if (node.kind === 163) { + if (node.kind === 165) { return !!node.name; } - if (node.kind === 201) { + if (node.kind === 203) { return !!node.name || languageVersion < 2; } } @@ -23812,7 +24167,7 @@ var ts; if (ts.nodeIsMissing(node.body)) { return emitOnlyPinnedOrTripleSlashComments(node); } - if (node.kind !== 135 && node.kind !== 134) { + if (node.kind !== 136 && node.kind !== 135) { emitLeadingComments(node); } if (!shouldEmitAsArrowFunction(node)) { @@ -23832,10 +24187,10 @@ var ts; emitDeclarationName(node); } emitSignatureAndBody(node); - if (languageVersion < 2 && node.kind === 201 && node.parent === currentSourceFile && node.name) { + if (languageVersion < 2 && node.kind === 203 && node.parent === currentSourceFile && node.name) { emitExportMemberAssignments(node.name); } - if (node.kind !== 135 && node.kind !== 134) { + if (node.kind !== 136 && node.kind !== 135) { emitTrailingComments(node); } } @@ -23882,7 +24237,7 @@ var ts; if (!node.body) { write(" { }"); } - else if (node.body.kind === 180) { + else if (node.body.kind === 182) { emitBlockFunctionBody(node, node.body); } else { @@ -23907,10 +24262,10 @@ var ts; } write(" "); var current = body; - while (current.kind === 161) { + while (current.kind === 163) { current = current.expression; } - emitParenthesizedIf(body, current.kind === 155); + emitParenthesizedIf(body, current.kind === 157); } function emitDownLevelExpressionFunctionBody(node, body) { write(" {"); @@ -23982,9 +24337,9 @@ var ts; function findInitialSuperCall(ctor) { if (ctor.body) { var statement = ctor.body.statements[0]; - if (statement && statement.kind === 183) { + if (statement && statement.kind === 185) { var expr = statement.expression; - if (expr && expr.kind === 158) { + if (expr && expr.kind === 160) { var func = expr.expression; if (func && func.kind === 91) { return statement; @@ -24015,7 +24370,7 @@ var ts; emitNodeWithoutSourceMap(memberName); write("]"); } - else if (memberName.kind === 128) { + else if (memberName.kind === 129) { emitComputedPropertyName(memberName); } else { @@ -24027,7 +24382,7 @@ var ts; var properties = []; for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if (member.kind === 133 && isStatic === ((member.flags & 128) !== 0) && member.initializer) { + if (member.kind === 134 && isStatic === ((member.flags & 128) !== 0) && member.initializer) { properties.push(member); } } @@ -24067,11 +24422,11 @@ var ts; } function emitMemberFunctionsForES5AndLower(node) { ts.forEach(node.members, function (member) { - if (member.kind === 179) { + if (member.kind === 181) { writeLine(); write(";"); } - else if (member.kind === 135 || node.kind === 134) { + else if (member.kind === 136 || node.kind === 135) { if (!member.body) { return emitOnlyPinnedOrTripleSlashComments(member); } @@ -24090,7 +24445,7 @@ var ts; write(";"); emitTrailingComments(member); } - else if (member.kind === 137 || member.kind === 138) { + else if (member.kind === 138 || member.kind === 139) { var accessors = ts.getAllAccessorDeclarations(node.members, member); if (member === accessors.firstAccessor) { writeLine(); @@ -24140,22 +24495,22 @@ var ts; function emitMemberFunctionsForES6AndHigher(node) { for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if ((member.kind === 135 || node.kind === 134) && !member.body) { + if ((member.kind === 136 || node.kind === 135) && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } - else if (member.kind === 135 || - member.kind === 137 || - member.kind === 138) { + else if (member.kind === 136 || + member.kind === 138 || + member.kind === 139) { writeLine(); emitLeadingComments(member); emitStart(member); if (member.flags & 128) { write("static "); } - if (member.kind === 137) { + if (member.kind === 138) { write("get "); } - else if (member.kind === 138) { + else if (member.kind === 139) { write("set "); } if (member.asteriskToken) { @@ -24166,7 +24521,7 @@ var ts; emitEnd(member); emitTrailingComments(member); } - else if (member.kind === 179) { + else if (member.kind === 181) { writeLine(); write(";"); } @@ -24187,10 +24542,10 @@ var ts; function emitConstructorWorker(node, baseTypeElement) { var hasInstancePropertyWithInitializer = false; ts.forEach(node.members, function (member) { - if (member.kind === 136 && !member.body) { + if (member.kind === 137 && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } - if (member.kind === 133 && member.initializer && (member.flags & 128) === 0) { + if (member.kind === 134 && member.initializer && (member.flags & 128) === 0) { hasInstancePropertyWithInitializer = true; } }); @@ -24290,7 +24645,7 @@ var ts; } function emitClassLikeDeclarationForES6AndHigher(node) { var thisNodeIsDecorated = ts.nodeIsDecorated(node); - if (node.kind === 202) { + if (node.kind === 204) { if (thisNodeIsDecorated) { if (isES6ExportedDeclaration(node) && !(node.flags & 256)) { write("export "); @@ -24307,7 +24662,7 @@ var ts; } } var staticProperties = getInitializedProperties(node, true); - var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 175; + var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 177; var tempVariable; if (isClassExpressionWithStaticProperties) { tempVariable = createAndRecordTempVariable(0); @@ -24374,7 +24729,7 @@ var ts; } } function emitClassLikeDeclarationBelowES6(node) { - if (node.kind === 202) { + if (node.kind === 204) { if (!shouldHoistDeclarationInSystemJsModule(node)) { write("var "); } @@ -24432,11 +24787,11 @@ var ts; emit(baseTypeNode.expression); } write(")"); - if (node.kind === 202) { + if (node.kind === 204) { write(";"); } emitEnd(node); - if (node.kind === 202) { + if (node.kind === 204) { emitExportMemberAssignment(node); } if (languageVersion < 2 && node.parent === currentSourceFile && node.name) { @@ -24510,13 +24865,13 @@ var ts; } else { decorators = member.decorators; - if (member.kind === 135) { + if (member.kind === 136) { functionLikeMember = member; } } writeLine(); emitStart(member); - if (member.kind !== 133) { + if (member.kind !== 134) { write("Object.defineProperty("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -24546,7 +24901,7 @@ var ts; write(", "); emitExpressionForPropertyName(member.name); emitEnd(member.name); - if (member.kind !== 133) { + if (member.kind !== 134) { write(", Object.getOwnPropertyDescriptor("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -24585,26 +24940,26 @@ var ts; } function shouldEmitTypeMetadata(node) { switch (node.kind) { - case 135: - case 137: + case 136: case 138: - case 133: + case 139: + case 134: return true; } return false; } function shouldEmitReturnTypeMetadata(node) { switch (node.kind) { - case 135: + case 136: return true; } return false; } function shouldEmitParamTypesMetadata(node) { switch (node.kind) { - case 202: - case 135: - case 138: + case 204: + case 136: + case 139: return true; } return false; @@ -24613,7 +24968,7 @@ var ts; var argumentsWritten = 0; if (compilerOptions.emitDecoratorMetadata) { if (shouldEmitTypeMetadata(node)) { - var serializedType = resolver.serializeTypeOfNode(node, getGeneratedNameForNode); + var serializedType = resolver.serializeTypeOfNode(node); if (serializedType) { if (writeComma) { write(", "); @@ -24626,7 +24981,7 @@ var ts; } } if (shouldEmitParamTypesMetadata(node)) { - var serializedTypes = resolver.serializeParameterTypesOfNode(node, getGeneratedNameForNode); + var serializedTypes = resolver.serializeParameterTypesOfNode(node); if (serializedTypes) { if (writeComma || argumentsWritten) { write(", "); @@ -24644,7 +24999,7 @@ var ts; } } if (shouldEmitReturnTypeMetadata(node)) { - var serializedType = resolver.serializeReturnTypeOfNode(node, getGeneratedNameForNode); + var serializedType = resolver.serializeReturnTypeOfNode(node); if (serializedType) { if (writeComma || argumentsWritten) { write(", "); @@ -24774,7 +25129,7 @@ var ts; } } function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { - if (moduleDeclaration.body.kind === 206) { + if (moduleDeclaration.body.kind === 208) { var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); return recursiveInnerModule || moduleDeclaration.body; } @@ -24809,7 +25164,7 @@ var ts; write(getGeneratedNameForNode(node)); emitEnd(node.name); write(") "); - if (node.body.kind === 207) { + if (node.body.kind === 209) { var saveTempFlags = tempFlags; var saveTempVariables = tempVariables; tempFlags = 0; @@ -24866,16 +25221,16 @@ var ts; } } function getNamespaceDeclarationNode(node) { - if (node.kind === 209) { + if (node.kind === 211) { return node; } var importClause = node.importClause; - if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 212) { + if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 214) { return importClause.namedBindings; } } function isDefaultImport(node) { - return node.kind === 210 && node.importClause && !!node.importClause.name; + return node.kind === 212 && node.importClause && !!node.importClause.name; } function emitExportImportAssignments(node) { if (ts.isAliasSymbolDeclaration(node) && resolver.isValueAliasDeclaration(node)) { @@ -24902,7 +25257,7 @@ var ts; if (shouldEmitNamedBindings) { emitLeadingComments(node.importClause.namedBindings); emitStart(node.importClause.namedBindings); - if (node.importClause.namedBindings.kind === 212) { + if (node.importClause.namedBindings.kind === 214) { write("* as "); emit(node.importClause.namedBindings.name); } @@ -24928,7 +25283,7 @@ var ts; } function emitExternalImportDeclaration(node) { if (ts.contains(externalImports, node)) { - var isExportedImport = node.kind === 209 && (node.flags & 1) !== 0; + var isExportedImport = node.kind === 211 && (node.flags & 1) !== 0; var namespaceDeclaration = getNamespaceDeclarationNode(node); if (compilerOptions.module !== 2) { emitLeadingComments(node); @@ -24940,7 +25295,7 @@ var ts; write(" = "); } else { - var isNakedImport = 210 && !node.importClause; + var isNakedImport = 212 && !node.importClause; if (!isNakedImport) { write("var "); write(getGeneratedNameForNode(node)); @@ -25096,8 +25451,8 @@ var ts; write("export default "); var expression = node.expression; emit(expression); - if (expression.kind !== 201 && - expression.kind !== 202) { + if (expression.kind !== 203 && + expression.kind !== 204) { write(";"); } emitEnd(node); @@ -25133,18 +25488,18 @@ var ts; for (var _a = 0, _b = sourceFile.statements; _a < _b.length; _a++) { var node = _b[_a]; switch (node.kind) { - case 210: + case 212: if (!node.importClause || resolver.isReferencedAliasDeclaration(node.importClause, true)) { externalImports.push(node); } break; - case 209: - if (node.moduleReference.kind === 220 && resolver.isReferencedAliasDeclaration(node)) { + case 211: + if (node.moduleReference.kind === 222 && resolver.isReferencedAliasDeclaration(node)) { externalImports.push(node); } break; - case 216: + case 218: if (node.moduleSpecifier) { if (!node.exportClause) { externalImports.push(node); @@ -25157,12 +25512,12 @@ var ts; else { for (var _c = 0, _d = node.exportClause.elements; _c < _d.length; _c++) { var specifier = _d[_c]; - var name_24 = (specifier.propertyName || specifier.name).text; - (exportSpecifiers[name_24] || (exportSpecifiers[name_24] = [])).push(specifier); + var name_21 = (specifier.propertyName || specifier.name).text; + (exportSpecifiers[name_21] || (exportSpecifiers[name_21] = [])).push(specifier); } } break; - case 215: + case 217: if (node.isExportEquals && !exportEquals) { exportEquals = node; } @@ -25182,13 +25537,16 @@ var ts; write("}"); } } - function getLocalNameForExternalImport(importNode) { - var namespaceDeclaration = getNamespaceDeclarationNode(importNode); - if (namespaceDeclaration && !isDefaultImport(importNode)) { + function getLocalNameForExternalImport(node) { + var namespaceDeclaration = getNamespaceDeclarationNode(node); + if (namespaceDeclaration && !isDefaultImport(node)) { return ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, namespaceDeclaration.name); } - else { - return getGeneratedNameForNode(importNode); + if (node.kind === 212 && node.importClause) { + return getGeneratedNameForNode(node); + } + if (node.kind === 218 && node.moduleSpecifier) { + return getGeneratedNameForNode(node); } } function getExternalModuleNameText(importNode) { @@ -25206,8 +25564,8 @@ var ts; var started = false; for (var _a = 0; _a < externalImports.length; _a++) { var importNode = externalImports[_a]; - var skipNode = importNode.kind === 216 || - (importNode.kind === 210 && !importNode.importClause); + var skipNode = importNode.kind === 218 || + (importNode.kind === 212 && !importNode.importClause); if (skipNode) { continue; } @@ -25232,7 +25590,7 @@ var ts; var hasExportDeclarationWithExportClause = false; for (var _a = 0; _a < externalImports.length; _a++) { var externalImport = externalImports[_a]; - if (externalImport.kind === 216 && externalImport.exportClause) { + if (externalImport.kind === 218 && externalImport.exportClause) { hasExportDeclarationWithExportClause = true; break; } @@ -25261,7 +25619,7 @@ var ts; } for (var _d = 0; _d < externalImports.length; _d++) { var externalImport = externalImports[_d]; - if (externalImport.kind !== 216) { + if (externalImport.kind !== 218) { continue; } var exportDecl = externalImport; @@ -25331,11 +25689,11 @@ var ts; var seen = {}; for (var i = 0; i < hoistedVars.length; ++i) { var local = hoistedVars[i]; - var name_25 = local.kind === 65 + var name_22 = local.kind === 65 ? local : local.name; - if (name_25) { - var text = ts.unescapeIdentifier(name_25.text); + if (name_22) { + var text = ts.unescapeIdentifier(name_22.text); if (ts.hasProperty(seen, text)) { continue; } @@ -25346,7 +25704,7 @@ var ts; if (i !== 0) { write(", "); } - if (local.kind === 202 || local.kind === 206 || local.kind === 205) { + if (local.kind === 204 || local.kind === 208 || local.kind === 207) { emitDeclarationName(local); } else { @@ -25380,21 +25738,21 @@ var ts; if (node.flags & 2) { return; } - if (node.kind === 201) { + if (node.kind === 203) { if (!hoistedFunctionDeclarations) { hoistedFunctionDeclarations = []; } hoistedFunctionDeclarations.push(node); return; } - if (node.kind === 202) { + if (node.kind === 204) { if (!hoistedVars) { hoistedVars = []; } hoistedVars.push(node); return; } - if (node.kind === 205) { + if (node.kind === 207) { if (shouldEmitEnumDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; @@ -25403,7 +25761,7 @@ var ts; } return; } - if (node.kind === 206) { + if (node.kind === 208) { if (shouldEmitModuleDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; @@ -25412,17 +25770,17 @@ var ts; } return; } - if (node.kind === 199 || node.kind === 153) { + if (node.kind === 201 || node.kind === 155) { if (shouldHoistVariable(node, false)) { - var name_26 = node.name; - if (name_26.kind === 65) { + var name_23 = node.name; + if (name_23.kind === 65) { if (!hoistedVars) { hoistedVars = []; } - hoistedVars.push(name_26); + hoistedVars.push(name_23); } else { - ts.forEachChild(name_26, visit); + ts.forEachChild(name_23, visit); } } return; @@ -25441,7 +25799,7 @@ var ts; return false; } return (ts.getCombinedNodeFlags(node) & 12288) === 0 || - ts.getEnclosingBlockScopeContainer(node).kind === 228; + ts.getEnclosingBlockScopeContainer(node).kind === 230; } function isCurrentFileSystemExternalModule() { return compilerOptions.module === 4 && ts.isExternalModule(currentSourceFile); @@ -25458,10 +25816,10 @@ var ts; emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(true); decreaseIndent(); writeLine(); write("}"); + emitTempDeclarations(true); } function emitSetters(exportStarFunction) { write("setters:["); @@ -25476,27 +25834,27 @@ var ts; var parameterName = "_" + importVariableName; write("function (" + parameterName + ") {"); switch (importNode.kind) { - case 210: + case 212: if (!importNode.importClause) { break; } - case 209: + case 211: ts.Debug.assert(importVariableName !== ""); increaseIndent(); writeLine(); write(importVariableName + " = " + parameterName + ";"); writeLine(); - var defaultName = importNode.kind === 210 + var defaultName = importNode.kind === 212 ? importNode.importClause.name : importNode.name; if (defaultName) { emitExportMemberAssignments(defaultName); writeLine(); } - if (importNode.kind === 210 && + if (importNode.kind === 212 && importNode.importClause.namedBindings) { var namedBindings = importNode.importClause.namedBindings; - if (namedBindings.kind === 212) { + if (namedBindings.kind === 214) { emitExportMemberAssignments(namedBindings.name); writeLine(); } @@ -25510,7 +25868,7 @@ var ts; } decreaseIndent(); break; - case 216: + case 218: ts.Debug.assert(importVariableName !== ""); increaseIndent(); if (importNode.exportClause) { @@ -25544,10 +25902,10 @@ var ts; for (var i = startIndex; i < node.statements.length; ++i) { var statement = node.statements[i]; switch (statement.kind) { - case 216: - case 210: - case 209: - case 201: + case 218: + case 212: + case 211: + case 203: continue; } writeLine(); @@ -25561,7 +25919,11 @@ var ts; collectExternalModuleInfo(node); ts.Debug.assert(!exportFunctionForFile); exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); + } + write("["); for (var i = 0; i < externalImports.length; ++i) { var text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -25634,8 +25996,8 @@ var ts; collectExternalModuleInfo(node); writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, true); write(") {"); @@ -25764,7 +26126,7 @@ var ts; } emitLeadingComments(node.endOfFileToken); } - function emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers) { + function emitNodeWithoutSourceMap(node) { if (!node) { return; } @@ -25775,48 +26137,47 @@ var ts; if (emitComments) { emitLeadingComments(node); } - emitJavaScriptWorker(node, allowGeneratedIdentifiers); + emitJavaScriptWorker(node); if (emitComments) { emitTrailingComments(node); } } function shouldEmitLeadingAndTrailingComments(node) { switch (node.kind) { - case 203: - case 201: - case 210: - case 209: - case 204: - case 215: - return false; - case 181: - return shouldEmitLeadingAndTrailingCommentsForVariableStatement(node); - case 206: - return shouldEmitModuleDeclaration(node); case 205: + case 203: + case 212: + case 211: + case 206: + case 217: + return false; + case 183: + return shouldEmitLeadingAndTrailingCommentsForVariableStatement(node); + case 208: + return shouldEmitModuleDeclaration(node); + case 207: return shouldEmitEnumDeclaration(node); } - if (node.kind !== 180 && + if (node.kind !== 182 && node.parent && - node.parent.kind === 164 && + node.parent.kind === 166 && node.parent.body === node && compilerOptions.target <= 1) { return false; } return true; } - function emitJavaScriptWorker(node, allowGeneratedIdentifiers) { - if (allowGeneratedIdentifiers === void 0) { allowGeneratedIdentifiers = true; } + function emitJavaScriptWorker(node) { switch (node.kind) { case 65: - return emitIdentifier(node, allowGeneratedIdentifiers); - case 130: + return emitIdentifier(node); + case 131: return emitParameter(node); + case 136: case 135: - case 134: return emitMethod(node); - case 137: case 138: + case 139: return emitAccessor(node); case 93: return emitThis(node); @@ -25836,131 +26197,131 @@ var ts; case 12: case 13: return emitLiteral(node); - case 172: - return emitTemplateExpression(node); - case 178: - return emitTemplateSpan(node); - case 127: - return emitQualifiedName(node); - case 151: - return emitObjectBindingPattern(node); - case 152: - return emitArrayBindingPattern(node); - case 153: - return emitBindingElement(node); - case 154: - return emitArrayLiteral(node); - case 155: - return emitObjectLiteral(node); - case 225: - return emitPropertyAssignment(node); - case 226: - return emitShorthandPropertyAssignment(node); - case 128: - return emitComputedPropertyName(node); - case 156: - return emitPropertyAccess(node); - case 157: - return emitIndexedAccess(node); - case 158: - return emitCallExpression(node); - case 159: - return emitNewExpression(node); - case 160: - return emitTaggedTemplateExpression(node); - case 161: - return emit(node.expression); - case 162: - return emitParenExpression(node); - case 201: - case 163: - case 164: - return emitFunctionDeclaration(node); - case 165: - return emitDeleteExpression(node); - case 166: - return emitTypeOfExpression(node); - case 167: - return emitVoidExpression(node); - case 168: - return emitPrefixUnaryExpression(node); - case 169: - return emitPostfixUnaryExpression(node); - case 170: - return emitBinaryExpression(node); - case 171: - return emitConditionalExpression(node); case 174: - return emitSpreadElementExpression(node); - case 173: - return emitYieldExpression(node); - case 176: - return; + return emitTemplateExpression(node); case 180: - case 207: - return emitBlock(node); - case 181: - return emitVariableStatement(node); - case 182: - return write(";"); - case 183: - return emitExpressionStatement(node); - case 184: - return emitIfStatement(node); - case 185: - return emitDoStatement(node); - case 186: - return emitWhileStatement(node); - case 187: - return emitForStatement(node); - case 189: - case 188: - return emitForInOrForOfStatement(node); - case 190: - case 191: - return emitBreakOrContinueStatement(node); - case 192: - return emitReturnStatement(node); - case 193: - return emitWithStatement(node); - case 194: - return emitSwitchStatement(node); - case 221: - case 222: - return emitCaseOrDefaultClause(node); - case 195: - return emitLabelledStatement(node); - case 196: - return emitThrowStatement(node); - case 197: - return emitTryStatement(node); - case 224: - return emitCatchClause(node); - case 198: - return emitDebuggerStatement(node); - case 199: - return emitVariableDeclaration(node); - case 175: - return emitClassExpression(node); - case 202: - return emitClassDeclaration(node); - case 203: - return emitInterfaceDeclaration(node); - case 205: - return emitEnumDeclaration(node); + return emitTemplateSpan(node); + case 128: + return emitQualifiedName(node); + case 153: + return emitObjectBindingPattern(node); + case 154: + return emitArrayBindingPattern(node); + case 155: + return emitBindingElement(node); + case 156: + return emitArrayLiteral(node); + case 157: + return emitObjectLiteral(node); case 227: - return emitEnumMember(node); - case 206: - return emitModuleDeclaration(node); - case 210: - return emitImportDeclaration(node); - case 209: - return emitImportEqualsDeclaration(node); - case 216: - return emitExportDeclaration(node); - case 215: - return emitExportAssignment(node); + return emitPropertyAssignment(node); case 228: + return emitShorthandPropertyAssignment(node); + case 129: + return emitComputedPropertyName(node); + case 158: + return emitPropertyAccess(node); + case 159: + return emitIndexedAccess(node); + case 160: + return emitCallExpression(node); + case 161: + return emitNewExpression(node); + case 162: + return emitTaggedTemplateExpression(node); + case 163: + return emit(node.expression); + case 164: + return emitParenExpression(node); + case 203: + case 165: + case 166: + return emitFunctionDeclaration(node); + case 167: + return emitDeleteExpression(node); + case 168: + return emitTypeOfExpression(node); + case 169: + return emitVoidExpression(node); + case 170: + return emitPrefixUnaryExpression(node); + case 171: + return emitPostfixUnaryExpression(node); + case 172: + return emitBinaryExpression(node); + case 173: + return emitConditionalExpression(node); + case 176: + return emitSpreadElementExpression(node); + case 175: + return emitYieldExpression(node); + case 178: + return; + case 182: + case 209: + return emitBlock(node); + case 183: + return emitVariableStatement(node); + case 184: + return write(";"); + case 185: + return emitExpressionStatement(node); + case 186: + return emitIfStatement(node); + case 187: + return emitDoStatement(node); + case 188: + return emitWhileStatement(node); + case 189: + return emitForStatement(node); + case 191: + case 190: + return emitForInOrForOfStatement(node); + case 192: + case 193: + return emitBreakOrContinueStatement(node); + case 194: + return emitReturnStatement(node); + case 195: + return emitWithStatement(node); + case 196: + return emitSwitchStatement(node); + case 223: + case 224: + return emitCaseOrDefaultClause(node); + case 197: + return emitLabelledStatement(node); + case 198: + return emitThrowStatement(node); + case 199: + return emitTryStatement(node); + case 226: + return emitCatchClause(node); + case 200: + return emitDebuggerStatement(node); + case 201: + return emitVariableDeclaration(node); + case 177: + return emitClassExpression(node); + case 204: + return emitClassDeclaration(node); + case 205: + return emitInterfaceDeclaration(node); + case 207: + return emitEnumDeclaration(node); + case 229: + return emitEnumMember(node); + case 208: + return emitModuleDeclaration(node); + case 212: + return emitImportDeclaration(node); + case 211: + return emitImportEqualsDeclaration(node); + case 218: + return emitExportDeclaration(node); + case 217: + return emitExportAssignment(node); + case 230: return emitSourceFileNode(node); } } @@ -25988,7 +26349,7 @@ var ts; } function getLeadingCommentsToEmit(node) { if (node.parent) { - if (node.parent.kind === 228 || node.pos !== node.parent.pos) { + if (node.parent.kind === 230 || node.pos !== node.parent.pos) { if (hasDetachedComments(node.pos)) { return getLeadingCommentsWithoutDetachedComments(); } @@ -26000,7 +26361,7 @@ var ts; } function getTrailingCommentsToEmit(node) { if (node.parent) { - if (node.parent.kind === 228 || node.end !== node.parent.end) { + if (node.parent.kind === 230 || node.end !== node.parent.end) { return ts.getTrailingCommentRanges(currentSourceFile.text, node.end); } } @@ -26178,7 +26539,7 @@ var ts; } ts.createCompilerHost = createCompilerHost; function getPreEmitDiagnostics(program, sourceFile) { - var diagnostics = program.getSyntacticDiagnostics(sourceFile).concat(program.getGlobalDiagnostics()).concat(program.getSemanticDiagnostics(sourceFile)); + var diagnostics = program.getOptionsDiagnostics().concat(program.getSyntacticDiagnostics(sourceFile), program.getGlobalDiagnostics(), program.getSemanticDiagnostics(sourceFile)); if (program.getCompilerOptions().declaration) { diagnostics.concat(program.getDeclarationDiagnostics(sourceFile)); } @@ -26211,16 +26572,17 @@ var ts; function createProgram(rootNames, options, host) { var program; var files = []; - var filesByName = {}; var diagnostics = ts.createDiagnosticCollection(); - var seenNoDefaultLib = options.noLib; var commonSourceDirectory; var diagnosticsProducingTypeChecker; var noDiagnosticsTypeChecker; + var classifiableNames; + var skipDefaultLib = options.noLib; var start = new Date().getTime(); host = host || createCompilerHost(options); + var filesByName = ts.createFileMap(function (fileName) { return host.getCanonicalFileName(fileName); }); ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); - if (!seenNoDefaultLib) { + if (!skipDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); } verifyCompilerOptions(); @@ -26230,11 +26592,12 @@ var ts; getSourceFiles: function () { return files; }, getCompilerOptions: function () { return options; }, getSyntacticDiagnostics: getSyntacticDiagnostics, + getOptionsDiagnostics: getOptionsDiagnostics, getGlobalDiagnostics: getGlobalDiagnostics, getSemanticDiagnostics: getSemanticDiagnostics, getDeclarationDiagnostics: getDeclarationDiagnostics, - getCompilerOptionsDiagnostics: getCompilerOptionsDiagnostics, getTypeChecker: getTypeChecker, + getClassifiableNames: getClassifiableNames, getDiagnosticsProducingTypeChecker: getDiagnosticsProducingTypeChecker, getCommonSourceDirectory: function () { return commonSourceDirectory; }, emit: emit, @@ -26245,6 +26608,17 @@ var ts; getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); } }; return program; + function getClassifiableNames() { + if (!classifiableNames) { + getTypeChecker(); + classifiableNames = {}; + for (var _i = 0; _i < files.length; _i++) { + var sourceFile = files[_i]; + ts.copyMap(sourceFile.classifiableNames, classifiableNames); + } + } + return classifiableNames; + } function getEmitHost(writeFileCallback) { return { getCanonicalFileName: function (fileName) { return host.getCanonicalFileName(fileName); }, @@ -26274,8 +26648,7 @@ var ts; return emitResult; } function getSourceFile(fileName) { - fileName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile, getDiagnostics) { if (sourceFile) { @@ -26314,16 +26687,14 @@ var ts; return ts.getDeclarationDiagnostics(getEmitHost(writeFile), resolver, sourceFile); } } - function getCompilerOptionsDiagnostics() { + function getOptionsDiagnostics() { var allDiagnostics = []; ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); return ts.sortAndDeduplicateDiagnostics(allDiagnostics); } function getGlobalDiagnostics() { - var typeChecker = getDiagnosticsProducingTypeChecker(); var allDiagnostics = []; - ts.addRange(allDiagnostics, typeChecker.getGlobalDiagnostics()); - ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); + ts.addRange(allDiagnostics, getDiagnosticsProducingTypeChecker().getGlobalDiagnostics()); return ts.sortAndDeduplicateDiagnostics(allDiagnostics); } function hasExtension(fileName) { @@ -26357,14 +26728,17 @@ var ts; } } else { - if (options.allowNonTsExtensions && !findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd)) { - diagnostic = ts.Diagnostics.File_0_not_found; - diagnosticArgument = [fileName]; - } - else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, isDefaultLib, refFile, refPos, refEnd); })) { - diagnostic = ts.Diagnostics.File_0_not_found; - fileName += ".ts"; - diagnosticArgument = [fileName]; + var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd); + if (!nonTsFile) { + if (options.allowNonTsExtensions) { + diagnostic = ts.Diagnostics.File_0_not_found; + diagnosticArgument = [fileName]; + } + else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, isDefaultLib, refFile, refPos, refEnd); })) { + diagnostic = ts.Diagnostics.File_0_not_found; + fileName += ".ts"; + diagnosticArgument = [fileName]; + } } } if (diagnostic) { @@ -26378,16 +26752,16 @@ var ts; } function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - if (ts.hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { return getSourceFileFromCache(fileName, canonicalName, false); } else { var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } - var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } @@ -26395,15 +26769,17 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { - seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; - filesByName[canonicalAbsolutePath] = file; + skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); processReferencedFiles(file, basePath); processImportedModules(file, basePath); } if (isDefaultLib) { + file.isDefaultLib = true; files.unshift(file); } else { @@ -26413,7 +26789,7 @@ var ts; return file; } function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { - var file = filesByName[canonicalName]; + var file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { @@ -26431,7 +26807,7 @@ var ts; } function processImportedModules(file, basePath) { ts.forEach(file.statements, function (node) { - if (node.kind === 210 || node.kind === 209 || node.kind === 216) { + if (node.kind === 212 || node.kind === 211 || node.kind === 218) { var moduleNameExpr = ts.getExternalModuleName(node); if (moduleNameExpr && moduleNameExpr.kind === 8) { var moduleNameText = moduleNameExpr.text; @@ -26452,7 +26828,7 @@ var ts; } } } - else if (node.kind === 206 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { + else if (node.kind === 208 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { ts.forEachChild(node.body, function (node) { if (ts.isExternalModuleImportEqualsDeclaration(node) && ts.getExternalModuleImportEqualsDeclarationExpression(node).kind === 8) { @@ -26710,9 +27086,14 @@ var ts; name: "noResolve", type: "boolean" }, + { + name: "skipDefaultLibCheck", + type: "boolean" + }, { name: "out", type: "string", + isFilePath: true, description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file, paramType: ts.Diagnostics.FILE }, diff --git a/bin/tsserver.js b/bin/tsserver.js index 9c655a0b0c1..6f4c99b36a6 100644 --- a/bin/tsserver.js +++ b/bin/tsserver.js @@ -31,6 +31,36 @@ var ts; /// var ts; (function (ts) { + function createFileMap(getCanonicalFileName) { + var files = {}; + return { + get: get, + set: set, + contains: contains, + remove: remove, + forEachValue: forEachValueInMap + }; + function set(fileName, value) { + files[normalizeKey(fileName)] = value; + } + function get(fileName) { + return files[normalizeKey(fileName)]; + } + function contains(fileName) { + return hasProperty(files, normalizeKey(fileName)); + } + function remove(fileName) { + var key = normalizeKey(fileName); + delete files[key]; + } + function forEachValueInMap(f) { + forEachValue(files, f); + } + function normalizeKey(key) { + return getCanonicalFileName(normalizeSlashes(key)); + } + } + ts.createFileMap = createFileMap; function forEach(array, callback) { if (array) { for (var i = 0, len = array.length; i < len; i++) { @@ -498,7 +528,7 @@ var ts; function getNormalizedPathComponents(path, currentDirectory) { path = normalizeSlashes(path); var rootLength = getRootLength(path); - if (rootLength == 0) { + if (rootLength === 0) { path = combinePaths(normalizeSlashes(currentDirectory), path); rootLength = getRootLength(path); } @@ -1116,14 +1146,26 @@ var ts; A_class_declaration_without_the_default_modifier_must_have_a_name: { code: 1211, category: ts.DiagnosticCategory.Error, key: "A class declaration without the 'default' modifier must have a name" }, Identifier_expected_0_is_a_reserved_word_in_strict_mode: { code: 1212, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode" }, Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1213, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, - Type_expected_0_is_a_reserved_word_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode" }, - Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: ts.DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: { code: 1214, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode." }, + Invalid_use_of_0_Modules_are_automatically_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Invalid use of '{0}'. Modules are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: ts.DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalDecorators_to_remove_this_warning: { code: 1219, category: ts.DiagnosticCategory.Error, key: "Experimental support for decorators is a feature that is subject to change in a future release. Specify '--experimentalDecorators' to remove this warning." }, Generators_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 1220, category: ts.DiagnosticCategory.Error, key: "Generators are only available when targeting ECMAScript 6 or higher." }, Generators_are_not_allowed_in_an_ambient_context: { code: 1221, category: ts.DiagnosticCategory.Error, key: "Generators are not allowed in an ambient context." }, An_overload_signature_cannot_be_declared_as_a_generator: { code: 1222, category: ts.DiagnosticCategory.Error, key: "An overload signature cannot be declared as a generator." }, _0_tag_already_specified: { code: 1223, category: ts.DiagnosticCategory.Error, key: "'{0}' tag already specified." }, + Signature_0_must_have_a_type_predicate: { code: 1224, category: ts.DiagnosticCategory.Error, key: "Signature '{0}' must have a type predicate." }, + Cannot_find_parameter_0: { code: 1225, category: ts.DiagnosticCategory.Error, key: "Cannot find parameter '{0}'." }, + Type_predicate_0_is_not_assignable_to_1: { code: 1226, category: ts.DiagnosticCategory.Error, key: "Type predicate '{0}' is not assignable to '{1}'." }, + Parameter_0_is_not_in_the_same_position_as_parameter_1: { code: 1227, category: ts.DiagnosticCategory.Error, key: "Parameter '{0}' is not in the same position as parameter '{1}'." }, + A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: { code: 1228, category: ts.DiagnosticCategory.Error, key: "A type predicate is only allowed in return type position for functions and methods." }, + A_type_predicate_cannot_reference_a_rest_parameter: { code: 1229, category: ts.DiagnosticCategory.Error, key: "A type predicate cannot reference a rest parameter." }, + A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: { code: 1230, category: ts.DiagnosticCategory.Error, key: "A type predicate cannot reference element '{0}' in a binding pattern." }, + An_export_assignment_can_only_be_used_in_a_module: { code: 1231, category: ts.DiagnosticCategory.Error, key: "An export assignment can only be used in a module." }, + An_import_declaration_can_only_be_used_in_a_namespace_or_module: { code: 1232, category: ts.DiagnosticCategory.Error, key: "An import declaration can only be used in a namespace or module." }, + An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, + An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, + A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.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: ts.DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -1317,6 +1359,11 @@ var ts; Cannot_find_namespace_0: { code: 2503, category: ts.DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, No_best_common_type_exists_among_yield_expressions: { code: 2504, category: ts.DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: ts.DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, + _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: { code: 2506, category: ts.DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own base expression." }, + Type_0_is_not_a_constructor_function_type: { code: 2507, category: ts.DiagnosticCategory.Error, key: "Type '{0}' is not a constructor function type." }, + No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: ts.DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." }, + Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: ts.DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." }, + Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: ts.DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: ts.DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -1526,7 +1573,7 @@ var ts; "false": 80, "finally": 81, "for": 82, - "from": 125, + "from": 126, "function": 83, "get": 116, "if": 84, @@ -1535,36 +1582,37 @@ var ts; "in": 86, "instanceof": 87, "interface": 103, + "is": 117, "let": 104, - "module": 117, - "namespace": 118, + "module": 118, + "namespace": 119, "new": 88, "null": 89, - "number": 120, + "number": 121, "package": 105, "private": 106, "protected": 107, "public": 108, - "require": 119, + "require": 120, "return": 90, - "set": 121, + "set": 122, "static": 109, - "string": 122, + "string": 123, "super": 91, "switch": 92, - "symbol": 123, + "symbol": 124, "this": 93, "throw": 94, "true": 95, "try": 96, - "type": 124, + "type": 125, "typeof": 97, "var": 98, "void": 99, "while": 100, "with": 101, "yield": 110, - "of": 126, + "of": 127, "{": 14, "}": 15, "(": 16, @@ -1767,6 +1815,25 @@ var ts; return ch >= 48 && ch <= 55; } ts.isOctalDigit = isOctalDigit; + function couldStartTrivia(text, pos) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13: + case 10: + case 9: + case 11: + case 12: + case 32: + case 47: + case 60: + case 61: + case 62: + return true; + default: + return ch > 127; + } + } + ts.couldStartTrivia = couldStartTrivia; function skipTrivia(text, pos, stopAfterLineBreak) { while (true) { var ch = text.charCodeAt(pos); @@ -2229,7 +2296,7 @@ var ts; error(ts.Diagnostics.Unexpected_end_of_text); isInvalidExtendedEscape = true; } - else if (text.charCodeAt(pos) == 125) { + else if (text.charCodeAt(pos) === 125) { pos++; } else { @@ -2849,9 +2916,14 @@ var ts; name: "noResolve", type: "boolean" }, + { + name: "skipDefaultLibCheck", + type: "boolean" + }, { name: "out", type: "string", + isFilePath: true, description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file, paramType: ts.Diagnostics.FILE }, @@ -3152,7 +3224,7 @@ var ts; ts.getDeclarationOfKind = getDeclarationOfKind; var stringWriters = []; function getSingleLineStringWriter() { - if (stringWriters.length == 0) { + if (stringWriters.length === 0) { var str = ""; var writeText = function (text) { return str += text; }; return { @@ -3199,7 +3271,7 @@ var ts; } } function getSourceFileOfNode(node) { - while (node && node.kind !== 228) { + while (node && node.kind !== 230) { node = node.parent; } return node; @@ -3288,15 +3360,15 @@ var ts; return current; } switch (current.kind) { - case 228: + case 230: + case 210: + case 226: case 208: - case 224: - case 206: - case 187: - case 188: case 189: + case 190: + case 191: return current; - case 180: + case 182: if (!isFunctionLike(current.parent)) { return current; } @@ -3307,9 +3379,9 @@ var ts; ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer; function isCatchClauseVariableDeclaration(declaration) { return declaration && - declaration.kind === 199 && + declaration.kind === 201 && declaration.parent && - declaration.parent.kind === 224; + declaration.parent.kind === 226; } ts.isCatchClauseVariableDeclaration = isCatchClauseVariableDeclaration; function declarationNameToString(name) { @@ -3345,22 +3417,22 @@ var ts; function getErrorSpanForNode(sourceFile, node) { var errorNode = node; switch (node.kind) { - case 228: + case 230: var pos_1 = ts.skipTrivia(sourceFile.text, 0, false); if (pos_1 === sourceFile.text.length) { return ts.createTextSpan(0, 0); } return getSpanOfTokenAtPosition(sourceFile, pos_1); - case 199: - case 153: - case 202: - case 175: - case 203: - case 206: - case 205: - case 227: case 201: - case 163: + case 155: + case 204: + case 177: + case 205: + case 208: + case 207: + case 229: + case 203: + case 165: errorNode = node.name; break; } @@ -3382,11 +3454,11 @@ var ts; } ts.isDeclarationFile = isDeclarationFile; function isConstEnumDeclaration(node) { - return node.kind === 205 && isConst(node); + return node.kind === 207 && isConst(node); } ts.isConstEnumDeclaration = isConstEnumDeclaration; function walkUpBindingElementsAndPatterns(node) { - while (node && (node.kind === 153 || isBindingPattern(node))) { + while (node && (node.kind === 155 || isBindingPattern(node))) { node = node.parent; } return node; @@ -3394,14 +3466,14 @@ var ts; function getCombinedNodeFlags(node) { node = walkUpBindingElementsAndPatterns(node); var flags = node.flags; - if (node.kind === 199) { + if (node.kind === 201) { node = node.parent; } - if (node && node.kind === 200) { + if (node && node.kind === 202) { flags |= node.flags; node = node.parent; } - if (node && node.kind === 181) { + if (node && node.kind === 183) { flags |= node.flags; } return flags; @@ -3416,11 +3488,11 @@ var ts; } ts.isLet = isLet; function isPrologueDirective(node) { - return node.kind === 183 && node.expression.kind === 8; + return node.kind === 185 && node.expression.kind === 8; } ts.isPrologueDirective = isPrologueDirective; function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { - if (node.kind === 130 || node.kind === 129) { + if (node.kind === 131 || node.kind === 130) { return ts.concatenate(ts.getTrailingCommentRanges(sourceFileOfNode.text, node.pos), ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); } else { @@ -3439,68 +3511,68 @@ var ts; ts.getJsDocComments = getJsDocComments; ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/; function isTypeNode(node) { - if (142 <= node.kind && node.kind <= 150) { + if (144 <= node.kind && node.kind <= 152) { return true; } switch (node.kind) { case 112: - case 120: - case 122: - case 113: + case 121: case 123: + case 113: + case 124: return true; case 99: - return node.parent.kind !== 167; + return node.parent.kind !== 169; case 8: - return node.parent.kind === 130; - case 177: - return true; + return node.parent.kind === 131; + case 179: + return !isExpressionWithTypeArgumentsInClassExtendsClause(node); case 65: - if (node.parent.kind === 127 && node.parent.right === node) { + if (node.parent.kind === 128 && node.parent.right === node) { node = node.parent; } - else if (node.parent.kind === 156 && node.parent.name === node) { + else if (node.parent.kind === 158 && node.parent.name === node) { node = node.parent; } - case 127: - case 156: - ts.Debug.assert(node.kind === 65 || node.kind === 127 || node.kind === 156, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); + case 128: + case 158: + ts.Debug.assert(node.kind === 65 || node.kind === 128 || node.kind === 158, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); var parent_1 = node.parent; - if (parent_1.kind === 145) { + if (parent_1.kind === 147) { return false; } - if (142 <= parent_1.kind && parent_1.kind <= 150) { + if (144 <= parent_1.kind && parent_1.kind <= 152) { return true; } switch (parent_1.kind) { - case 177: - return true; - case 129: - return node === parent_1.constraint; - case 133: - case 132: + case 179: + return !isExpressionWithTypeArgumentsInClassExtendsClause(parent_1); case 130: - case 199: - return node === parent_1.type; + return node === parent_1.constraint; + case 134: + case 133: + case 131: case 201: - case 163: - case 164: + return node === parent_1.type; + case 203: + case 165: + case 166: + case 137: case 136: case 135: - case 134: - case 137: case 138: - return node === parent_1.type; case 139: + return node === parent_1.type; case 140: case 141: + case 142: return node === parent_1.type; - case 161: + case 163: return node === parent_1.type; - case 158: - case 159: - return parent_1.typeArguments && ts.indexOf(parent_1.typeArguments, node) >= 0; case 160: + case 161: + return parent_1.typeArguments && ts.indexOf(parent_1.typeArguments, node) >= 0; + case 162: return false; } } @@ -3511,23 +3583,23 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 192: + case 194: return visitor(node); - case 208: - case 180: - case 184: - case 185: + case 210: + case 182: case 186: case 187: case 188: case 189: - case 193: - case 194: - case 221: - case 222: + case 190: + case 191: case 195: - case 197: + case 196: + case 223: case 224: + case 197: + case 199: + case 226: return ts.forEachChild(node, traverse); } } @@ -3537,22 +3609,22 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 173: + case 175: visitor(node); var operand = node.expression; if (operand) { traverse(operand); } + case 207: case 205: - case 203: + case 208: case 206: case 204: - case 202: return; default: if (isFunctionLike(node)) { var name_4 = node.name; - if (name_4 && name_4.kind === 128) { + if (name_4 && name_4.kind === 129) { traverse(name_4.expression); return; } @@ -3567,14 +3639,14 @@ var ts; function isVariableLike(node) { if (node) { switch (node.kind) { - case 153: + case 155: + case 229: + case 131: case 227: - case 130: - case 225: + case 134: case 133: - case 132: - case 226: - case 199: + case 228: + case 201: return true; } } @@ -3584,8 +3656,8 @@ var ts; function isAccessor(node) { if (node) { switch (node.kind) { - case 137: case 138: + case 139: return true; } } @@ -3594,26 +3666,26 @@ var ts; ts.isAccessor = isAccessor; function isClassLike(node) { if (node) { - return node.kind === 202 || node.kind === 175; + return node.kind === 204 || node.kind === 177; } } ts.isClassLike = isClassLike; function isFunctionLike(node) { if (node) { switch (node.kind) { - case 136: - case 163: - case 201: - case 164: - case 135: - case 134: case 137: + case 165: + case 203: + case 166: + case 136: + case 135: case 138: case 139: case 140: case 141: - case 143: - case 144: + case 142: + case 145: + case 146: return true; } } @@ -3621,11 +3693,11 @@ var ts; } ts.isFunctionLike = isFunctionLike; function isFunctionBlock(node) { - return node && node.kind === 180 && isFunctionLike(node.parent); + return node && node.kind === 182 && isFunctionLike(node.parent); } ts.isFunctionBlock = isFunctionBlock; function isObjectLiteralMethod(node) { - return node && node.kind === 135 && node.parent.kind === 155; + return node && node.kind === 136 && node.parent.kind === 157; } ts.isObjectLiteralMethod = isObjectLiteralMethod; function getContainingFunction(node) { @@ -3644,36 +3716,36 @@ var ts; return undefined; } switch (node.kind) { - case 128: - if (node.parent.parent.kind === 202) { + case 129: + if (node.parent.parent.kind === 204) { return node; } node = node.parent; break; - case 131: - if (node.parent.kind === 130 && isClassElement(node.parent.parent)) { + case 132: + if (node.parent.kind === 131 && isClassElement(node.parent.parent)) { node = node.parent.parent; } else if (isClassElement(node.parent)) { node = node.parent; } break; - case 164: + case 166: if (!includeArrowFunctions) { continue; } - case 201: - case 163: - case 206: - case 133: - case 132: - case 135: + case 203: + case 165: + case 208: case 134: + case 133: case 136: + case 135: case 137: case 138: - case 205: - case 228: + case 139: + case 207: + case 230: return node; } } @@ -3685,40 +3757,40 @@ var ts; if (!node) return node; switch (node.kind) { - case 128: - if (node.parent.parent.kind === 202) { + case 129: + if (node.parent.parent.kind === 204) { return node; } node = node.parent; break; - case 131: - if (node.parent.kind === 130 && isClassElement(node.parent.parent)) { + case 132: + if (node.parent.kind === 131 && isClassElement(node.parent.parent)) { node = node.parent.parent; } else if (isClassElement(node.parent)) { node = node.parent; } break; - case 201: - case 163: - case 164: + case 203: + case 165: + case 166: if (!includeFunctions) { continue; } - case 133: - case 132: - case 135: case 134: + case 133: case 136: + case 135: case 137: case 138: + case 139: return node; } } } ts.getSuperContainer = getSuperContainer; function getInvokedExpression(node) { - if (node.kind === 160) { + if (node.kind === 162) { return node.tag; } return node.expression; @@ -3726,40 +3798,40 @@ var ts; ts.getInvokedExpression = getInvokedExpression; function nodeCanBeDecorated(node) { switch (node.kind) { - case 202: + case 204: return true; - case 133: - return node.parent.kind === 202; - case 130: - return node.parent.body && node.parent.parent.kind === 202; - case 137: + case 134: + return node.parent.kind === 204; + case 131: + return node.parent.body && node.parent.parent.kind === 204; case 138: - case 135: - return node.body && node.parent.kind === 202; + case 139: + case 136: + return node.body && node.parent.kind === 204; } return false; } ts.nodeCanBeDecorated = nodeCanBeDecorated; function nodeIsDecorated(node) { switch (node.kind) { - case 202: + case 204: if (node.decorators) { return true; } return false; - case 133: - case 130: + case 134: + case 131: if (node.decorators) { return true; } return false; - case 137: + case 138: if (node.body && node.decorators) { return true; } return false; - case 135: - case 138: + case 136: + case 139: if (node.body && node.decorators) { return true; } @@ -3770,10 +3842,10 @@ var ts; ts.nodeIsDecorated = nodeIsDecorated; function childIsDecorated(node) { switch (node.kind) { - case 202: + case 204: return ts.forEach(node.members, nodeOrChildIsDecorated); - case 135: - case 138: + case 136: + case 139: return ts.forEach(node.parameters, nodeIsDecorated); } return false; @@ -3791,8 +3863,6 @@ var ts; case 95: case 80: case 9: - case 154: - case 155: case 156: case 157: case 158: @@ -3801,71 +3871,75 @@ var ts; case 161: case 162: case 163: - case 175: case 164: - case 167: case 165: + case 177: case 166: - case 168: case 169: + case 167: + case 168: case 170: case 171: - case 174: case 172: - case 10: - case 176: case 173: + case 176: + case 174: + case 10: + case 178: + case 175: return true; - case 127: - while (node.parent.kind === 127) { + case 128: + while (node.parent.kind === 128) { node = node.parent; } - return node.parent.kind === 145; + return node.parent.kind === 147; case 65: - if (node.parent.kind === 145) { + if (node.parent.kind === 147) { return true; } case 7: case 8: var parent_2 = node.parent; switch (parent_2.kind) { - case 199: - case 130: + case 201: + case 131: + case 134: case 133: - case 132: + case 229: case 227: - case 225: - case 153: + case 155: return parent_2.initializer === node; - case 183: - case 184: case 185: case 186: - case 192: - case 193: - case 194: - case 221: - case 196: - case 194: - return parent_2.expression === node; case 187: + case 188: + case 194: + case 195: + case 196: + case 223: + case 198: + case 196: + return parent_2.expression === node; + case 189: var forStatement = parent_2; - return (forStatement.initializer === node && forStatement.initializer.kind !== 200) || + return (forStatement.initializer === node && forStatement.initializer.kind !== 202) || forStatement.condition === node || forStatement.incrementor === node; - case 188: - case 189: + case 190: + case 191: var forInStatement = parent_2; - return (forInStatement.initializer === node && forInStatement.initializer.kind !== 200) || + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 202) || forInStatement.expression === node; - case 161: + case 163: return node === parent_2.expression; - case 178: + case 180: return node === parent_2.expression; - case 128: + case 129: return node === parent_2.expression; - case 131: + case 132: return true; + case 179: + return parent_2.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent_2); default: if (isExpression(parent_2)) { return true; @@ -3882,7 +3956,7 @@ var ts; } ts.isInstantiatedModule = isInstantiatedModule; function isExternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 && node.moduleReference.kind === 220; + return node.kind === 211 && node.moduleReference.kind === 222; } ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; function getExternalModuleImportEqualsDeclarationExpression(node) { @@ -3891,20 +3965,20 @@ var ts; } ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; function isInternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 && node.moduleReference.kind !== 220; + return node.kind === 211 && node.moduleReference.kind !== 222; } ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; function getExternalModuleName(node) { - if (node.kind === 210) { + if (node.kind === 212) { return node.moduleSpecifier; } - if (node.kind === 209) { + if (node.kind === 211) { var reference = node.moduleReference; - if (reference.kind === 220) { + if (reference.kind === 222) { return reference.expression; } } - if (node.kind === 216) { + if (node.kind === 218) { return node.moduleSpecifier; } } @@ -3912,15 +3986,15 @@ var ts; function hasQuestionToken(node) { if (node) { switch (node.kind) { - case 130: + case 131: return node.questionToken !== undefined; + case 136: case 135: - case 134: return node.questionToken !== undefined; - case 226: - case 225: + case 228: + case 227: + case 134: case 133: - case 132: return node.questionToken !== undefined; } } @@ -3928,9 +4002,9 @@ var ts; } ts.hasQuestionToken = hasQuestionToken; function isJSDocConstructSignature(node) { - return node.kind === 241 && + return node.kind === 243 && node.parameters.length > 0 && - node.parameters[0].type.kind === 243; + node.parameters[0].type.kind === 245; } ts.isJSDocConstructSignature = isJSDocConstructSignature; function getJSDocTag(node, kind) { @@ -3944,15 +4018,15 @@ var ts; } } function getJSDocTypeTag(node) { - return getJSDocTag(node, 249); + return getJSDocTag(node, 251); } ts.getJSDocTypeTag = getJSDocTypeTag; function getJSDocReturnTag(node) { - return getJSDocTag(node, 248); + return getJSDocTag(node, 250); } ts.getJSDocReturnTag = getJSDocReturnTag; function getJSDocTemplateTag(node) { - return getJSDocTag(node, 250); + return getJSDocTag(node, 252); } ts.getJSDocTemplateTag = getJSDocTemplateTag; function getCorrespondingJSDocParameterTag(parameter) { @@ -3961,7 +4035,7 @@ var ts; var docComment = parameter.parent.jsDocComment; if (docComment) { return ts.forEach(docComment.tags, function (t) { - if (t.kind === 247) { + if (t.kind === 249) { var parameterTag = t; var name_5 = parameterTag.preParameterName || parameterTag.postParameterName; if (name_5.text === parameterName) { @@ -3980,12 +4054,12 @@ var ts; function isRestParameter(node) { if (node) { if (node.parserContextFlags & 64) { - if (node.type && node.type.kind === 242) { + if (node.type && node.type.kind === 244) { return true; } var paramTag = getCorrespondingJSDocParameterTag(node); if (paramTag && paramTag.typeExpression) { - return paramTag.typeExpression.type.kind === 242; + return paramTag.typeExpression.type.kind === 244; } } return node.dotDotDotToken !== undefined; @@ -4006,7 +4080,7 @@ var ts; } ts.isTemplateLiteralKind = isTemplateLiteralKind; function isBindingPattern(node) { - return !!node && (node.kind === 152 || node.kind === 151); + return !!node && (node.kind === 154 || node.kind === 153); } ts.isBindingPattern = isBindingPattern; function isInAmbientContext(node) { @@ -4021,33 +4095,33 @@ var ts; ts.isInAmbientContext = isInAmbientContext; function isDeclaration(node) { switch (node.kind) { - case 164: - case 153: - case 202: - case 136: - case 205: - case 227: - case 218: - case 201: - case 163: - case 137: - case 211: - case 209: - case 214: - case 203: - case 135: - case 134: - case 206: - case 212: - case 130: - case 225: - case 133: - case 132: - case 138: - case 226: + case 166: + case 155: case 204: - case 129: - case 199: + case 137: + case 207: + case 229: + case 220: + case 203: + case 165: + case 138: + case 213: + case 211: + case 216: + case 205: + case 136: + case 135: + case 208: + case 214: + case 131: + case 227: + case 134: + case 133: + case 139: + case 228: + case 206: + case 130: + case 201: return true; } return false; @@ -4055,25 +4129,25 @@ var ts; ts.isDeclaration = isDeclaration; function isStatement(n) { switch (n.kind) { - case 191: - case 190: - case 198: - case 185: - case 183: - case 182: - case 188: - case 189: - case 187: - case 184: - case 195: - case 192: - case 194: - case 94: - case 197: - case 181: - case 186: case 193: - case 215: + case 192: + case 200: + case 187: + case 185: + case 184: + case 190: + case 191: + case 189: + case 186: + case 197: + case 194: + case 196: + case 94: + case 199: + case 183: + case 188: + case 195: + case 217: return true; default: return false; @@ -4082,13 +4156,13 @@ var ts; ts.isStatement = isStatement; function isClassElement(n) { switch (n.kind) { - case 136: - case 133: - case 135: case 137: - case 138: case 134: - case 141: + case 136: + case 138: + case 139: + case 135: + case 142: return true; default: return false; @@ -4100,7 +4174,7 @@ var ts; return false; } var parent = name.parent; - if (parent.kind === 214 || parent.kind === 218) { + if (parent.kind === 216 || parent.kind === 220) { if (parent.propertyName) { return true; } @@ -4111,13 +4185,43 @@ var ts; return false; } ts.isDeclarationName = isDeclarationName; + function isIdentifierName(node) { + var parent = node.parent; + switch (parent.kind) { + case 134: + case 133: + case 136: + case 135: + case 138: + case 139: + case 229: + case 227: + case 158: + return parent.name === node; + case 128: + if (parent.right === node) { + while (parent.kind === 128) { + parent = parent.parent; + } + return parent.kind === 147; + } + return false; + case 155: + case 216: + return parent.propertyName === node; + case 220: + return true; + } + return false; + } + ts.isIdentifierName = isIdentifierName; function isAliasSymbolDeclaration(node) { - return node.kind === 209 || - node.kind === 211 && !!node.name || - node.kind === 212 || + return node.kind === 211 || + node.kind === 213 && !!node.name || node.kind === 214 || - node.kind === 218 || - node.kind === 215 && node.expression.kind === 65; + node.kind === 216 || + node.kind === 220 || + node.kind === 217 && node.expression.kind === 65; } ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration; function getClassExtendsHeritageClauseElement(node) { @@ -4200,7 +4304,7 @@ var ts; } ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; function isKeyword(token) { - return 66 <= token && token <= 126; + return 66 <= token && token <= 127; } ts.isKeyword = isKeyword; function isTrivia(token) { @@ -4209,19 +4313,19 @@ var ts; ts.isTrivia = isTrivia; function hasDynamicName(declaration) { return declaration.name && - declaration.name.kind === 128 && + declaration.name.kind === 129 && !isWellKnownSymbolSyntactically(declaration.name.expression); } ts.hasDynamicName = hasDynamicName; function isWellKnownSymbolSyntactically(node) { - return node.kind === 156 && isESSymbolIdentifier(node.expression); + return node.kind === 158 && isESSymbolIdentifier(node.expression); } ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; function getPropertyNameForPropertyNameNode(name) { if (name.kind === 65 || name.kind === 8 || name.kind === 7) { return name.text; } - if (name.kind === 128) { + if (name.kind === 129) { var nameExpression = name.expression; if (isWellKnownSymbolSyntactically(nameExpression)) { var rightHandSideName = nameExpression.name.text; @@ -4256,18 +4360,18 @@ var ts; ts.isModifier = isModifier; function isParameterDeclaration(node) { var root = getRootDeclaration(node); - return root.kind === 130; + return root.kind === 131; } ts.isParameterDeclaration = isParameterDeclaration; function getRootDeclaration(node) { - while (node.kind === 153) { + while (node.kind === 155) { node = node.parent.parent; } return node; } ts.getRootDeclaration = getRootDeclaration; function nodeStartsNewLexicalEnvironment(n) { - return isFunctionLike(n) || n.kind === 206 || n.kind === 228; + return isFunctionLike(n) || n.kind === 208 || n.kind === 230; } ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment; function nodeIsSynthesized(node) { @@ -4491,7 +4595,7 @@ var ts; ts.getLineOfLocalPosition = getLineOfLocalPosition; function getFirstConstructorWithBody(node) { return ts.forEach(node.members, function (member) { - if (member.kind === 136 && nodeIsPresent(member.body)) { + if (member.kind === 137 && nodeIsPresent(member.body)) { return member; } }); @@ -4514,10 +4618,10 @@ var ts; var setAccessor; if (hasDynamicName(accessor)) { firstAccessor = accessor; - if (accessor.kind === 137) { + if (accessor.kind === 138) { getAccessor = accessor; } - else if (accessor.kind === 138) { + else if (accessor.kind === 139) { setAccessor = accessor; } else { @@ -4526,7 +4630,7 @@ var ts; } else { ts.forEach(declarations, function (member) { - if ((member.kind === 137 || member.kind === 138) + if ((member.kind === 138 || member.kind === 139) && (member.flags & 128) === (accessor.flags & 128)) { var memberName = getPropertyNameForPropertyNameNode(member.name); var accessorName = getPropertyNameForPropertyNameNode(accessor.name); @@ -4537,10 +4641,10 @@ var ts; else if (!secondAccessor) { secondAccessor = member; } - if (member.kind === 137 && !getAccessor) { + if (member.kind === 138 && !getAccessor) { getAccessor = member; } - if (member.kind === 138 && !setAccessor) { + if (member.kind === 139 && !setAccessor) { setAccessor = member; } } @@ -4661,22 +4765,22 @@ var ts; function isLeftHandSideExpression(expr) { if (expr) { switch (expr.kind) { - case 156: - case 157: - case 159: case 158: + case 159: + case 161: case 160: - case 154: case 162: - case 155: - case 175: - case 163: + case 156: + case 164: + case 157: + case 177: + case 165: case 65: case 9: case 7: case 8: case 10: - case 172: + case 174: case 80: case 89: case 93: @@ -4692,6 +4796,12 @@ var ts; return token >= 53 && token <= 64; } ts.isAssignmentOperator = isAssignmentOperator; + function isExpressionWithTypeArgumentsInClassExtendsClause(node) { + return node.kind === 179 && + node.parent.token === 79 && + node.parent.parent.kind === 204; + } + ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; function isSupportedExpressionWithTypeArguments(node) { return isSupportedExpressionWithTypeArgumentsRest(node.expression); } @@ -4700,7 +4810,7 @@ var ts; if (node.kind === 65) { return true; } - else if (node.kind === 156) { + else if (node.kind === 158) { return isSupportedExpressionWithTypeArgumentsRest(node.expression); } else { @@ -4708,8 +4818,8 @@ var ts; } } function isRightSideOfQualifiedNameOrPropertyAccess(node) { - return (node.parent.kind === 127 && node.parent.right === node) || - (node.parent.kind === 156 && node.parent.name === node); + return (node.parent.kind === 128 && node.parent.right === node) || + (node.parent.kind === 158 && node.parent.name === node); } ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess; function getLocalSymbolForExportDefault(symbol) { @@ -4836,6 +4946,12 @@ var ts; return start <= textSpanEnd(span) && end >= span.start; } ts.textSpanIntersectsWith = textSpanIntersectsWith; + function decodedTextSpanIntersectsWith(start1, length1, start2, length2) { + var end1 = start1 + length1; + var end2 = start2 + length2; + return start2 <= end1 && end2 >= start1; + } + ts.decodedTextSpanIntersectsWith = decodedTextSpanIntersectsWith; function textSpanIntersectsWithPosition(span, position) { return position <= textSpanEnd(span) && position >= span.start; } @@ -4906,9 +5022,9 @@ var ts; } ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions; function getTypeParameterOwner(d) { - if (d && d.kind === 129) { + if (d && d.kind === 130) { for (var current = d; current; current = current.parent) { - if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 203) { + if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 205) { return current; } } @@ -4920,7 +5036,7 @@ var ts; /// var ts; (function (ts) { - var nodeConstructors = new Array(252); + var nodeConstructors = new Array(254); ts.parseTime = 0; function getNodeConstructor(kind) { return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); @@ -4958,20 +5074,20 @@ var ts; var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; var cbNodes = cbNodeArray || cbNode; switch (node.kind) { - case 127: + case 128: return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); - case 129: + case 130: return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); - case 130: + case 131: + case 134: case 133: - case 132: - case 225: - case 226: - case 199: - case 153: + case 227: + case 228: + case 201: + case 155: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || @@ -4980,24 +5096,24 @@ var ts; visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); - case 143: - case 144: - case 139: + case 145: + case 146: case 140: case 141: + case 142: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 135: - case 134: case 136: + case 135: case 137: case 138: - case 163: - case 201: - case 164: + case 139: + case 165: + case 203: + case 166: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || @@ -5008,263 +5124,267 @@ var ts; visitNode(cbNode, node.type) || visitNode(cbNode, node.equalsGreaterThanToken) || visitNode(cbNode, node.body); - case 142: + case 144: return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); - case 145: - return visitNode(cbNode, node.exprName); - case 146: - return visitNodes(cbNodes, node.members); + case 143: + return visitNode(cbNode, node.parameterName) || + visitNode(cbNode, node.type); case 147: - return visitNode(cbNode, node.elementType); + return visitNode(cbNode, node.exprName); case 148: - return visitNodes(cbNodes, node.elementTypes); + return visitNodes(cbNodes, node.members); case 149: - return visitNodes(cbNodes, node.types); + return visitNode(cbNode, node.elementType); case 150: - return visitNode(cbNode, node.type); + return visitNodes(cbNodes, node.elementTypes); case 151: + return visitNodes(cbNodes, node.types); case 152: - return visitNodes(cbNodes, node.elements); + return visitNode(cbNode, node.type); + case 153: case 154: return visitNodes(cbNodes, node.elements); - case 155: - return visitNodes(cbNodes, node.properties); case 156: + return visitNodes(cbNodes, node.elements); + case 157: + return visitNodes(cbNodes, node.properties); + case 158: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.dotToken) || visitNode(cbNode, node.name); - case 157: + case 159: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); - case 158: - case 159: + case 160: + case 161: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); - case 160: + case 162: return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); - case 161: + case 163: return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); - case 162: - return visitNode(cbNode, node.expression); - case 165: - return visitNode(cbNode, node.expression); - case 166: + case 164: return visitNode(cbNode, node.expression); case 167: return visitNode(cbNode, node.expression); case 168: + return visitNode(cbNode, node.expression); + case 169: + return visitNode(cbNode, node.expression); + case 170: return visitNode(cbNode, node.operand); - case 173: + case 175: return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); - case 169: + case 171: return visitNode(cbNode, node.operand); - case 170: + case 172: return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); - case 171: + case 173: return visitNode(cbNode, node.condition) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.colonToken) || visitNode(cbNode, node.whenFalse); - case 174: + case 176: return visitNode(cbNode, node.expression); - case 180: - case 207: + case 182: + case 209: return visitNodes(cbNodes, node.statements); - case 228: + case 230: return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); - case 181: + case 183: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); - case 200: + case 202: return visitNodes(cbNodes, node.declarations); - case 183: + case 185: return visitNode(cbNode, node.expression); - case 184: + case 186: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); - case 185: + case 187: return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); - case 186: + case 188: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 187: + case 189: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.incrementor) || visitNode(cbNode, node.statement); - case 188: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); - case 189: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); case 190: - case 191: - return visitNode(cbNode, node.label); - case 192: - return visitNode(cbNode, node.expression); - case 193: - return visitNode(cbNode, node.expression) || + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); + case 191: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 192: + case 193: + return visitNode(cbNode, node.label); case 194: - return visitNode(cbNode, node.expression) || - visitNode(cbNode, node.caseBlock); - case 208: - return visitNodes(cbNodes, node.clauses); - case 221: - return visitNode(cbNode, node.expression) || - visitNodes(cbNodes, node.statements); - case 222: - return visitNodes(cbNodes, node.statements); + return visitNode(cbNode, node.expression); case 195: - return visitNode(cbNode, node.label) || + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 196: - return visitNode(cbNode, node.expression); + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.caseBlock); + case 210: + return visitNodes(cbNodes, node.clauses); + case 223: + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.statements); + case 224: + return visitNodes(cbNodes, node.statements); case 197: + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + case 198: + return visitNode(cbNode, node.expression); + case 199: return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); - case 224: + case 226: return visitNode(cbNode, node.variableDeclaration) || visitNode(cbNode, node.block); - case 131: + case 132: return visitNode(cbNode, node.expression); - case 202: - case 175: - return visitNodes(cbNodes, node.decorators) || - visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); - case 203: - return visitNodes(cbNodes, node.decorators) || - visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); case 204: + case 177: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || - visitNode(cbNode, node.type); + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || + visitNodes(cbNodes, node.members); case 205: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 227: - return visitNode(cbNode, node.name) || - visitNode(cbNode, node.initializer); case 206: + return visitNodes(cbNodes, node.decorators) || + visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNode(cbNode, node.type); + case 207: + return visitNodes(cbNodes, node.decorators) || + visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.members); + case 229: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + case 208: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.body); - case 209: + case 211: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); - case 210: + case 212: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.importClause) || visitNode(cbNode, node.moduleSpecifier); - case 211: + case 213: return visitNode(cbNode, node.name) || visitNode(cbNode, node.namedBindings); - case 212: + case 214: return visitNode(cbNode, node.name); - case 213: - case 217: + case 215: + case 219: return visitNodes(cbNodes, node.elements); - case 216: + case 218: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportClause) || visitNode(cbNode, node.moduleSpecifier); - case 214: - case 218: + case 216: + case 220: return visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.name); - case 215: + case 217: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.expression); - case 172: + case 174: return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); - case 178: + case 180: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); - case 128: + case 129: return visitNode(cbNode, node.expression); - case 223: + case 225: return visitNodes(cbNodes, node.types); - case 177: + case 179: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments); - case 220: + case 222: return visitNode(cbNode, node.expression); - case 219: + case 221: return visitNodes(cbNodes, node.decorators); - case 229: - return visitNode(cbNode, node.type); - case 233: - return visitNodes(cbNodes, node.types); - case 234: - return visitNodes(cbNodes, node.types); - case 232: - return visitNode(cbNode, node.elementType); - case 236: + case 231: return visitNode(cbNode, node.type); case 235: + return visitNodes(cbNodes, node.types); + case 236: + return visitNodes(cbNodes, node.types); + case 234: + return visitNode(cbNode, node.elementType); + case 238: return visitNode(cbNode, node.type); case 237: - return visitNodes(cbNodes, node.members); + return visitNode(cbNode, node.type); case 239: + return visitNodes(cbNodes, node.members); + case 241: return visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeArguments); - case 240: - return visitNode(cbNode, node.type); - case 241: - return visitNodes(cbNodes, node.parameters) || - visitNode(cbNode, node.type); case 242: return visitNode(cbNode, node.type); case 243: - return visitNode(cbNode, node.type); + return visitNodes(cbNodes, node.parameters) || + visitNode(cbNode, node.type); case 244: return visitNode(cbNode, node.type); - case 238: + case 245: + return visitNode(cbNode, node.type); + case 246: + return visitNode(cbNode, node.type); + case 240: return visitNode(cbNode, node.name) || visitNode(cbNode, node.type); - case 245: - return visitNodes(cbNodes, node.tags); case 247: + return visitNodes(cbNodes, node.tags); + case 249: return visitNode(cbNode, node.preParameterName) || visitNode(cbNode, node.typeExpression) || visitNode(cbNode, node.postParameterName); - case 248: - return visitNode(cbNode, node.typeExpression); - case 249: - return visitNode(cbNode, node.typeExpression); case 250: + return visitNode(cbNode, node.typeExpression); + case 251: + return visitNode(cbNode, node.typeExpression); + case 252: return visitNodes(cbNodes, node.typeParameters); } } @@ -5338,7 +5458,7 @@ var ts; sourceFile = createSourceFile(fileName, languageVersion); token = nextToken(); processReferenceComments(sourceFile); - sourceFile.statements = parseList(0, true, parseSourceElement); + sourceFile.statements = parseList(0, parseStatement); ts.Debug.assert(token === 1); sourceFile.endOfFileToken = parseTokenNode(); setExternalModuleIndicator(sourceFile); @@ -5359,9 +5479,9 @@ var ts; return; function visit(node) { switch (node.kind) { - case 181: - case 201: - case 130: + case 183: + case 203: + case 131: addJSDocComment(node); } forEachChild(node, visit); @@ -5399,7 +5519,7 @@ var ts; } Parser.fixupParentReferences = fixupParentReferences; function createSourceFile(fileName, languageVersion) { - var sourceFile = createNode(228, 0); + var sourceFile = createNode(230, 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; sourceFile.text = sourceText; @@ -5417,9 +5537,6 @@ var ts; contextFlags &= ~flag; } } - function setStrictModeContext(val) { - setContextFlag(val, 1); - } function setDisallowInContext(val) { setContextFlag(val, 2); } @@ -5490,9 +5607,6 @@ var ts; function inYieldContext() { return (contextFlags & 4) !== 0; } - function inStrictModeContext() { - return (contextFlags & 1) !== 0; - } function inGeneratorParameterContext() { return (contextFlags & 8) !== 0; } @@ -5701,7 +5815,7 @@ var ts; return token === 8 || token === 7 || isIdentifierOrKeyword(); } function parseComputedPropertyName() { - var node = createNode(128); + var node = createNode(129); parseExpected(18); var yieldContext = inYieldContext(); if (inGeneratorParameterContext()) { @@ -5755,23 +5869,21 @@ var ts; switch (parsingContext) { case 0: case 1: - return !(token === 22 && inErrorRecovery) && isStartOfModuleElement(); - case 2: - case 4: - return !(token === 22 && inErrorRecovery) && isStartOfStatement(); case 3: + return !(token === 22 && inErrorRecovery) && isStartOfStatement(); + case 2: return token === 67 || token === 73; - case 5: + case 4: return isStartOfTypeMember(); - case 6: + case 5: return lookAhead(isClassMemberStart) || (token === 22 && !inErrorRecovery); - case 7: + case 6: return token === 18 || isLiteralPropertyName(); - case 13: + case 12: return token === 18 || token === 35 || isLiteralPropertyName(); - case 10: + case 9: return isLiteralPropertyName(); - case 8: + case 7: if (token === 14) { return lookAhead(isValidHeritageClauseObjectLiteral); } @@ -5781,29 +5893,29 @@ var ts; else { return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword(); } - case 9: + case 8: return isIdentifierOrPattern(); - case 11: + case 10: return token === 23 || token === 21 || isIdentifierOrPattern(); - case 16: - return isIdentifier(); - case 12: - case 14: - return token === 23 || token === 21 || isStartOfExpression(); case 15: + return isIdentifier(); + case 11: + case 13: + return token === 23 || token === 21 || isStartOfExpression(); + case 14: return isStartOfParameter(); + case 16: case 17: - case 18: return token === 23 || isStartOfType(); - case 19: + case 18: return isHeritageClause(); - case 20: + case 19: return isIdentifierOrKeyword(); + case 20: case 21: - case 22: - case 24: - return JSDocParser.isJSDocType(); case 23: + return JSDocParser.isJSDocType(); + case 22: return isSimplePropertyName(); } ts.Debug.fail("Non-exhaustive case in 'isListElement'."); @@ -5838,41 +5950,40 @@ var ts; switch (kind) { case 1: case 2: - case 3: + case 4: case 5: case 6: - case 7: - case 13: - case 10: - case 20: - return token === 15; - case 4: - return token === 15 || token === 67 || token === 73; - case 8: - return token === 14 || token === 79 || token === 102; - case 9: - return isVariableDeclaratorListTerminator(); - case 16: - return token === 25 || token === 16 || token === 14 || token === 79 || token === 102; case 12: - return token === 17 || token === 22; - case 14: - case 18: - case 11: - return token === 19; - case 15: - return token === 17 || token === 19; - case 17: - return token === 25 || token === 16; + case 9: case 19: + return token === 15; + case 3: + return token === 15 || token === 67 || token === 73; + case 7: + return token === 14 || token === 79 || token === 102; + case 8: + return isVariableDeclaratorListTerminator(); + case 15: + return token === 25 || token === 16 || token === 14 || token === 79 || token === 102; + case 11: + return token === 17 || token === 22; + case 13: + case 17: + case 10: + return token === 19; + case 14: + return token === 17 || token === 19; + case 16: + return token === 25 || token === 16; + case 18: return token === 14 || token === 15; - case 21: + case 20: return token === 17 || token === 51 || token === 15; - case 22: + case 21: return token === 25 || token === 15; - case 24: - return token === 19 || token === 15; case 23: + return token === 19 || token === 15; + case 22: return token === 15; } } @@ -5889,7 +6000,7 @@ var ts; return false; } function isInSomeParsingContext() { - for (var kind = 0; kind < 25; kind++) { + for (var kind = 0; kind < 24; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, true) || isListTerminator(kind)) { return true; @@ -5898,43 +6009,25 @@ var ts; } return false; } - function parseList(kind, checkForStrictMode, parseElement) { + function parseList(kind, parseElement) { var saveParsingContext = parsingContext; parsingContext |= 1 << kind; var result = []; result.pos = getNodePos(); - var savedStrictModeContext = inStrictModeContext(); while (!isListTerminator(kind)) { if (isListElement(kind, false)) { var element = parseListElement(kind, parseElement); result.push(element); - if (checkForStrictMode && !inStrictModeContext()) { - if (ts.isPrologueDirective(element)) { - if (isUseStrictPrologueDirective(element)) { - setStrictModeContext(true); - checkForStrictMode = false; - } - } - else { - checkForStrictMode = false; - } - } continue; } if (abortParsingListOrMoveToNextToken(kind)) { break; } } - setStrictModeContext(savedStrictModeContext); result.end = getNodeEnd(); parsingContext = saveParsingContext; return result; } - function isUseStrictPrologueDirective(node) { - ts.Debug.assert(ts.isPrologueDirective(node)); - var nodeText = ts.getTextOfNodeFromSourceText(sourceText, node.expression); - return nodeText === '"use strict"' || nodeText === "'use strict'"; - } function parseListElement(parsingContext, parseElement) { var node = currentNode(parsingContext); if (node) { @@ -5959,7 +6052,7 @@ var ts; if (ts.containsParseError(node)) { return undefined; } - var nodeContextFlags = node.parserContextFlags & 63; + var nodeContextFlags = node.parserContextFlags & 62; if (nodeContextFlags !== contextFlags) { return undefined; } @@ -5975,61 +6068,47 @@ var ts; } function canReuseNode(node, parsingContext) { switch (parsingContext) { - case 1: - return isReusableModuleElement(node); - case 6: - return isReusableClassMember(node); - case 3: - return isReusableSwitchClause(node); - case 2: - case 4: - return isReusableStatement(node); - case 7: - return isReusableEnumMember(node); case 5: + return isReusableClassMember(node); + case 2: + return isReusableSwitchClause(node); + case 0: + case 1: + case 3: + return isReusableStatement(node); + case 6: + return isReusableEnumMember(node); + case 4: return isReusableTypeMember(node); - case 9: - return isReusableVariableDeclaration(node); - case 15: - return isReusableParameter(node); - case 19: - case 16: - case 18: - case 17: - case 12: - case 13: case 8: - } - return false; - } - function isReusableModuleElement(node) { - if (node) { - switch (node.kind) { - case 210: - case 209: - case 216: - case 215: - case 202: - case 203: - case 206: - case 205: - return true; - } - return isReusableStatement(node); + return isReusableVariableDeclaration(node); + case 14: + return isReusableParameter(node); + case 18: + case 15: + case 17: + case 16: + case 11: + case 12: + case 7: } return false; } function isReusableClassMember(node) { if (node) { switch (node.kind) { - case 136: - case 141: - case 135: case 137: + case 142: case 138: - case 133: - case 179: + case 139: + case 134: + case 181: return true; + case 136: + var methodDeclaration = node; + var nameIsConstructor = methodDeclaration.name.kind === 65 && + methodDeclaration.name.originalKeywordKind === 114; + return !nameIsConstructor; } } return false; @@ -6037,8 +6116,8 @@ var ts; function isReusableSwitchClause(node) { if (node) { switch (node.kind) { - case 221: - case 222: + case 223: + case 224: return true; } } @@ -6047,56 +6126,65 @@ var ts; function isReusableStatement(node) { if (node) { switch (node.kind) { - case 201: - case 181: - case 180: - case 184: + case 203: case 183: - case 196: - case 192: - case 194: - case 191: - case 190: - case 188: - case 189: - case 187: - case 186: - case 193: case 182: - case 197: - case 195: + case 186: case 185: case 198: + case 194: + case 196: + case 193: + case 192: + case 190: + case 191: + case 189: + case 188: + case 195: + case 184: + case 199: + case 197: + case 187: + case 200: + case 212: + case 211: + case 218: + case 217: + case 208: + case 204: + case 205: + case 207: + case 206: return true; } } return false; } function isReusableEnumMember(node) { - return node.kind === 227; + return node.kind === 229; } function isReusableTypeMember(node) { if (node) { switch (node.kind) { - case 140: - case 134: case 141: - case 132: - case 139: + case 135: + case 142: + case 133: + case 140: return true; } } return false; } function isReusableVariableDeclaration(node) { - if (node.kind !== 199) { + if (node.kind !== 201) { return false; } var variableDeclarator = node; return variableDeclarator.initializer === undefined; } function isReusableParameter(node) { - if (node.kind !== 130) { + if (node.kind !== 131) { return false; } var parameter = node; @@ -6114,29 +6202,28 @@ var ts; switch (context) { case 0: return ts.Diagnostics.Declaration_or_statement_expected; case 1: return ts.Diagnostics.Declaration_or_statement_expected; - case 2: return ts.Diagnostics.Statement_expected; - case 3: return ts.Diagnostics.case_or_default_expected; - case 4: return ts.Diagnostics.Statement_expected; - case 5: return ts.Diagnostics.Property_or_signature_expected; - case 6: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; - case 7: return ts.Diagnostics.Enum_member_expected; - case 8: return ts.Diagnostics.Expression_expected; - case 9: return ts.Diagnostics.Variable_declaration_expected; - case 10: return ts.Diagnostics.Property_destructuring_pattern_expected; - case 11: return ts.Diagnostics.Array_element_destructuring_pattern_expected; - case 12: return ts.Diagnostics.Argument_expression_expected; - case 13: return ts.Diagnostics.Property_assignment_expected; - case 14: return ts.Diagnostics.Expression_or_comma_expected; - case 15: return ts.Diagnostics.Parameter_declaration_expected; - case 16: return ts.Diagnostics.Type_parameter_declaration_expected; - case 17: return ts.Diagnostics.Type_argument_expected; - case 18: return ts.Diagnostics.Type_expected; - case 19: return ts.Diagnostics.Unexpected_token_expected; - case 20: return ts.Diagnostics.Identifier_expected; - case 21: return ts.Diagnostics.Parameter_declaration_expected; - case 22: return ts.Diagnostics.Type_argument_expected; - case 24: return ts.Diagnostics.Type_expected; - case 23: return ts.Diagnostics.Property_assignment_expected; + case 2: return ts.Diagnostics.case_or_default_expected; + case 3: return ts.Diagnostics.Statement_expected; + case 4: return ts.Diagnostics.Property_or_signature_expected; + case 5: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; + case 6: return ts.Diagnostics.Enum_member_expected; + case 7: return ts.Diagnostics.Expression_expected; + case 8: return ts.Diagnostics.Variable_declaration_expected; + case 9: return ts.Diagnostics.Property_destructuring_pattern_expected; + case 10: return ts.Diagnostics.Array_element_destructuring_pattern_expected; + case 11: return ts.Diagnostics.Argument_expression_expected; + case 12: return ts.Diagnostics.Property_assignment_expected; + case 13: return ts.Diagnostics.Expression_or_comma_expected; + case 14: return ts.Diagnostics.Parameter_declaration_expected; + case 15: return ts.Diagnostics.Type_parameter_declaration_expected; + case 16: return ts.Diagnostics.Type_argument_expected; + case 17: return ts.Diagnostics.Type_expected; + case 18: return ts.Diagnostics.Unexpected_token_expected; + case 19: return ts.Diagnostics.Identifier_expected; + case 20: return ts.Diagnostics.Parameter_declaration_expected; + case 21: return ts.Diagnostics.Type_argument_expected; + case 23: return ts.Diagnostics.Type_expected; + case 22: return ts.Diagnostics.Property_assignment_expected; } } ; @@ -6195,7 +6282,7 @@ var ts; function parseEntityName(allowReservedWords, diagnosticMessage) { var entity = parseIdentifier(diagnosticMessage); while (parseOptional(20)) { - var node = createNode(127, entity.pos); + var node = createNode(128, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -6203,7 +6290,7 @@ var ts; return entity; } function parseRightSideOfDot(allowIdentifierNames) { - if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord()) { + if (scanner.hasPrecedingLineBreak() && isIdentifierOrKeyword()) { var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); if (matchesPattern) { return createMissingNode(65, true, ts.Diagnostics.Identifier_expected); @@ -6212,7 +6299,7 @@ var ts; return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); } function parseTemplateExpression() { - var template = createNode(172); + var template = createNode(174); template.head = parseLiteralNode(); ts.Debug.assert(template.head.kind === 11, "Template head has wrong token kind"); var templateSpans = []; @@ -6225,7 +6312,7 @@ var ts; return finishNode(template); } function parseTemplateSpan() { - var span = createNode(178); + var span = createNode(180); span.expression = allowInAnd(parseExpression); var literal; if (token === 15) { @@ -6258,22 +6345,30 @@ var ts; } return node; } - function parseTypeReference() { - var node = createNode(142); - node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + function parseTypeReferenceOrTypePredicate() { + var typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + if (typeName.kind === 65 && token === 117 && !scanner.hasPrecedingLineBreak()) { + nextToken(); + var node_1 = createNode(143, typeName.pos); + node_1.parameterName = typeName; + node_1.type = parseType(); + return finishNode(node_1); + } + var node = createNode(144, typeName.pos); + node.typeName = typeName; if (!scanner.hasPrecedingLineBreak() && token === 24) { - node.typeArguments = parseBracketedList(17, parseType, 24, 25); + node.typeArguments = parseBracketedList(16, parseType, 24, 25); } return finishNode(node); } function parseTypeQuery() { - var node = createNode(145); + var node = createNode(147); parseExpected(97); node.exprName = parseEntityName(true); return finishNode(node); } function parseTypeParameter() { - var node = createNode(129); + var node = createNode(130); node.name = parseIdentifier(); if (parseOptional(79)) { if (isStartOfType() || !isStartOfExpression()) { @@ -6287,7 +6382,7 @@ var ts; } function parseTypeParameters() { if (token === 24) { - return parseBracketedList(16, parseTypeParameter, 24, 25); + return parseBracketedList(15, parseTypeParameter, 24, 25); } } function parseParameterType() { @@ -6308,7 +6403,7 @@ var ts; } } function parseParameter() { - var node = createNode(130); + var node = createNode(131); node.decorators = parseDecorators(); setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(21); @@ -6342,7 +6437,7 @@ var ts; var savedGeneratorParameterContext = inGeneratorParameterContext(); setYieldContext(yieldAndGeneratorParameterContext); setGeneratorParameterContext(yieldAndGeneratorParameterContext); - var result = parseDelimitedList(15, parseParameter); + var result = parseDelimitedList(14, parseParameter); setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); if (!parseExpected(17) && requireCompleteParameterList) { @@ -6360,7 +6455,7 @@ var ts; } function parseSignatureMember(kind) { var node = createNode(kind); - if (kind === 140) { + if (kind === 141) { parseExpected(88); } fillSignature(51, false, false, node); @@ -6400,10 +6495,10 @@ var ts; return token === 51 || token === 23 || token === 19; } function parseIndexSignatureDeclaration(fullStart, decorators, modifiers) { - var node = createNode(141, fullStart); + var node = createNode(142, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - node.parameters = parseBracketedList(15, parseParameter, 18, 19); + node.parameters = parseBracketedList(14, parseParameter, 18, 19); node.type = parseTypeAnnotation(); parseTypeMemberSemicolon(); return finishNode(node); @@ -6413,7 +6508,7 @@ var ts; var name = parsePropertyName(); var questionToken = parseOptionalToken(50); if (token === 16 || token === 24) { - var method = createNode(134, fullStart); + var method = createNode(135, fullStart); method.name = name; method.questionToken = questionToken; fillSignature(51, false, false, method); @@ -6421,7 +6516,7 @@ var ts; return finishNode(method); } else { - var property = createNode(132, fullStart); + var property = createNode(133, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -6463,14 +6558,14 @@ var ts; switch (token) { case 16: case 24: - return parseSignatureMember(139); + return parseSignatureMember(140); case 18: return isIndexSignature() ? parseIndexSignatureDeclaration(scanner.getStartPos(), undefined, undefined) : parsePropertyOrMethodSignature(); case 88: if (lookAhead(isStartOfConstructSignature)) { - return parseSignatureMember(140); + return parseSignatureMember(141); } case 8: case 7: @@ -6500,14 +6595,14 @@ var ts; return token === 16 || token === 24; } function parseTypeLiteral() { - var node = createNode(146); + var node = createNode(148); node.members = parseObjectTypeMembers(); return finishNode(node); } function parseObjectTypeMembers() { var members; if (parseExpected(14)) { - members = parseList(5, false, parseTypeMember); + members = parseList(4, parseTypeMember); parseExpected(15); } else { @@ -6516,12 +6611,12 @@ var ts; return members; } function parseTupleType() { - var node = createNode(148); - node.elementTypes = parseBracketedList(18, parseType, 18, 19); + var node = createNode(150); + node.elementTypes = parseBracketedList(17, parseType, 18, 19); return finishNode(node); } function parseParenthesizedType() { - var node = createNode(150); + var node = createNode(152); parseExpected(16); node.type = parseType(); parseExpected(17); @@ -6529,7 +6624,7 @@ var ts; } function parseFunctionOrConstructorType(kind) { var node = createNode(kind); - if (kind === 144) { + if (kind === 146) { parseExpected(88); } fillSignature(32, false, false, node); @@ -6542,12 +6637,12 @@ var ts; function parseNonArrayType() { switch (token) { case 112: - case 122: - case 120: - case 113: case 123: + case 121: + case 113: + case 124: var node = tryParse(parseKeywordAndNoDot); - return node || parseTypeReference(); + return node || parseTypeReferenceOrTypePredicate(); case 99: return parseTokenNode(); case 97: @@ -6559,16 +6654,16 @@ var ts; case 16: return parseParenthesizedType(); default: - return parseTypeReference(); + return parseTypeReferenceOrTypePredicate(); } } function isStartOfType() { switch (token) { case 112: - case 122: - case 120: - case 113: case 123: + case 121: + case 113: + case 124: case 99: case 97: case 14: @@ -6590,7 +6685,7 @@ var ts; var type = parseNonArrayType(); while (!scanner.hasPrecedingLineBreak() && parseOptional(18)) { parseExpected(19); - var node = createNode(147, type.pos); + var node = createNode(149, type.pos); node.elementType = type; type = finishNode(node); } @@ -6605,7 +6700,7 @@ var ts; types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(149, type.pos); + var node = createNode(151, type.pos); node.types = types; type = finishNode(node); } @@ -6650,10 +6745,10 @@ var ts; } function parseTypeWorker() { if (isStartOfFunctionType()) { - return parseFunctionOrConstructorType(143); + return parseFunctionOrConstructorType(145); } if (token === 88) { - return parseFunctionOrConstructorType(144); + return parseFunctionOrConstructorType(146); } return parseUnionTypeOrHigher(); } @@ -6774,10 +6869,7 @@ var ts; if (inYieldContext()) { return true; } - if (inStrictModeContext()) { - return true; - } - return lookAhead(nextTokenIsIdentifierOnSameLine); + return lookAhead(nextTokenIsIdentifierOrKeywordOrNumberOnSameLine); } return false; } @@ -6786,7 +6878,7 @@ var ts; return !scanner.hasPrecedingLineBreak() && isIdentifier(); } function parseYieldExpression() { - var node = createNode(173); + var node = createNode(175); nextToken(); if (!scanner.hasPrecedingLineBreak() && (token === 35 || isStartOfExpression())) { @@ -6800,8 +6892,8 @@ var ts; } function parseSimpleArrowFunctionExpression(identifier) { ts.Debug.assert(token === 32, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(164, identifier.pos); - var parameter = createNode(130, identifier.pos); + var node = createNode(166, identifier.pos); + var parameter = createNode(131, identifier.pos); parameter.name = identifier; finishNode(parameter); node.parameters = [parameter]; @@ -6879,7 +6971,7 @@ var ts; return parseParenthesizedArrowFunctionExpressionHead(false); } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { - var node = createNode(164); + var node = createNode(166); fillSignature(51, false, !allowAmbiguity, node); if (!node.parameters) { return undefined; @@ -6907,7 +6999,7 @@ var ts; if (!questionToken) { return leftOperand; } - var node = createNode(171, leftOperand.pos); + var node = createNode(173, leftOperand.pos); node.condition = leftOperand; node.questionToken = questionToken; node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher); @@ -6920,7 +7012,7 @@ var ts; return parseBinaryExpressionRest(precedence, leftOperand); } function isInOrOfKeyword(t) { - return t === 86 || t === 126; + return t === 86 || t === 127; } function parseBinaryExpressionRest(precedence, leftOperand) { while (true) { @@ -6981,33 +7073,33 @@ var ts; return -1; } function makeBinaryExpression(left, operatorToken, right) { - var node = createNode(170, left.pos); + var node = createNode(172, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; return finishNode(node); } function parsePrefixUnaryExpression() { - var node = createNode(168); + var node = createNode(170); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseDeleteExpression() { - var node = createNode(165); + var node = createNode(167); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(166); + var node = createNode(168); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(167); + var node = createNode(169); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); @@ -7037,7 +7129,7 @@ var ts; var expression = parseLeftHandSideExpressionOrHigher(); ts.Debug.assert(ts.isLeftHandSideExpression(expression)); if ((token === 38 || token === 39) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(169, expression.pos); + var node = createNode(171, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -7060,14 +7152,14 @@ var ts; if (token === 16 || token === 20) { return expression; } - var node = createNode(156, expression.pos); + var node = createNode(158, expression.pos); node.expression = expression; node.dotToken = parseExpectedToken(20, false, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); node.name = parseRightSideOfDot(true); return finishNode(node); } function parseTypeAssertion() { - var node = createNode(161); + var node = createNode(163); parseExpected(24); node.type = parseType(); parseExpected(25); @@ -7078,7 +7170,7 @@ var ts; while (true) { var dotToken = parseOptionalToken(20); if (dotToken) { - var propertyAccess = createNode(156, expression.pos); + var propertyAccess = createNode(158, expression.pos); propertyAccess.expression = expression; propertyAccess.dotToken = dotToken; propertyAccess.name = parseRightSideOfDot(true); @@ -7086,7 +7178,7 @@ var ts; continue; } if (!inDecoratorContext() && parseOptional(18)) { - var indexedAccess = createNode(157, expression.pos); + var indexedAccess = createNode(159, expression.pos); indexedAccess.expression = expression; if (token !== 19) { indexedAccess.argumentExpression = allowInAnd(parseExpression); @@ -7100,7 +7192,7 @@ var ts; continue; } if (token === 10 || token === 11) { - var tagExpression = createNode(160, expression.pos); + var tagExpression = createNode(162, expression.pos); tagExpression.tag = expression; tagExpression.template = token === 10 ? parseLiteralNode() @@ -7119,7 +7211,7 @@ var ts; if (!typeArguments) { return expression; } - var callExpr = createNode(158, expression.pos); + var callExpr = createNode(160, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); @@ -7127,7 +7219,7 @@ var ts; continue; } else if (token === 16) { - var callExpr = createNode(158, expression.pos); + var callExpr = createNode(160, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -7138,7 +7230,7 @@ var ts; } function parseArgumentList() { parseExpected(16); - var result = parseDelimitedList(12, parseArgumentExpression); + var result = parseDelimitedList(11, parseArgumentExpression); parseExpected(17); return result; } @@ -7146,7 +7238,7 @@ var ts; if (!parseOptional(24)) { return undefined; } - var typeArguments = parseDelimitedList(17, parseType); + var typeArguments = parseDelimitedList(16, parseType); if (!parseExpected(25)) { return undefined; } @@ -7217,42 +7309,42 @@ var ts; return parseIdentifier(ts.Diagnostics.Expression_expected); } function parseParenthesizedExpression() { - var node = createNode(162); + var node = createNode(164); parseExpected(16); node.expression = allowInAnd(parseExpression); parseExpected(17); return finishNode(node); } function parseSpreadElement() { - var node = createNode(174); + var node = createNode(176); parseExpected(21); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } function parseArgumentOrArrayLiteralElement() { return token === 21 ? parseSpreadElement() : - token === 23 ? createNode(176) : + token === 23 ? createNode(178) : parseAssignmentExpressionOrHigher(); } function parseArgumentExpression() { return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement); } function parseArrayLiteralExpression() { - var node = createNode(154); + var node = createNode(156); parseExpected(18); if (scanner.hasPrecedingLineBreak()) node.flags |= 512; - node.elements = parseDelimitedList(14, parseArgumentOrArrayLiteralElement); + node.elements = parseDelimitedList(13, parseArgumentOrArrayLiteralElement); parseExpected(19); return finishNode(node); } function tryParseAccessorDeclaration(fullStart, decorators, modifiers) { if (parseContextualModifier(116)) { - return parseAccessorDeclaration(137, fullStart, decorators, modifiers); - } - else if (parseContextualModifier(121)) { return parseAccessorDeclaration(138, fullStart, decorators, modifiers); } + else if (parseContextualModifier(122)) { + return parseAccessorDeclaration(139, fullStart, decorators, modifiers); + } return undefined; } function parseObjectLiteralElement() { @@ -7272,13 +7364,13 @@ var ts; return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken); } if ((token === 23 || token === 15) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(226, fullStart); + var shorthandDeclaration = createNode(228, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(225, fullStart); + var propertyAssignment = createNode(227, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; parseExpected(51); @@ -7287,12 +7379,12 @@ var ts; } } function parseObjectLiteralExpression() { - var node = createNode(155); + var node = createNode(157); parseExpected(14); if (scanner.hasPrecedingLineBreak()) { node.flags |= 512; } - node.properties = parseDelimitedList(13, parseObjectLiteralElement, true); + node.properties = parseDelimitedList(12, parseObjectLiteralElement, true); parseExpected(15); return finishNode(node); } @@ -7301,7 +7393,7 @@ var ts; if (saveDecoratorContext) { setDecoratorContext(false); } - var node = createNode(163); + var node = createNode(165); parseExpected(83); node.asteriskToken = parseOptionalToken(35); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); @@ -7316,7 +7408,7 @@ var ts; return isIdentifier() ? parseIdentifier() : undefined; } function parseNewExpression() { - var node = createNode(159); + var node = createNode(161); parseExpected(88); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); @@ -7325,10 +7417,10 @@ var ts; } return finishNode(node); } - function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { - var node = createNode(180); + function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) { + var node = createNode(182); if (parseExpected(14, diagnosticMessage) || ignoreMissingOpenBrace) { - node.statements = parseList(2, checkForStrictMode, parseStatement); + node.statements = parseList(1, parseStatement); parseExpected(15); } else { @@ -7343,7 +7435,7 @@ var ts; if (saveDecoratorContext) { setDecoratorContext(false); } - var block = parseBlock(ignoreMissingOpenBrace, true, diagnosticMessage); + var block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage); if (saveDecoratorContext) { setDecoratorContext(true); } @@ -7351,12 +7443,12 @@ var ts; return block; } function parseEmptyStatement() { - var node = createNode(182); + var node = createNode(184); parseExpected(22); return finishNode(node); } function parseIfStatement() { - var node = createNode(184); + var node = createNode(186); parseExpected(84); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -7366,7 +7458,7 @@ var ts; return finishNode(node); } function parseDoStatement() { - var node = createNode(185); + var node = createNode(187); parseExpected(75); node.statement = parseStatement(); parseExpected(100); @@ -7377,7 +7469,7 @@ var ts; return finishNode(node); } function parseWhileStatement() { - var node = createNode(186); + var node = createNode(188); parseExpected(100); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -7400,21 +7492,21 @@ var ts; } var forOrForInOrForOfStatement; if (parseOptional(86)) { - var forInStatement = createNode(188, pos); + var forInStatement = createNode(190, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); parseExpected(17); forOrForInOrForOfStatement = forInStatement; } - else if (parseOptional(126)) { - var forOfStatement = createNode(189, pos); + else if (parseOptional(127)) { + var forOfStatement = createNode(191, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(17); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(187, pos); + var forStatement = createNode(189, pos); forStatement.initializer = initializer; parseExpected(22); if (token !== 22 && token !== 17) { @@ -7432,7 +7524,7 @@ var ts; } function parseBreakOrContinueStatement(kind) { var node = createNode(kind); - parseExpected(kind === 191 ? 66 : 71); + parseExpected(kind === 193 ? 66 : 71); if (!canParseSemicolon()) { node.label = parseIdentifier(); } @@ -7440,7 +7532,7 @@ var ts; return finishNode(node); } function parseReturnStatement() { - var node = createNode(192); + var node = createNode(194); parseExpected(90); if (!canParseSemicolon()) { node.expression = allowInAnd(parseExpression); @@ -7449,7 +7541,7 @@ var ts; return finishNode(node); } function parseWithStatement() { - var node = createNode(193); + var node = createNode(195); parseExpected(101); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -7458,32 +7550,32 @@ var ts; return finishNode(node); } function parseCaseClause() { - var node = createNode(221); + var node = createNode(223); parseExpected(67); node.expression = allowInAnd(parseExpression); parseExpected(51); - node.statements = parseList(4, false, parseStatement); + node.statements = parseList(3, parseStatement); return finishNode(node); } function parseDefaultClause() { - var node = createNode(222); + var node = createNode(224); parseExpected(73); parseExpected(51); - node.statements = parseList(4, false, parseStatement); + node.statements = parseList(3, parseStatement); return finishNode(node); } function parseCaseOrDefaultClause() { return token === 67 ? parseCaseClause() : parseDefaultClause(); } function parseSwitchStatement() { - var node = createNode(194); + var node = createNode(196); parseExpected(92); parseExpected(16); node.expression = allowInAnd(parseExpression); parseExpected(17); - var caseBlock = createNode(208, scanner.getStartPos()); + var caseBlock = createNode(210, scanner.getStartPos()); parseExpected(14); - caseBlock.clauses = parseList(3, false, parseCaseOrDefaultClause); + caseBlock.clauses = parseList(2, parseCaseOrDefaultClause); parseExpected(15); node.caseBlock = finishNode(caseBlock); return finishNode(node); @@ -7491,35 +7583,35 @@ var ts; function parseThrowStatement() { // ThrowStatement[Yield] : // throw [no LineTerminator here]Expression[In, ?Yield]; - var node = createNode(196); + var node = createNode(198); parseExpected(94); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); return finishNode(node); } function parseTryStatement() { - var node = createNode(197); + var node = createNode(199); parseExpected(96); - node.tryBlock = parseBlock(false, false); + node.tryBlock = parseBlock(false); node.catchClause = token === 68 ? parseCatchClause() : undefined; if (!node.catchClause || token === 81) { parseExpected(81); - node.finallyBlock = parseBlock(false, false); + node.finallyBlock = parseBlock(false); } return finishNode(node); } function parseCatchClause() { - var result = createNode(224); + var result = createNode(226); parseExpected(68); if (parseExpected(16)) { result.variableDeclaration = parseVariableDeclaration(); } parseExpected(17); - result.block = parseBlock(false, false); + result.block = parseBlock(false); return finishNode(result); } function parseDebuggerStatement() { - var node = createNode(198); + var node = createNode(200); parseExpected(72); parseSemicolon(); return finishNode(node); @@ -7528,13 +7620,13 @@ var ts; var fullStart = scanner.getStartPos(); var expression = allowInAnd(parseExpression); if (expression.kind === 65 && parseOptional(51)) { - var labeledStatement = createNode(195, fullStart); + var labeledStatement = createNode(197, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(183, fullStart); + var expressionStatement = createNode(185, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); @@ -7547,7 +7639,11 @@ var ts; nextToken(); return isIdentifierOrKeyword() && !scanner.hasPrecedingLineBreak(); } - function parseDeclarationFlags() { + function nextTokenIsIdentifierOrKeywordOrNumberOnSameLine() { + nextToken(); + return (isIdentifierOrKeyword() || token === 7) && !scanner.hasPrecedingLineBreak(); + } + function isDeclaration() { while (true) { switch (token) { case 98: @@ -7556,28 +7652,30 @@ var ts; case 83: case 69: case 77: - return 1; + return true; case 103: - case 124: - nextToken(); - return isIdentifierOrKeyword() ? 1 : 0; - case 117: + case 125: + return nextTokenIsIdentifierOnSameLine(); case 118: + case 119: + return nextTokenIsIdentifierOrStringLiteralOnSameLine(); + case 115: nextToken(); - return isIdentifierOrKeyword() || token === 8 ? 2 : 0; + if (scanner.hasPrecedingLineBreak()) { + return false; + } + continue; case 85: nextToken(); return token === 8 || token === 35 || - token === 14 || isIdentifierOrKeyword() ? - 2 : 0; + token === 14 || isIdentifierOrKeyword(); case 78: nextToken(); if (token === 53 || token === 35 || token === 14 || token === 73) { - return 2; + return true; } continue; - case 115: case 108: case 106: case 107: @@ -7585,14 +7683,14 @@ var ts; nextToken(); continue; default: - return 0; + return false; } } } - function getDeclarationFlags() { - return lookAhead(parseDeclarationFlags); + function isStartOfDeclaration() { + return lookAhead(isDeclaration); } - function getStatementFlags() { + function isStartOfStatement() { switch (token) { case 52: case 22: @@ -7616,56 +7714,39 @@ var ts; case 72: case 68: case 81: - return 1; + return true; case 70: case 78: case 85: - return getDeclarationFlags(); + return isStartOfDeclaration(); case 115: case 103: - case 117: case 118: - case 124: - return getDeclarationFlags() || 1; + case 119: + case 125: + return true; case 108: case 106: case 107: case 109: - return getDeclarationFlags() || - (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? 0 : 1); + return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); default: - return isStartOfExpression() ? 1 : 0; + return isStartOfExpression(); } } - function isStartOfStatement() { - return (getStatementFlags() & 1) !== 0; - } - function isStartOfModuleElement() { - return (getStatementFlags() & 3) !== 0; - } - function nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine() { + function nextTokenIsIdentifierOrStartOfDestructuring() { nextToken(); - return !scanner.hasPrecedingLineBreak() && - (isIdentifier() || token === 14 || token === 18); + return isIdentifier() || token === 14 || token === 18; } function isLetDeclaration() { - return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine); + return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring); } function parseStatement() { - return parseModuleElementOfKind(1); - } - function parseModuleElement() { - return parseModuleElementOfKind(3); - } - function parseSourceElement() { - return parseModuleElementOfKind(3); - } - function parseModuleElementOfKind(flags) { switch (token) { case 22: return parseEmptyStatement(); case 14: - return parseBlock(false, false); + return parseBlock(false); case 98: return parseVariableStatement(scanner.getStartPos(), undefined, undefined); case 104: @@ -7686,9 +7767,9 @@ var ts; case 82: return parseForOrForInOrForOfStatement(); case 71: - return parseBreakOrContinueStatement(190); + return parseBreakOrContinueStatement(192); case 66: - return parseBreakOrContinueStatement(191); + return parseBreakOrContinueStatement(193); case 90: return parseReturnStatement(); case 101: @@ -7705,20 +7786,20 @@ var ts; return parseDebuggerStatement(); case 52: return parseDeclaration(); - case 70: + case 103: + case 125: + case 118: + case 119: case 115: + case 70: case 77: case 78: case 85: - case 103: - case 117: - case 118: case 106: case 107: case 108: case 109: - case 124: - if (getDeclarationFlags() & flags) { + if (isStartOfDeclaration()) { return parseDeclaration(); } break; @@ -7740,12 +7821,12 @@ var ts; return parseClassDeclaration(fullStart, decorators, modifiers); case 103: return parseInterfaceDeclaration(fullStart, decorators, modifiers); - case 124: + case 125: return parseTypeAliasDeclaration(fullStart, decorators, modifiers); case 77: return parseEnumDeclaration(fullStart, decorators, modifiers); - case 117: case 118: + case 119: return parseModuleDeclaration(fullStart, decorators, modifiers); case 85: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); @@ -7755,8 +7836,8 @@ var ts; parseExportAssignment(fullStart, decorators, modifiers) : parseExportDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { - var node = createMissingNode(219, true, ts.Diagnostics.Declaration_expected); + if (decorators || modifiers) { + var node = createMissingNode(221, true, ts.Diagnostics.Declaration_expected); node.pos = fullStart; node.decorators = decorators; setModifiers(node, modifiers); @@ -7764,6 +7845,10 @@ var ts; } } } + function nextTokenIsIdentifierOrStringLiteralOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token === 8); + } function parseFunctionBlockOrSemicolon(isGenerator, diagnosticMessage) { if (token !== 14 && canParseSemicolon()) { parseSemicolon(); @@ -7773,16 +7858,16 @@ var ts; } function parseArrayBindingElement() { if (token === 23) { - return createNode(176); + return createNode(178); } - var node = createNode(153); + var node = createNode(155); node.dotDotDotToken = parseOptionalToken(21); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(false); return finishNode(node); } function parseObjectBindingElement() { - var node = createNode(153); + var node = createNode(155); var tokenIsIdentifier = isIdentifier(); var propertyName = parsePropertyName(); if (tokenIsIdentifier && token !== 51) { @@ -7797,16 +7882,16 @@ var ts; return finishNode(node); } function parseObjectBindingPattern() { - var node = createNode(151); + var node = createNode(153); parseExpected(14); - node.elements = parseDelimitedList(10, parseObjectBindingElement); + node.elements = parseDelimitedList(9, parseObjectBindingElement); parseExpected(15); return finishNode(node); } function parseArrayBindingPattern() { - var node = createNode(152); + var node = createNode(154); parseExpected(18); - node.elements = parseDelimitedList(11, parseArrayBindingElement); + node.elements = parseDelimitedList(10, parseArrayBindingElement); parseExpected(19); return finishNode(node); } @@ -7823,7 +7908,7 @@ var ts; return parseIdentifier(); } function parseVariableDeclaration() { - var node = createNode(199); + var node = createNode(201); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -7832,7 +7917,7 @@ var ts; return finishNode(node); } function parseVariableDeclarationList(inForStatementInitializer) { - var node = createNode(200); + var node = createNode(202); switch (token) { case 98: break; @@ -7846,13 +7931,13 @@ var ts; ts.Debug.fail(); } nextToken(); - if (token === 126 && lookAhead(canFollowContextualOfKeyword)) { + if (token === 127 && lookAhead(canFollowContextualOfKeyword)) { node.declarations = createMissingList(); } else { var savedDisallowIn = inDisallowInContext(); setDisallowInContext(inForStatementInitializer); - node.declarations = parseDelimitedList(9, parseVariableDeclaration); + node.declarations = parseDelimitedList(8, parseVariableDeclaration); setDisallowInContext(savedDisallowIn); } return finishNode(node); @@ -7861,7 +7946,7 @@ var ts; return nextTokenIsIdentifier() && nextToken() === 17; } function parseVariableStatement(fullStart, decorators, modifiers) { - var node = createNode(181, fullStart); + var node = createNode(183, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(false); @@ -7869,7 +7954,7 @@ var ts; return finishNode(node); } function parseFunctionDeclaration(fullStart, decorators, modifiers) { - var node = createNode(201, fullStart); + var node = createNode(203, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(83); @@ -7880,7 +7965,7 @@ var ts; return finishNode(node); } function parseConstructorDeclaration(pos, decorators, modifiers) { - var node = createNode(136, pos); + var node = createNode(137, pos); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(114); @@ -7889,7 +7974,7 @@ var ts; return finishNode(node); } function parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { - var method = createNode(135, fullStart); + var method = createNode(136, fullStart); method.decorators = decorators; setModifiers(method, modifiers); method.asteriskToken = asteriskToken; @@ -7900,7 +7985,7 @@ var ts; return finishNode(method); } function parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken) { - var property = createNode(133, fullStart); + var property = createNode(134, fullStart); property.decorators = decorators; setModifiers(property, modifiers); property.name = name; @@ -7969,7 +8054,7 @@ var ts; return true; } if (idToken !== undefined) { - if (!ts.isKeyword(idToken) || idToken === 121 || idToken === 116) { + if (!ts.isKeyword(idToken) || idToken === 122 || idToken === 116) { return true; } switch (token) { @@ -7996,7 +8081,7 @@ var ts; decorators = []; decorators.pos = scanner.getStartPos(); } - var decorator = createNode(131, decoratorStart); + var decorator = createNode(132, decoratorStart); decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher); decorators.push(finishNode(decorator)); } @@ -8029,7 +8114,7 @@ var ts; } function parseClassElement() { if (token === 22) { - var result = createNode(179); + var result = createNode(181); nextToken(); return finishNode(result); } @@ -8053,21 +8138,19 @@ var ts; token === 18) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { var name_6 = createMissingNode(65, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_6, undefined); } ts.Debug.fail("Should not have attempted to parse class member declaration."); } function parseClassExpression() { - return parseClassDeclarationOrExpression(scanner.getStartPos(), undefined, undefined, 175); + return parseClassDeclarationOrExpression(scanner.getStartPos(), undefined, undefined, 177); } function parseClassDeclaration(fullStart, decorators, modifiers) { - return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 202); + return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 204); } function parseClassDeclarationOrExpression(fullStart, decorators, modifiers, kind) { - var savedStrictModeContext = inStrictModeContext(); - setStrictModeContext(true); var node = createNode(kind, fullStart); node.decorators = decorators; setModifiers(node, modifiers); @@ -8084,9 +8167,7 @@ var ts; else { node.members = createMissingList(); } - var finishedNode = finishNode(node); - setStrictModeContext(savedStrictModeContext); - return finishedNode; + return finishNode(node); } function parseHeritageClauses(isClassHeritageClause) { // ClassTail[Yield,GeneratorParameter] : See 14.5 @@ -8100,23 +8181,23 @@ var ts; return undefined; } function parseHeritageClausesWorker() { - return parseList(19, false, parseHeritageClause); + return parseList(18, parseHeritageClause); } function parseHeritageClause() { if (token === 79 || token === 102) { - var node = createNode(223); + var node = createNode(225); node.token = token; nextToken(); - node.types = parseDelimitedList(8, parseExpressionWithTypeArguments); + node.types = parseDelimitedList(7, parseExpressionWithTypeArguments); return finishNode(node); } return undefined; } function parseExpressionWithTypeArguments() { - var node = createNode(177); + var node = createNode(179); node.expression = parseLeftHandSideExpressionOrHigher(); if (token === 24) { - node.typeArguments = parseBracketedList(17, parseType, 24, 25); + node.typeArguments = parseBracketedList(16, parseType, 24, 25); } return finishNode(node); } @@ -8124,10 +8205,10 @@ var ts; return token === 79 || token === 102; } function parseClassMembers() { - return parseList(6, false, parseClassElement); + return parseList(5, parseClassElement); } function parseInterfaceDeclaration(fullStart, decorators, modifiers) { - var node = createNode(203, fullStart); + var node = createNode(205, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(103); @@ -8138,30 +8219,31 @@ var ts; return finishNode(node); } function parseTypeAliasDeclaration(fullStart, decorators, modifiers) { - var node = createNode(204, fullStart); + var node = createNode(206, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(124); + parseExpected(125); node.name = parseIdentifier(); + node.typeParameters = parseTypeParameters(); parseExpected(53); node.type = parseType(); parseSemicolon(); return finishNode(node); } function parseEnumMember() { - var node = createNode(227, scanner.getStartPos()); + var node = createNode(229, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart, decorators, modifiers) { - var node = createNode(205, fullStart); + var node = createNode(207, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(77); node.name = parseIdentifier(); if (parseExpected(14)) { - node.members = parseDelimitedList(7, parseEnumMember); + node.members = parseDelimitedList(6, parseEnumMember); parseExpected(15); } else { @@ -8170,9 +8252,9 @@ var ts; return finishNode(node); } function parseModuleBlock() { - var node = createNode(207, scanner.getStartPos()); + var node = createNode(209, scanner.getStartPos()); if (parseExpected(14)) { - node.statements = parseList(1, false, parseModuleElement); + node.statements = parseList(1, parseStatement); parseExpected(15); } else { @@ -8181,7 +8263,7 @@ var ts; return finishNode(node); } function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) { - var node = createNode(206, fullStart); + var node = createNode(208, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.flags |= flags; @@ -8192,7 +8274,7 @@ var ts; return finishNode(node); } function parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers) { - var node = createNode(206, fullStart); + var node = createNode(208, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.name = parseLiteralNode(true); @@ -8201,11 +8283,11 @@ var ts; } function parseModuleDeclaration(fullStart, decorators, modifiers) { var flags = modifiers ? modifiers.flags : 0; - if (parseOptional(118)) { + if (parseOptional(119)) { flags |= 32768; } else { - parseExpected(117); + parseExpected(118); if (token === 8) { return parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers); } @@ -8213,7 +8295,7 @@ var ts; return parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags); } function isExternalModuleReference() { - return token === 119 && + return token === 120 && lookAhead(nextTokenIsOpenParen); } function nextTokenIsOpenParen() { @@ -8222,7 +8304,7 @@ var ts; function nextTokenIsCommaOrFromKeyword() { nextToken(); return token === 23 || - token === 125; + token === 126; } function parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers) { parseExpected(85); @@ -8230,8 +8312,8 @@ var ts; var identifier; if (isIdentifier()) { identifier = parseIdentifier(); - if (token !== 23 && token !== 125) { - var importEqualsDeclaration = createNode(209, fullStart); + if (token !== 23 && token !== 126) { + var importEqualsDeclaration = createNode(211, fullStart); importEqualsDeclaration.decorators = decorators; setModifiers(importEqualsDeclaration, modifiers); importEqualsDeclaration.name = identifier; @@ -8241,14 +8323,14 @@ var ts; return finishNode(importEqualsDeclaration); } } - var importDeclaration = createNode(210, fullStart); + var importDeclaration = createNode(212, fullStart); importDeclaration.decorators = decorators; setModifiers(importDeclaration, modifiers); if (identifier || token === 35 || token === 14) { importDeclaration.importClause = parseImportClause(identifier, afterImportPos); - parseExpected(125); + parseExpected(126); } importDeclaration.moduleSpecifier = parseModuleSpecifier(); parseSemicolon(); @@ -8261,13 +8343,13 @@ var ts; // NamedImports // ImportedDefaultBinding, NameSpaceImport // ImportedDefaultBinding, NamedImports - var importClause = createNode(211, fullStart); + var importClause = createNode(213, fullStart); if (identifier) { importClause.name = identifier; } if (!importClause.name || parseOptional(23)) { - importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(213); + importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(215); } return finishNode(importClause); } @@ -8277,8 +8359,8 @@ var ts; : parseEntityName(false); } function parseExternalModuleReference() { - var node = createNode(220); - parseExpected(119); + var node = createNode(222); + parseExpected(120); parseExpected(16); node.expression = parseModuleSpecifier(); parseExpected(17); @@ -8292,7 +8374,7 @@ var ts; return result; } function parseNamespaceImport() { - var namespaceImport = createNode(212); + var namespaceImport = createNode(214); parseExpected(35); parseExpected(111); namespaceImport.name = parseIdentifier(); @@ -8300,14 +8382,14 @@ var ts; } function parseNamedImportsOrExports(kind) { var node = createNode(kind); - node.elements = parseBracketedList(20, kind === 213 ? parseImportSpecifier : parseExportSpecifier, 14, 15); + node.elements = parseBracketedList(19, kind === 215 ? parseImportSpecifier : parseExportSpecifier, 14, 15); return finishNode(node); } function parseExportSpecifier() { - return parseImportOrExportSpecifier(218); + return parseImportOrExportSpecifier(220); } function parseImportSpecifier() { - return parseImportOrExportSpecifier(214); + return parseImportOrExportSpecifier(216); } function parseImportOrExportSpecifier(kind) { var node = createNode(kind); @@ -8326,22 +8408,22 @@ var ts; else { node.name = identifierName; } - if (kind === 214 && checkIdentifierIsKeyword) { + if (kind === 216 && checkIdentifierIsKeyword) { parseErrorAtPosition(checkIdentifierStart, checkIdentifierEnd - checkIdentifierStart, ts.Diagnostics.Identifier_expected); } return finishNode(node); } function parseExportDeclaration(fullStart, decorators, modifiers) { - var node = createNode(216, fullStart); + var node = createNode(218, fullStart); node.decorators = decorators; setModifiers(node, modifiers); if (parseOptional(35)) { - parseExpected(125); + parseExpected(126); node.moduleSpecifier = parseModuleSpecifier(); } else { - node.exportClause = parseNamedImportsOrExports(217); - if (parseOptional(125)) { + node.exportClause = parseNamedImportsOrExports(219); + if (parseOptional(126)) { node.moduleSpecifier = parseModuleSpecifier(); } } @@ -8349,7 +8431,7 @@ var ts; return finishNode(node); } function parseExportAssignment(fullStart, decorators, modifiers) { - var node = createNode(215, fullStart); + var node = createNode(217, fullStart); node.decorators = decorators; setModifiers(node, modifiers); if (parseOptional(53)) { @@ -8414,15 +8496,15 @@ var ts; } sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { return node.flags & 1 - || node.kind === 209 && node.moduleReference.kind === 220 - || node.kind === 210 - || node.kind === 215 - || node.kind === 216 + || node.kind === 211 && node.moduleReference.kind === 222 + || node.kind === 212 + || node.kind === 217 + || node.kind === 218 ? node : undefined; }); @@ -8457,7 +8539,7 @@ var ts; function parseJSDocTypeExpression(start, length) { scanner.setText(sourceText, start, length); token = nextToken(); - var result = createNode(229); + var result = createNode(231); parseExpected(14); result.type = parseJSDocTopLevelType(); parseExpected(15); @@ -8468,12 +8550,12 @@ var ts; function parseJSDocTopLevelType() { var type = parseJSDocType(); if (token === 44) { - var unionType = createNode(233, type.pos); + var unionType = createNode(235, type.pos); unionType.types = parseJSDocTypeList(type); type = finishNode(unionType); } if (token === 53) { - var optionalType = createNode(240, type.pos); + var optionalType = createNode(242, type.pos); nextToken(); optionalType.type = type; type = finishNode(optionalType); @@ -8484,20 +8566,20 @@ var ts; var type = parseBasicTypeExpression(); while (true) { if (token === 18) { - var arrayType = createNode(232, type.pos); + var arrayType = createNode(234, type.pos); arrayType.elementType = type; nextToken(); parseExpected(19); type = finishNode(arrayType); } else if (token === 50) { - var nullableType = createNode(235, type.pos); + var nullableType = createNode(237, type.pos); nullableType.type = type; nextToken(); type = finishNode(nullableType); } else if (token === 46) { - var nonNullableType = createNode(236, type.pos); + var nonNullableType = createNode(238, type.pos); nonNullableType.type = type; nextToken(); type = finishNode(nonNullableType); @@ -8531,40 +8613,40 @@ var ts; case 93: return parseJSDocThisType(); case 112: - case 122: - case 120: - case 113: case 123: + case 121: + case 113: + case 124: case 99: return parseTokenNode(); } return parseJSDocTypeReference(); } function parseJSDocThisType() { - var result = createNode(244); + var result = createNode(246); nextToken(); parseExpected(51); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocConstructorType() { - var result = createNode(243); + var result = createNode(245); nextToken(); parseExpected(51); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocVariadicType() { - var result = createNode(242); + var result = createNode(244); nextToken(); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocFunctionType() { - var result = createNode(241); + var result = createNode(243); nextToken(); parseExpected(16); - result.parameters = parseDelimitedList(21, parseJSDocParameter); + result.parameters = parseDelimitedList(20, parseJSDocParameter); checkForTrailingComma(result.parameters); parseExpected(17); if (token === 51) { @@ -8574,18 +8656,18 @@ var ts; return finishNode(result); } function parseJSDocParameter() { - var parameter = createNode(130); + var parameter = createNode(131); parameter.type = parseJSDocType(); return finishNode(parameter); } function parseJSDocOptionalType(type) { - var result = createNode(240, type.pos); + var result = createNode(242, type.pos); nextToken(); result.type = type; return finishNode(result); } function parseJSDocTypeReference() { - var result = createNode(239); + var result = createNode(241); result.name = parseSimplePropertyName(); while (parseOptional(20)) { if (token === 24) { @@ -8600,7 +8682,7 @@ var ts; } function parseTypeArguments() { nextToken(); - var typeArguments = parseDelimitedList(22, parseJSDocType); + var typeArguments = parseDelimitedList(21, parseJSDocType); checkForTrailingComma(typeArguments); checkForEmptyTypeArgumentList(typeArguments); parseExpected(25); @@ -8614,21 +8696,21 @@ var ts; } } function parseQualifiedName(left) { - var result = createNode(127, left.pos); + var result = createNode(128, left.pos); result.left = left; result.right = parseIdentifierName(); return finishNode(result); } function parseJSDocRecordType() { - var result = createNode(237); + var result = createNode(239); nextToken(); - result.members = parseDelimitedList(23, parseJSDocRecordMember); + result.members = parseDelimitedList(22, parseJSDocRecordMember); checkForTrailingComma(result.members); parseExpected(15); return finishNode(result); } function parseJSDocRecordMember() { - var result = createNode(238); + var result = createNode(240); result.name = parseSimplePropertyName(); if (token === 51) { nextToken(); @@ -8637,15 +8719,15 @@ var ts; return finishNode(result); } function parseJSDocNonNullableType() { - var result = createNode(236); + var result = createNode(238); nextToken(); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocTupleType() { - var result = createNode(234); + var result = createNode(236); nextToken(); - result.types = parseDelimitedList(24, parseJSDocType); + result.types = parseDelimitedList(23, parseJSDocType); checkForTrailingComma(result.types); parseExpected(19); return finishNode(result); @@ -8657,7 +8739,7 @@ var ts; } } function parseJSDocUnionType() { - var result = createNode(233); + var result = createNode(235); nextToken(); result.types = parseJSDocTypeList(parseJSDocType()); parseExpected(17); @@ -8675,7 +8757,7 @@ var ts; return types; } function parseJSDocAllType() { - var result = createNode(230); + var result = createNode(232); nextToken(); return finishNode(result); } @@ -8688,11 +8770,11 @@ var ts; token === 25 || token === 53 || token === 44) { - var result = createNode(231, pos); + var result = createNode(233, pos); return finishNode(result); } else { - var result = createNode(235, pos); + var result = createNode(237, pos); result.type = parseJSDocType(); return finishNode(result); } @@ -8763,7 +8845,7 @@ var ts; if (!tags) { return undefined; } - var result = createNode(245, start); + var result = createNode(247, start); result.tags = tags; return finishNode(result, end); } @@ -8801,7 +8883,7 @@ var ts; return undefined; } function handleUnknownTag(atToken, tagName) { - var result = createNode(246, atToken.pos); + var result = createNode(248, atToken.pos); result.atToken = atToken; result.tagName = tagName; return finishNode(result, pos); @@ -8853,7 +8935,7 @@ var ts; if (!typeExpression) { typeExpression = tryParseTypeExpression(); } - var result = createNode(247, atToken.pos); + var result = createNode(249, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.preParameterName = preName; @@ -8863,27 +8945,27 @@ var ts; return finishNode(result, pos); } function handleReturnTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 248; })) { + if (ts.forEach(tags, function (t) { return t.kind === 250; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } - var result = createNode(248, atToken.pos); + var result = createNode(250, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeExpression = tryParseTypeExpression(); return finishNode(result, pos); } function handleTypeTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 249; })) { + if (ts.forEach(tags, function (t) { return t.kind === 251; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } - var result = createNode(249, atToken.pos); + var result = createNode(251, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeExpression = tryParseTypeExpression(); return finishNode(result, pos); } function handleTemplateTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 250; })) { + if (ts.forEach(tags, function (t) { return t.kind === 252; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } var typeParameters = []; @@ -8896,7 +8978,7 @@ var ts; parseErrorAtPosition(startPos, 0, ts.Diagnostics.Identifier_expected); return undefined; } - var typeParameter = createNode(129, name_7.pos); + var typeParameter = createNode(130, name_7.pos); typeParameter.name = name_7; finishNode(typeParameter, pos); typeParameters.push(typeParameter); @@ -8907,7 +8989,7 @@ var ts; pos++; } typeParameters.end = pos; - var result = createNode(250, atToken.pos); + var result = createNode(252, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeParameters = typeParameters; @@ -9222,16 +9304,16 @@ var ts; (function (ts) { ts.bindTime = 0; function getModuleInstanceState(node) { - if (node.kind === 203 || node.kind === 204) { + if (node.kind === 205 || node.kind === 206) { return 0; } else if (ts.isConstEnumDeclaration(node)) { return 2; } - else if ((node.kind === 210 || node.kind === 209) && !(node.flags & 1)) { + else if ((node.kind === 212 || node.kind === 211) && !(node.flags & 1)) { return 0; } - else if (node.kind === 207) { + else if (node.kind === 209) { var state = 0; ts.forEachChild(node, function (n) { switch (getModuleInstanceState(n)) { @@ -9247,7 +9329,7 @@ var ts; }); return state; } - else if (node.kind === 206) { + else if (node.kind === 208) { return getModuleInstanceState(node.body); } else { @@ -9266,11 +9348,14 @@ var ts; var container; var blockScopeContainer; var lastContainer; + var inStrictMode = !!file.externalModuleIndicator; var symbolCount = 0; var Symbol = ts.objectAllocator.getSymbolConstructor(); + var classifiableNames = {}; if (!file.locals) { bind(file); file.symbolCount = symbolCount; + file.classifiableNames = classifiableNames; } return; function createSymbol(flags, name) { @@ -9296,10 +9381,10 @@ var ts; } function getDeclarationName(node) { if (node.name) { - if (node.kind === 206 && node.name.kind === 8) { + if (node.kind === 208 && node.name.kind === 8) { return '"' + node.name.text + '"'; } - if (node.name.kind === 128) { + if (node.name.kind === 129) { var nameExpression = node.name.expression; ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); @@ -9307,22 +9392,22 @@ var ts; return node.name.text; } switch (node.kind) { - case 136: + case 137: return "__constructor"; - case 143: - case 139: - return "__call"; - case 144: + case 145: case 140: - return "__new"; + return "__call"; + case 146: case 141: + return "__new"; + case 142: return "__index"; - case 216: + case 218: return "__export"; - case 215: + case 217: return node.isExportEquals ? "export=" : "default"; - case 201: - case 202: + case 203: + case 204: return node.flags & 256 ? "default" : undefined; } } @@ -9337,6 +9422,9 @@ var ts; symbol = ts.hasProperty(symbolTable, name) ? symbolTable[name] : (symbolTable[name] = createSymbol(0, name)); + if (name && (includes & 788448)) { + classifiableNames[name] = name; + } if (symbol.flags & excludes) { if (node.name) { node.name.parent = node; @@ -9361,7 +9449,7 @@ var ts; function declareModuleMember(node, symbolFlags, symbolExcludes) { var hasExportModifier = ts.getCombinedNodeFlags(node) & 1; if (symbolFlags & 8388608) { - if (node.kind === 218 || (node.kind === 209 && hasExportModifier)) { + if (node.kind === 220 || (node.kind === 211 && hasExportModifier)) { return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); } else { @@ -9407,36 +9495,37 @@ var ts; } function getContainerFlags(node) { switch (node.kind) { - case 175: - case 202: - case 203: + case 177: + case 204: case 205: - case 146: - case 155: + case 207: + case 148: + case 157: return 1; - case 139: case 140: case 141: - case 135: - case 134: - case 201: + case 142: case 136: + case 135: + case 203: case 137: case 138: - case 143: - case 144: - case 163: - case 164: - case 206: - case 228: - return 5; - case 224: - case 187: - case 188: - case 189: + case 139: + case 145: + case 146: + case 165: + case 166: case 208: + case 230: + case 206: + return 5; + case 226: + case 189: + case 190: + case 191: + case 210: return 2; - case 180: + case 182: return ts.isFunctionLike(node.parent) ? 0 : 2; } return 0; @@ -9452,32 +9541,33 @@ var ts; } function declareSymbolAndAddToSymbolTableWorker(node, symbolFlags, symbolExcludes) { switch (container.kind) { - case 206: + case 208: return declareModuleMember(node, symbolFlags, symbolExcludes); - case 228: + case 230: return declareSourceFileMember(node, symbolFlags, symbolExcludes); - case 175: - case 202: + case 177: + case 204: return declareClassMember(node, symbolFlags, symbolExcludes); - case 205: + case 207: return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); - case 146: - case 155: - case 203: + case 148: + case 157: + case 205: return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes); - case 143: - case 144: - case 139: + case 145: + case 146: case 140: case 141: - case 135: - case 134: + case 142: case 136: + case 135: case 137: case 138: - case 201: - case 163: - case 164: + case 139: + case 203: + case 165: + case 166: + case 206: return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes); } } @@ -9501,11 +9591,11 @@ var ts; return false; } function hasExportDeclarations(node) { - var body = node.kind === 228 ? node : node.body; - if (body.kind === 228 || body.kind === 207) { + var body = node.kind === 230 ? node : node.body; + if (body.kind === 230 || body.kind === 209) { for (var _i = 0, _a = body.statements; _i < _a.length; _i++) { var stat = _a[_i]; - if (stat.kind === 216 || stat.kind === 215) { + if (stat.kind === 218 || stat.kind === 217) { return true; } } @@ -9550,16 +9640,41 @@ var ts; typeLiteralSymbol.members = (_a = {}, _a[symbol.name] = symbol, _a); var _a; } + function bindObjectLiteralExpression(node) { + if (inStrictMode) { + var seen = {}; + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var prop = _a[_i]; + if (prop.name.kind !== 65) { + continue; + } + var identifier = prop.name; + var currentKind = prop.kind === 227 || prop.kind === 228 || prop.kind === 136 + ? 1 + : 2; + var existingKind = seen[identifier.text]; + if (!existingKind) { + seen[identifier.text] = currentKind; + continue; + } + if (currentKind === 1 && existingKind === 1) { + var span = ts.getErrorSpanForNode(file, identifier); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode)); + } + } + } + return bindAnonymousDeclaration(node, 4096, "__object"); + } function bindAnonymousDeclaration(node, symbolFlags, name) { var symbol = createSymbol(symbolFlags, name); addDeclarationToSymbol(symbol, node, symbolFlags); } function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) { switch (blockScopeContainer.kind) { - case 206: + case 208: declareModuleMember(node, symbolFlags, symbolExcludes); break; - case 228: + case 230: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolFlags, symbolExcludes); break; @@ -9575,79 +9690,223 @@ var ts; function bindBlockScopedVariableDeclaration(node) { bindBlockScopedDeclaration(node, 2, 107455); } + function checkStrictModeIdentifier(node) { + if (inStrictMode && + node.originalKeywordKind >= 102 && + node.originalKeywordKind <= 110 && + !ts.isIdentifierName(node)) { + if (!file.parseDiagnostics.length) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node))); + } + } + } + function getStrictModeIdentifierMessage(node) { + if (ts.getAncestor(node, 204) || ts.getAncestor(node, 177)) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode; + } + function checkStrictModeBinaryExpression(node) { + if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { + checkStrictModeEvalOrArguments(node, node.left); + } + } + function checkStrictModeCatchClause(node) { + if (inStrictMode && node.variableDeclaration) { + checkStrictModeEvalOrArguments(node, node.variableDeclaration.name); + } + } + function checkStrictModeDeleteExpression(node) { + if (inStrictMode && node.expression.kind === 65) { + var span = ts.getErrorSpanForNode(file, node.expression); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode)); + } + } + function isEvalOrArgumentsIdentifier(node) { + return node.kind === 65 && + (node.text === "eval" || node.text === "arguments"); + } + function checkStrictModeEvalOrArguments(contextNode, name) { + if (name && name.kind === 65) { + var identifier = name; + if (isEvalOrArgumentsIdentifier(identifier)) { + var span = ts.getErrorSpanForNode(file, name); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), identifier.text)); + } + } + } + function getStrictModeEvalOrArgumentsMessage(node) { + if (ts.getAncestor(node, 204) || ts.getAncestor(node, 177)) { + return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Invalid_use_of_0_in_strict_mode; + } + function checkStrictModeFunctionName(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } + } + function checkStrictModeNumericLiteral(node) { + if (inStrictMode && node.flags & 16384) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode)); + } + } + function checkStrictModePostfixUnaryExpression(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + function checkStrictModePrefixUnaryExpression(node) { + if (inStrictMode) { + if (node.operator === 38 || node.operator === 39) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + } + function checkStrictModeWithStatement(node) { + if (inStrictMode) { + grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); + } + } + function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) { + var span = ts.getSpanOfTokenAtPosition(file, node.pos); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2)); + } function getDestructuringParameterName(node) { return "__" + ts.indexOf(node.parent.parameters, node); } function bind(node) { node.parent = parent; + var savedInStrictMode = inStrictMode; + if (!savedInStrictMode) { + updateStrictMode(node); + } bindWorker(node); bindChildren(node); + inStrictMode = savedInStrictMode; + } + function updateStrictMode(node) { + switch (node.kind) { + case 230: + case 209: + updateStrictModeStatementList(node.statements); + return; + case 182: + if (ts.isFunctionLike(node.parent)) { + updateStrictModeStatementList(node.statements); + } + return; + case 204: + case 177: + inStrictMode = true; + return; + } + } + function updateStrictModeStatementList(statements) { + for (var _i = 0; _i < statements.length; _i++) { + var statement = statements[_i]; + if (!ts.isPrologueDirective(statement)) { + return; + } + if (isUseStrictPrologueDirective(statement)) { + inStrictMode = true; + return; + } + } + } + function isUseStrictPrologueDirective(node) { + var nodeText = ts.getTextOfNodeFromSourceText(file.text, node.expression); + return nodeText === '"use strict"' || nodeText === "'use strict'"; } function bindWorker(node) { switch (node.kind) { - case 129: - return declareSymbolAndAddToSymbolTable(node, 262144, 530912); - case 130: - return bindParameter(node); - case 199: - case 153: - return bindVariableDeclarationOrBindingElement(node); - case 133: - case 132: - return bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455); - case 225: + case 65: + return checkStrictModeIdentifier(node); + case 172: + return checkStrictModeBinaryExpression(node); case 226: - return bindPropertyOrMethodOrAccessor(node, 4, 107455); + return checkStrictModeCatchClause(node); + case 167: + return checkStrictModeDeleteExpression(node); + case 7: + return checkStrictModeNumericLiteral(node); + case 171: + return checkStrictModePostfixUnaryExpression(node); + case 170: + return checkStrictModePrefixUnaryExpression(node); + case 195: + return checkStrictModeWithStatement(node); + case 130: + return declareSymbolAndAddToSymbolTable(node, 262144, 530912); + case 131: + return bindParameter(node); + case 201: + case 155: + return bindVariableDeclarationOrBindingElement(node); + case 134: + case 133: + return bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455); case 227: + case 228: + return bindPropertyOrMethodOrAccessor(node, 4, 107455); + case 229: return bindPropertyOrMethodOrAccessor(node, 8, 107455); - case 139: case 140: case 141: + case 142: return declareSymbolAndAddToSymbolTable(node, 131072, 0); - case 135: - case 134: - return bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263); - case 201: - return declareSymbolAndAddToSymbolTable(node, 16, 106927); case 136: - return declareSymbolAndAddToSymbolTable(node, 16384, 0); - case 137: - return bindPropertyOrMethodOrAccessor(node, 32768, 41919); - case 138: - return bindPropertyOrMethodOrAccessor(node, 65536, 74687); - case 143: - case 144: - return bindFunctionOrConstructorType(node); - case 146: - return bindAnonymousDeclaration(node, 2048, "__type"); - case 155: - return bindAnonymousDeclaration(node, 4096, "__object"); - case 163: - case 164: - return bindAnonymousDeclaration(node, 16, "__function"); - case 175: - case 202: - return bindClassLikeDeclaration(node); + case 135: + return bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263); case 203: - return bindBlockScopedDeclaration(node, 64, 792992); + checkStrictModeFunctionName(node); + return declareSymbolAndAddToSymbolTable(node, 16, 106927); + case 137: + return declareSymbolAndAddToSymbolTable(node, 16384, 0); + case 138: + return bindPropertyOrMethodOrAccessor(node, 32768, 41919); + case 139: + return bindPropertyOrMethodOrAccessor(node, 65536, 74687); + case 145: + case 146: + return bindFunctionOrConstructorType(node); + case 148: + return bindAnonymousDeclaration(node, 2048, "__type"); + case 157: + return bindObjectLiteralExpression(node); + case 165: + case 166: + checkStrictModeFunctionName(node); + return bindAnonymousDeclaration(node, 16, "__function"); + case 177: case 204: - return bindBlockScopedDeclaration(node, 524288, 793056); + return bindClassLikeDeclaration(node); case 205: - return bindEnumDeclaration(node); + return bindBlockScopedDeclaration(node, 64, 792992); case 206: + return bindBlockScopedDeclaration(node, 524288, 793056); + case 207: + return bindEnumDeclaration(node); + case 208: return bindModuleDeclaration(node); - case 209: - case 212: - case 214: - case 218: - return declareSymbolAndAddToSymbolTable(node, 8388608, 8388608); case 211: - return bindImportClause(node); + case 214: case 216: + case 220: + return declareSymbolAndAddToSymbolTable(node, 8388608, 8388608); + case 213: + return bindImportClause(node); + case 218: return bindExportDeclaration(node); - case 215: + case 217: return bindExportAssignment(node); - case 228: + case 230: return bindSourceFileIfExternalModule(); } } @@ -9658,7 +9917,10 @@ var ts; } } function bindExportAssignment(node) { - if (node.expression.kind === 65) { + if (!container.symbol || !container.symbol.exports) { + bindAnonymousDeclaration(node, 8388608, getDeclarationName(node)); + } + else if (node.expression.kind === 65) { declareSymbol(container.symbol.exports, container.symbol, node, 8388608, 107455 | 8388608); } else { @@ -9666,7 +9928,10 @@ var ts; } } function bindExportDeclaration(node) { - if (!node.exportClause) { + if (!container.symbol || !container.symbol.exports) { + bindAnonymousDeclaration(node, 1073741824, getDeclarationName(node)); + } + else if (!node.exportClause) { declareSymbol(container.symbol.exports, container.symbol, node, 1073741824, 0); } } @@ -9676,7 +9941,7 @@ var ts; } } function bindClassLikeDeclaration(node) { - if (node.kind === 202) { + if (node.kind === 204) { bindBlockScopedDeclaration(node, 32, 899583); } else { @@ -9699,6 +9964,9 @@ var ts; : bindBlockScopedDeclaration(node, 256, 899327); } function bindVariableDeclarationOrBindingElement(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } if (!ts.isBindingPattern(node.name)) { if (ts.isBlockOrCatchScoped(node)) { bindBlockScopedVariableDeclaration(node); @@ -9712,6 +9980,9 @@ var ts; } } function bindParameter(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } if (ts.isBindingPattern(node.name)) { bindAnonymousDeclaration(node, 1, getDestructuringParameterName(node)); } @@ -9719,8 +9990,8 @@ var ts; declareSymbolAndAddToSymbolTable(node, 1, 107455); } if (node.flags & 112 && - node.parent.kind === 136 && - (node.parent.parent.kind === 202 || node.parent.parent.kind === 175)) { + node.parent.kind === 137 && + (node.parent.parent.kind === 204 || node.parent.parent.kind === 177)) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); } @@ -9817,8 +10088,8 @@ var ts; emptyGenericType.instantiations = {}; var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); - var anySignature = createSignature(undefined, undefined, emptyArray, anyType, 0, false, false); - var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, 0, false, false); + var anySignature = createSignature(undefined, undefined, emptyArray, anyType, undefined, 0, false, false); + var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, undefined, 0, false, false); var globals = {}; var globalESSymbolConstructorSymbol; var globalObjectType; @@ -9869,6 +10140,11 @@ var ts; flags: 2097152 } }; + var subtypeRelation = {}; + var assignableRelation = {}; + var identityRelation = {}; + initializeTypeChecker(); + return checker; function getEmitResolver(sourceFile) { getDiagnostics(sourceFile); return emitResolver; @@ -10008,10 +10284,10 @@ var ts; return nodeLinks[nodeId] || (nodeLinks[nodeId] = {}); } function getSourceFile(node) { - return ts.getAncestor(node, 228); + return ts.getAncestor(node, 230); } function isGlobalSourceFile(node) { - return node.kind === 228 && !ts.isExternalModule(node); + return node.kind === 230 && !ts.isExternalModule(node); } function getSymbol(symbols, name, meaning) { if (meaning && ts.hasProperty(symbols, name)) { @@ -10059,34 +10335,37 @@ var ts; } } switch (location.kind) { - case 228: + case 230: if (!ts.isExternalModule(location)) break; - case 206: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { - if (result.flags & meaning || !(result.flags & 8388608 && getDeclarationOfAliasSymbol(result).kind === 218)) { - break loop; + case 208: + var moduleExports = getSymbolOfNode(location).exports; + if (location.kind === 230 || + (location.kind === 208 && location.name.kind === 8)) { + if (ts.hasProperty(moduleExports, name) && + moduleExports[name].flags === 8388608 && + ts.getDeclarationOfKind(moduleExports[name], 220)) { + break; } - result = undefined; - } - else if (location.kind === 228 || - (location.kind === 206 && location.name.kind === 8)) { - result = getSymbolOfNode(location).exports["default"]; + result = moduleExports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + if (result = getSymbol(moduleExports, name, meaning & 8914931)) { + break loop; + } break; - case 205: + case 207: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { break loop; } break; + case 134: case 133: - case 132: - if (location.parent.kind === 202 && !(location.flags & 128)) { + if (location.parent.kind === 204 && !(location.flags & 128)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455)) { @@ -10095,8 +10374,8 @@ var ts; } } break; - case 202: - case 203: + case 204: + case 205: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056)) { if (lastLocation && lastLocation.flags & 128) { error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters); @@ -10105,28 +10384,28 @@ var ts; break loop; } break; - case 128: + case 129: grandparent = location.parent.parent; - if (grandparent.kind === 202 || grandparent.kind === 203) { + if (grandparent.kind === 204 || grandparent.kind === 205) { if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); return undefined; } } break; - case 135: - case 134: case 136: + case 135: case 137: case 138: - case 201: - case 164: + case 139: + case 203: + case 166: if (meaning & 3 && name === "arguments") { result = argumentsSymbol; break loop; } break; - case 163: + case 165: if (meaning & 3 && name === "arguments") { result = argumentsSymbol; break loop; @@ -10139,7 +10418,7 @@ var ts; } } break; - case 175: + case 177: if (meaning & 32) { var className = location.name; if (className && name === className.text) { @@ -10148,8 +10427,8 @@ var ts; } } break; - case 131: - if (location.parent && location.parent.kind === 130) { + case 132: + if (location.parent && location.parent.kind === 131) { location = location.parent; } if (location.parent && ts.isClassElement(location.parent)) { @@ -10187,14 +10466,14 @@ var ts; ts.Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined"); var isUsedBeforeDeclaration = !isDefinedBefore(declaration, errorLocation); if (!isUsedBeforeDeclaration) { - var variableDeclaration = ts.getAncestor(declaration, 199); + var variableDeclaration = ts.getAncestor(declaration, 201); var container = ts.getEnclosingBlockScopeContainer(variableDeclaration); - if (variableDeclaration.parent.parent.kind === 181 || - variableDeclaration.parent.parent.kind === 187) { + if (variableDeclaration.parent.parent.kind === 183 || + variableDeclaration.parent.parent.kind === 189) { isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, variableDeclaration, container); } - else if (variableDeclaration.parent.parent.kind === 189 || - variableDeclaration.parent.parent.kind === 188) { + else if (variableDeclaration.parent.parent.kind === 191 || + variableDeclaration.parent.parent.kind === 190) { var expression = variableDeclaration.parent.parent.expression; isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, expression, container); } @@ -10216,10 +10495,10 @@ var ts; } function getAnyImportSyntax(node) { if (ts.isAliasSymbolDeclaration(node)) { - if (node.kind === 209) { + if (node.kind === 211) { return node; } - while (node && node.kind !== 210) { + while (node && node.kind !== 212) { node = node.parent; } return node; @@ -10229,7 +10508,7 @@ var ts; return ts.forEach(symbol.declarations, function (d) { return ts.isAliasSymbolDeclaration(d) ? d : undefined; }); } function getTargetOfImportEqualsDeclaration(node) { - if (node.moduleReference.kind === 220) { + if (node.moduleReference.kind === 222) { return resolveExternalModuleSymbol(resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node))); } return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); @@ -10318,17 +10597,17 @@ var ts; } function getTargetOfAliasDeclaration(node) { switch (node.kind) { - case 209: - return getTargetOfImportEqualsDeclaration(node); case 211: + return getTargetOfImportEqualsDeclaration(node); + case 213: return getTargetOfImportClause(node); - case 212: - return getTargetOfNamespaceImport(node); case 214: + return getTargetOfNamespaceImport(node); + case 216: return getTargetOfImportSpecifier(node); - case 218: + case 220: return getTargetOfExportSpecifier(node); - case 215: + case 217: return getTargetOfExportAssignment(node); } } @@ -10370,10 +10649,10 @@ var ts; if (!links.referenced) { links.referenced = true; var node = getDeclarationOfAliasSymbol(symbol); - if (node.kind === 215) { + if (node.kind === 217) { checkExpressionCached(node.expression); } - else if (node.kind === 218) { + else if (node.kind === 220) { checkExpressionCached(node.propertyName || node.name); } else if (ts.isInternalModuleImportEqualsDeclaration(node)) { @@ -10383,17 +10662,17 @@ var ts; } function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { if (!importDeclaration) { - importDeclaration = ts.getAncestor(entityName, 209); + importDeclaration = ts.getAncestor(entityName, 211); ts.Debug.assert(importDeclaration !== undefined); } if (entityName.kind === 65 && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { entityName = entityName.parent; } - if (entityName.kind === 65 || entityName.parent.kind === 127) { + if (entityName.kind === 65 || entityName.parent.kind === 128) { return resolveEntityName(entityName, 1536); } else { - ts.Debug.assert(entityName.parent.kind === 209); + ts.Debug.assert(entityName.parent.kind === 211); return resolveEntityName(entityName, 107455 | 793056 | 1536); } } @@ -10412,9 +10691,9 @@ var ts; return undefined; } } - else if (name.kind === 127 || name.kind === 156) { - var left = name.kind === 127 ? name.left : name.expression; - var right = name.kind === 127 ? name.right : name.name; + else if (name.kind === 128 || name.kind === 158) { + var left = name.kind === 128 ? name.left : name.expression; + var right = name.kind === 128 ? name.right : name.name; var namespace = resolveEntityName(left, 1536); if (!namespace || namespace === unknownSymbol || ts.nodeIsMissing(right)) { return undefined; @@ -10559,7 +10838,7 @@ var ts; var members = node.members; for (var _i = 0; _i < members.length; _i++) { var member = members[_i]; - if (member.kind === 136 && ts.nodeIsPresent(member.body)) { + if (member.kind === 137 && ts.nodeIsPresent(member.body)) { return member; } } @@ -10624,17 +10903,17 @@ var ts; } } switch (location_1.kind) { - case 228: + case 230: if (!ts.isExternalModule(location_1)) { break; } - case 206: + case 208: if (result = callback(getSymbolOfNode(location_1).exports)) { return result; } break; - case 202: - case 203: + case 204: + case 205: if (result = callback(getSymbolOfNode(location_1).members)) { return result; } @@ -10749,8 +11028,8 @@ var ts; } } function hasExternalModuleSymbol(declaration) { - return (declaration.kind === 206 && declaration.name.kind === 8) || - (declaration.kind === 228 && ts.isExternalModule(declaration)); + return (declaration.kind === 208 && declaration.name.kind === 8) || + (declaration.kind === 230 && ts.isExternalModule(declaration)); } function hasVisibleDeclarations(symbol) { var aliasesToMakeVisible; @@ -10782,11 +11061,11 @@ var ts; } function isEntityNameVisible(entityName, enclosingDeclaration) { var meaning; - if (entityName.parent.kind === 145) { + if (entityName.parent.kind === 147) { meaning = 107455 | 1048576; } - else if (entityName.kind === 127 || entityName.kind === 156 || - entityName.parent.kind === 209) { + else if (entityName.kind === 128 || entityName.kind === 158 || + entityName.parent.kind === 211) { meaning = 1536; } else { @@ -10816,6 +11095,13 @@ var ts; ts.releaseStringWriter(writer); return result; } + function signatureToString(signature, enclosingDeclaration, flags) { + var writer = ts.getSingleLineStringWriter(); + getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); + var result = writer.string(); + ts.releaseStringWriter(writer); + return result; + } function typeToString(type, enclosingDeclaration, flags) { var writer = ts.getSingleLineStringWriter(); getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); @@ -10830,10 +11116,10 @@ var ts; function getTypeAliasForTypeLiteral(type) { if (type.symbol && type.symbol.flags & 2048) { var node = type.symbol.declarations[0].parent; - while (node.kind === 150) { + while (node.kind === 152) { node = node.parent; } - if (node.kind === 204) { + if (node.kind === 206) { return getSymbolOfNode(node); } } @@ -11040,7 +11326,7 @@ var ts; var isNonLocalFunctionSymbol = !!(symbol.flags & 16) && (symbol.parent || ts.forEach(symbol.declarations, function (declaration) { - return declaration.parent.kind === 228 || declaration.parent.kind === 207; + return declaration.parent.kind === 230 || declaration.parent.kind === 209; })); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { return !!(flags & 2) || @@ -11114,7 +11400,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 0, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 122); + writeKeyword(writer, 123); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -11127,7 +11413,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 1, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 120); + writeKeyword(writer, 121); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -11170,7 +11456,7 @@ var ts; function buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaraiton, flags) { var targetSymbol = getTargetSymbol(symbol); if (targetSymbol.flags & 32 || targetSymbol.flags & 64) { - buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags); + buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), writer, enclosingDeclaraiton, flags); } } function buildTypeParameterDisplay(tp, writer, enclosingDeclaration, flags, symbolStack) { @@ -11272,12 +11558,12 @@ var ts; function isDeclarationVisible(node) { function getContainingExternalModule(node) { for (; node; node = node.parent) { - if (node.kind === 206) { + if (node.kind === 208) { if (node.name.kind === 8) { return node; } } - else if (node.kind === 228) { + else if (node.kind === 230) { return ts.isExternalModule(node) ? node : undefined; } } @@ -11320,58 +11606,58 @@ var ts; } function determineIfDeclarationIsVisible() { switch (node.kind) { - case 153: + case 155: return isDeclarationVisible(node.parent.parent); - case 199: + case 201: if (ts.isBindingPattern(node.name) && !node.name.elements.length) { return false; } - case 206: - case 202: - case 203: + case 208: case 204: - case 201: case 205: - case 209: + case 206: + case 203: + case 207: + case 211: var parent_4 = getDeclarationContainer(node); if (!(ts.getCombinedNodeFlags(node) & 1) && - !(node.kind !== 209 && parent_4.kind !== 228 && ts.isInAmbientContext(parent_4))) { + !(node.kind !== 211 && parent_4.kind !== 230 && ts.isInAmbientContext(parent_4))) { return isGlobalSourceFile(parent_4); } return isDeclarationVisible(parent_4); - case 133: - case 132: - case 137: - case 138: - case 135: case 134: + case 133: + case 138: + case 139: + case 136: + case 135: if (node.flags & (32 | 64)) { return false; } - case 136: - case 140: - case 139: + case 137: case 141: - case 130: - case 207: - case 143: - case 144: - case 146: + case 140: case 142: - case 147: + case 131: + case 209: + case 145: + case 146: case 148: + case 144: case 149: case 150: + case 151: + case 152: return isDeclarationVisible(node.parent); - case 211: - case 212: + case 213: case 214: + case 216: return false; - case 129: - case 228: + case 130: + case 230: return true; - case 215: + case 217: return false; default: ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); @@ -11387,10 +11673,10 @@ var ts; } function collectLinkedAliases(node) { var exportSymbol; - if (node.parent && node.parent.kind === 215) { + if (node.parent && node.parent.kind === 217) { exportSymbol = resolveName(node.parent, node.text, 107455 | 793056 | 1536, ts.Diagnostics.Cannot_find_name_0, node); } - else if (node.parent.kind === 218) { + else if (node.parent.kind === 220) { exportSymbol = getTargetOfExportSpecifier(node.parent); } var result = []; @@ -11436,7 +11722,7 @@ var ts; } function getDeclarationContainer(node) { node = ts.getRootDeclaration(node); - return node.kind === 199 ? node.parent.parent.parent : node.parent; + return node.kind === 201 ? node.parent.parent.parent : node.parent; } function getTypeOfPrototypeProperty(prototype) { var classType = getDeclaredTypeOfSymbol(prototype.parent); @@ -11462,7 +11748,7 @@ var ts; return parentType; } var type; - if (pattern.kind === 151) { + if (pattern.kind === 153) { var name_9 = declaration.propertyName || declaration.name; type = getTypeOfPropertyOfType(parentType, name_9.text) || isNumericLiteralName(name_9.text) && getIndexTypeOfType(parentType, 1) || @@ -11499,10 +11785,10 @@ var ts; return type; } function getTypeForVariableLikeDeclaration(declaration) { - if (declaration.parent.parent.kind === 188) { + if (declaration.parent.parent.kind === 190) { return anyType; } - if (declaration.parent.parent.kind === 189) { + if (declaration.parent.parent.kind === 191) { return checkRightHandSideOfForOf(declaration.parent.parent.expression) || anyType; } if (ts.isBindingPattern(declaration.parent)) { @@ -11511,10 +11797,10 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130) { + if (declaration.kind === 131) { var func = declaration.parent; - if (func.kind === 138 && !ts.hasDynamicName(func)) { - var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 137); + if (func.kind === 139 && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 138); if (getter) { return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); } @@ -11527,7 +11813,7 @@ var ts; if (declaration.initializer) { return checkExpressionCached(declaration.initializer); } - if (declaration.kind === 226) { + if (declaration.kind === 228) { return checkIdentifier(declaration.name); } return undefined; @@ -11556,7 +11842,7 @@ var ts; var hasSpreadElement = false; var elementTypes = []; ts.forEach(pattern.elements, function (e) { - elementTypes.push(e.kind === 176 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + elementTypes.push(e.kind === 178 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); if (e.dotDotDotToken) { hasSpreadElement = true; } @@ -11571,7 +11857,7 @@ var ts; return createTupleType(elementTypes); } function getTypeFromBindingPattern(pattern) { - return pattern.kind === 151 + return pattern.kind === 153 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); } @@ -11581,7 +11867,7 @@ var ts; if (reportErrors) { reportErrorsFromWidening(declaration, type); } - return declaration.kind !== 225 ? getWidenedType(type) : type; + return declaration.kind !== 227 ? getWidenedType(type) : type; } if (ts.isBindingPattern(declaration.name)) { return getTypeFromBindingPattern(declaration.name); @@ -11589,7 +11875,7 @@ var ts; type = declaration.dotDotDotToken ? anyArrayType : anyType; if (reportErrors && compilerOptions.noImplicitAny) { var root = ts.getRootDeclaration(declaration); - if (!isPrivateWithinAmbient(root) && !(root.kind === 130 && isPrivateWithinAmbient(root.parent))) { + if (!isPrivateWithinAmbient(root) && !(root.kind === 131 && isPrivateWithinAmbient(root.parent))) { reportImplicitAnyError(declaration, type); } } @@ -11602,10 +11888,10 @@ var ts; return links.type = getTypeOfPrototypeProperty(symbol); } var declaration = symbol.valueDeclaration; - if (declaration.parent.kind === 224) { + if (declaration.parent.kind === 226) { return links.type = anyType; } - if (declaration.kind === 215) { + if (declaration.kind === 217) { return links.type = checkExpression(declaration.expression); } if (!pushTypeResolution(symbol)) { @@ -11633,7 +11919,7 @@ var ts; } function getAnnotatedAccessorType(accessor) { if (accessor) { - if (accessor.kind === 137) { + if (accessor.kind === 138) { return accessor.type && getTypeFromTypeNode(accessor.type); } else { @@ -11649,8 +11935,8 @@ var ts; if (!pushTypeResolution(symbol)) { return unknownType; } - var getter = ts.getDeclarationOfKind(symbol, 137); - var setter = ts.getDeclarationOfKind(symbol, 138); + var getter = ts.getDeclarationOfKind(symbol, 138); + var setter = ts.getDeclarationOfKind(symbol, 139); var type; var getterReturnType = getAnnotatedAccessorType(getter); if (getterReturnType) { @@ -11676,7 +11962,7 @@ var ts; if (!popTypeResolution()) { type = anyType; if (compilerOptions.noImplicitAny) { - var getter_1 = ts.getDeclarationOfKind(symbol, 137); + var getter_1 = ts.getDeclarationOfKind(symbol, 138); error(getter_1, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); } } @@ -11765,9 +12051,9 @@ var ts; if (!node) { return typeParameters; } - if (node.kind === 202 || node.kind === 201 || - node.kind === 163 || node.kind === 135 || - node.kind === 164) { + if (node.kind === 204 || node.kind === 203 || + node.kind === 165 || node.kind === 136 || + node.kind === 166) { var declarations = node.typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); @@ -11776,14 +12062,14 @@ var ts; } } function getOuterTypeParametersOfClassOrInterface(symbol) { - var kind = symbol.flags & 32 ? 202 : 203; + var kind = symbol.flags & 32 ? 204 : 205; return appendOuterTypeParameters(undefined, ts.getDeclarationOfKind(symbol, kind)); } - function getLocalTypeParametersOfClassOrInterface(symbol) { + function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) { var result; for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { var node = _a[_i]; - if (node.kind === 203 || node.kind === 202) { + if (node.kind === 205 || node.kind === 204 || node.kind === 206) { var declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -11793,56 +12079,109 @@ var ts; return result; } function getTypeParametersOfClassOrInterface(symbol) { - return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterface(symbol)); + return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol)); + } + function isConstructorType(type) { + return type.flags & 48128 && getSignaturesOfType(type, 1).length > 0; + } + function getBaseTypeNodeOfClass(type) { + return ts.getClassExtendsHeritageClauseElement(type.symbol.valueDeclaration); + } + function getConstructorsForTypeArguments(type, typeArgumentNodes) { + var typeArgCount = typeArgumentNodes ? typeArgumentNodes.length : 0; + return ts.filter(getSignaturesOfType(type, 1), function (sig) { return (sig.typeParameters ? sig.typeParameters.length : 0) === typeArgCount; }); + } + function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes) { + var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes); + if (typeArgumentNodes) { + var typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode); + signatures = ts.map(signatures, function (sig) { return getSignatureInstantiation(sig, typeArguments); }); + } + return signatures; + } + function getBaseConstructorTypeOfClass(type) { + if (!type.resolvedBaseConstructorType) { + var baseTypeNode = getBaseTypeNodeOfClass(type); + if (!baseTypeNode) { + return type.resolvedBaseConstructorType = undefinedType; + } + if (!pushTypeResolution(type)) { + return unknownType; + } + var baseConstructorType = checkExpression(baseTypeNode.expression); + if (baseConstructorType.flags & 48128) { + resolveObjectOrUnionTypeMembers(baseConstructorType); + } + if (!popTypeResolution()) { + error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol)); + return type.resolvedBaseConstructorType = unknownType; + } + if (baseConstructorType !== unknownType && baseConstructorType !== nullType && !isConstructorType(baseConstructorType)) { + error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType)); + return type.resolvedBaseConstructorType = unknownType; + } + type.resolvedBaseConstructorType = baseConstructorType; + } + return type.resolvedBaseConstructorType; } function getBaseTypes(type) { - var typeWithBaseTypes = type; - if (!typeWithBaseTypes.baseTypes) { + if (!type.resolvedBaseTypes) { if (type.symbol.flags & 32) { - resolveBaseTypesOfClass(typeWithBaseTypes); + resolveBaseTypesOfClass(type); } else if (type.symbol.flags & 64) { - resolveBaseTypesOfInterface(typeWithBaseTypes); + resolveBaseTypesOfInterface(type); } else { ts.Debug.fail("type must be class or interface"); } } - return typeWithBaseTypes.baseTypes; + return type.resolvedBaseTypes; } function resolveBaseTypesOfClass(type) { - type.baseTypes = []; - var declaration = ts.getDeclarationOfKind(type.symbol, 202); - var baseTypeNode = ts.getClassExtendsHeritageClauseElement(declaration); - if (baseTypeNode) { - var baseType = getTypeFromTypeNode(baseTypeNode); - if (baseType !== unknownType) { - if (getTargetType(baseType).flags & 1024) { - if (type !== baseType && !hasBaseType(baseType, type)) { - type.baseTypes.push(baseType); - } - else { - error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1)); - } - } - else { - error(baseTypeNode, ts.Diagnostics.A_class_may_only_extend_another_class); - } - } + type.resolvedBaseTypes = emptyArray; + var baseContructorType = getBaseConstructorTypeOfClass(type); + if (!(baseContructorType.flags & 48128)) { + return; } + var baseTypeNode = getBaseTypeNodeOfClass(type); + var baseType; + if (baseContructorType.symbol && baseContructorType.symbol.flags & 32) { + baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseContructorType.symbol); + } + else { + var constructors = getInstantiatedConstructorsForTypeArguments(baseContructorType, baseTypeNode.typeArguments); + if (!constructors.length) { + error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments); + return; + } + baseType = getReturnTypeOfSignature(constructors[0]); + } + if (baseType === unknownType) { + return; + } + if (!(getTargetType(baseType).flags & (1024 | 2048))) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructor_return_type_0_is_not_a_class_or_interface_type, typeToString(baseType)); + return; + } + if (type === baseType || hasBaseType(baseType, type)) { + error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1)); + return; + } + type.resolvedBaseTypes = [baseType]; } function resolveBaseTypesOfInterface(type) { - type.baseTypes = []; + type.resolvedBaseTypes = []; for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { var declaration = _a[_i]; - if (declaration.kind === 203 && ts.getInterfaceBaseTypeNodes(declaration)) { + if (declaration.kind === 205 && ts.getInterfaceBaseTypeNodes(declaration)) { for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) { var node = _c[_b]; var baseType = getTypeFromTypeNode(node); if (baseType !== unknownType) { if (getTargetType(baseType).flags & (1024 | 2048)) { if (type !== baseType && !hasBaseType(baseType, type)) { - type.baseTypes.push(baseType); + type.resolvedBaseTypes.push(baseType); } else { error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1)); @@ -11862,7 +12201,7 @@ var ts; var kind = symbol.flags & 32 ? 1024 : 2048; var type = links.declaredType = createObjectType(kind, symbol); var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol); - var localTypeParameters = getLocalTypeParametersOfClassOrInterface(symbol); + var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); if (outerTypeParameters || localTypeParameters) { type.flags |= 4096; type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters); @@ -11882,9 +12221,16 @@ var ts; if (!pushTypeResolution(links)) { return unknownType; } - var declaration = ts.getDeclarationOfKind(symbol, 204); + var declaration = ts.getDeclarationOfKind(symbol, 206); var type = getTypeFromTypeNode(declaration.type); - if (!popTypeResolution()) { + if (popTypeResolution()) { + links.typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (links.typeParameters) { + links.instantiations = {}; + links.instantiations[getTypeListId(links.typeParameters)] = type; + } + } + else { type = unknownType; error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } @@ -11906,7 +12252,7 @@ var ts; if (!links.declaredType) { var type = createType(512); type.symbol = symbol; - if (!ts.getDeclarationOfKind(symbol, 129).constraint) { + if (!ts.getDeclarationOfKind(symbol, 130).constraint) { type.constraint = noConstraintType; } links.declaredType = type; @@ -12021,34 +12367,42 @@ var ts; }); setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } - function createSignature(declaration, typeParameters, parameters, resolvedReturnType, minArgumentCount, hasRestParameter, hasStringLiterals) { + function createSignature(declaration, typeParameters, parameters, resolvedReturnType, typePredicate, minArgumentCount, hasRestParameter, hasStringLiterals) { var sig = new Signature(checker); sig.declaration = declaration; sig.typeParameters = typeParameters; sig.parameters = parameters; sig.resolvedReturnType = resolvedReturnType; + sig.typePredicate = typePredicate; sig.minArgumentCount = minArgumentCount; sig.hasRestParameter = hasRestParameter; sig.hasStringLiterals = hasStringLiterals; return sig; } function cloneSignature(sig) { - return createSignature(sig.declaration, sig.typeParameters, sig.parameters, sig.resolvedReturnType, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); + return createSignature(sig.declaration, sig.typeParameters, sig.parameters, sig.resolvedReturnType, sig.typePredicate, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); } function getDefaultConstructSignatures(classType) { - var baseTypes = getBaseTypes(classType); - if (baseTypes.length) { - var baseType = baseTypes[0]; - var baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), 1); - return ts.map(baseSignatures, function (baseSignature) { - var signature = baseType.flags & 4096 ? - getSignatureInstantiation(baseSignature, baseType.typeArguments) : cloneSignature(baseSignature); - signature.typeParameters = classType.localTypeParameters; - signature.resolvedReturnType = classType; - return signature; - }); + if (!getBaseTypes(classType).length) { + return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)]; } - return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, 0, false, false)]; + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + var baseSignatures = getSignaturesOfType(baseConstructorType, 1); + var baseTypeNode = getBaseTypeNodeOfClass(classType); + var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode); + var typeArgCount = typeArguments ? typeArguments.length : 0; + var result = []; + for (var _i = 0; _i < baseSignatures.length; _i++) { + var baseSig = baseSignatures[_i]; + var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0; + if (typeParamCount === typeArgCount) { + var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig); + sig.typeParameters = classType.localTypeParameters; + sig.resolvedReturnType = classType; + result.push(sig); + } + } + return result; } function createTupleTypeMemberSymbols(memberTypes) { var members = {}; @@ -12147,10 +12501,10 @@ var ts; if (!constructSignatures.length) { constructSignatures = getDefaultConstructSignatures(classType); } - var baseTypes = getBaseTypes(classType); - if (baseTypes.length) { + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + if (baseConstructorType.flags & 48128) { members = createSymbolTable(getNamedMembers(members)); - addInheritedMembers(members, getPropertiesOfObjectType(getTypeOfSymbol(baseTypes[0].symbol))); + addInheritedMembers(members, getPropertiesOfObjectType(baseConstructorType)); } } stringIndexType = undefined; @@ -12356,7 +12710,7 @@ var ts; function getSignatureFromDeclaration(declaration) { var links = getNodeLinks(declaration); if (!links.resolvedSignature) { - var classType = declaration.kind === 136 ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; + var classType = declaration.kind === 137 ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; var typeParameters = classType ? classType.localTypeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; var parameters = []; @@ -12378,22 +12732,31 @@ var ts; minArgumentCount = declaration.parameters.length; } var returnType; + var typePredicate; if (classType) { returnType = classType; } else if (declaration.type) { returnType = getTypeFromTypeNode(declaration.type); + if (declaration.type.kind === 143) { + var typePredicateNode = declaration.type; + typePredicate = { + parameterName: typePredicateNode.parameterName ? typePredicateNode.parameterName.text : undefined, + parameterIndex: typePredicateNode.parameterName ? getTypePredicateParameterIndex(declaration.parameters, typePredicateNode.parameterName) : undefined, + type: getTypeFromTypeNode(typePredicateNode.type) + }; + } } else { - if (declaration.kind === 137 && !ts.hasDynamicName(declaration)) { - var setter = ts.getDeclarationOfKind(declaration.symbol, 138); + if (declaration.kind === 138 && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 139); returnType = getAnnotatedAccessorType(setter); } if (!returnType && ts.nodeIsMissing(declaration.body)) { returnType = anyType; } } - links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals); + links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, typePredicate, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals); } return links.resolvedSignature; } @@ -12404,19 +12767,19 @@ var ts; for (var i = 0, len = symbol.declarations.length; i < len; i++) { var node = symbol.declarations[i]; switch (node.kind) { - case 143: - case 144: - case 201: - case 135: - case 134: + case 145: + case 146: + case 203: case 136: - case 139: + case 135: + case 137: case 140: case 141: - case 137: + case 142: case 138: - case 163: - case 164: + case 139: + case 165: + case 166: if (i > 0 && node.body) { var previous = symbol.declarations[i - 1]; if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) { @@ -12486,7 +12849,7 @@ var ts; } function getOrCreateTypeFromSignature(signature) { if (!signature.isolatedSignatureType) { - var isConstructor = signature.declaration.kind === 136 || signature.declaration.kind === 140; + var isConstructor = signature.declaration.kind === 137 || signature.declaration.kind === 141; var type = createObjectType(32768 | 131072); type.members = emptySymbols; type.properties = emptyArray; @@ -12500,7 +12863,7 @@ var ts; return symbol.members["__index"]; } function getIndexDeclarationOfSymbol(symbol, kind) { - var syntaxKind = kind === 1 ? 120 : 122; + var syntaxKind = kind === 1 ? 121 : 123; var indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { var len = indexSymbol.declarations.length; @@ -12530,13 +12893,13 @@ var ts; type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; } else { - type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 129).constraint); + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 130).constraint); } } return type.constraint === noConstraintType ? undefined : type.constraint; } function getParentSymbolOfTypeParameter(typeParameter) { - return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 129).parent); + return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 130).parent); } function getTypeListId(types) { switch (types.length) { @@ -12583,18 +12946,18 @@ var ts; while (!ts.forEach(typeParameterSymbol.declarations, function (d) { return d.parent === currentNode.parent; })) { currentNode = currentNode.parent; } - links.isIllegalTypeReferenceInConstraint = currentNode.kind === 129; + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 130; return links.isIllegalTypeReferenceInConstraint; } function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { var typeParameterSymbol; function check(n) { - if (n.kind === 142 && n.typeName.kind === 65) { + if (n.kind === 144 && n.typeName.kind === 65) { var links = getNodeLinks(n); if (links.isIllegalTypeReferenceInConstraint === undefined) { var symbol = resolveName(typeParameter, n.typeName.text, 793056, undefined, undefined); if (symbol && (symbol.flags & 262144)) { - links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent == typeParameter.parent; }); + links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent === typeParameter.parent; }); } } if (links.isIllegalTypeReferenceInConstraint) { @@ -12608,55 +12971,71 @@ var ts; check(typeParameter.constraint); } } - function getTypeFromTypeReferenceOrExpressionWithTypeArguments(node) { - var links = getNodeLinks(node); - if (!links.resolvedType) { - var type; - if (node.kind !== 177 || ts.isSupportedExpressionWithTypeArguments(node)) { - var typeNameOrExpression = node.kind === 142 - ? node.typeName - : node.expression; - var symbol = resolveEntityName(typeNameOrExpression, 793056); - if (symbol) { - if ((symbol.flags & 262144) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { - type = unknownType; - } - else { - type = createTypeReferenceIfGeneric(getDeclaredTypeOfSymbol(symbol), node, node.typeArguments); - } - } + function getTypeFromClassOrInterfaceReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var typeParameters = type.localTypeParameters; + if (typeParameters) { + if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1), typeParameters.length); + return unknownType; } - links.resolvedType = type || unknownType; + return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(node.typeArguments, getTypeFromTypeNode))); } - return links.resolvedType; - } - function createTypeReferenceIfGeneric(type, node, typeArguments) { - if (type.flags & (1024 | 2048) && type.flags & 4096) { - var localTypeParameters = type.localTypeParameters; - var expectedTypeArgCount = localTypeParameters ? localTypeParameters.length : 0; - var typeArgCount = typeArguments ? typeArguments.length : 0; - if (typeArgCount === expectedTypeArgCount) { - if (typeArgCount) { - return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(typeArguments, getTypeFromTypeNode))); - } - } - else { - error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1), expectedTypeArgCount); - return undefined; - } - } - else { - if (typeArguments) { - error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); - return undefined; - } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); + return unknownType; } return type; } + function getTypeFromTypeAliasReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var links = getSymbolLinks(symbol); + var typeParameters = links.typeParameters; + if (typeParameters) { + if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, symbolToString(symbol), typeParameters.length); + return unknownType; + } + var typeArguments = ts.map(node.typeArguments, getTypeFromTypeNode); + var id = getTypeListId(typeArguments); + return links.instantiations[id] || (links.instantiations[id] = instantiateType(type, createTypeMapper(typeParameters, typeArguments))); + } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol)); + return unknownType; + } + return type; + } + function getTypeFromNonGenericTypeReference(node, symbol) { + if (symbol.flags & 262144 && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { + return unknownType; + } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol)); + return unknownType; + } + return getDeclaredTypeOfSymbol(symbol); + } + function getTypeFromTypeReference(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var typeNameOrExpression = node.kind === 144 ? node.typeName : + ts.isSupportedExpressionWithTypeArguments(node) ? node.expression : + undefined; + var symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, 793056) || unknownSymbol; + var type = symbol === unknownSymbol ? unknownType : + symbol.flags & (32 | 64) ? getTypeFromClassOrInterfaceReference(node, symbol) : + symbol.flags & 524288 ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); + links.resolvedSymbol = symbol; + links.resolvedType = type; + } + return links.resolvedType; + } function getTypeFromTypeQueryNode(node) { var links = getNodeLinks(node); if (!links.resolvedType) { - links.resolvedType = getWidenedType(checkExpressionOrQualifiedName(node.exprName)); + links.resolvedType = getWidenedType(checkExpression(node.exprName)); } return links.resolvedType; } @@ -12666,9 +13045,9 @@ var ts; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; switch (declaration.kind) { - case 202: - case 203: + case 204: case 205: + case 207: return declaration; } } @@ -12869,38 +13248,40 @@ var ts; switch (node.kind) { case 112: return anyType; - case 122: + case 123: return stringType; - case 120: + case 121: return numberType; case 113: return booleanType; - case 123: + case 124: return esSymbolType; case 99: return voidType; case 8: return getTypeFromStringLiteral(node); - case 142: - return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 177: - return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 145: - return getTypeFromTypeQueryNode(node); - case 147: - return getTypeFromArrayTypeNode(node); - case 148: - return getTypeFromTupleTypeNode(node); - case 149: - return getTypeFromUnionTypeNode(node); - case 150: - return getTypeFromTypeNode(node.type); - case 143: case 144: + return getTypeFromTypeReference(node); + case 143: + return booleanType; + case 179: + return getTypeFromTypeReference(node); + case 147: + return getTypeFromTypeQueryNode(node); + case 149: + return getTypeFromArrayTypeNode(node); + case 150: + return getTypeFromTupleTypeNode(node); + case 151: + return getTypeFromUnionTypeNode(node); + case 152: + return getTypeFromTypeNode(node.type); + case 145: case 146: + case 148: return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); case 65: - case 127: + case 128: var symbol = getSymbolInfo(node); return symbol && getDeclaredTypeOfSymbol(symbol); default: @@ -12990,11 +13371,19 @@ var ts; } function instantiateSignature(signature, mapper, eraseTypeParameters) { var freshTypeParameters; + var freshTypePredicate; if (signature.typeParameters && !eraseTypeParameters) { freshTypeParameters = instantiateList(signature.typeParameters, mapper, instantiateTypeParameter); mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper); } - var result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); + if (signature.typePredicate) { + freshTypePredicate = { + parameterName: signature.typePredicate.parameterName, + parameterIndex: signature.typePredicate.parameterIndex, + type: instantiateType(signature.typePredicate.type, mapper) + }; + } + var result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, freshTypePredicate, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); result.target = signature; result.mapper = mapper; return result; @@ -13051,27 +13440,27 @@ var ts; return type; } function isContextSensitive(node) { - ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 || ts.isObjectLiteralMethod(node)); switch (node.kind) { - case 163: - case 164: + case 165: + case 166: return isContextSensitiveFunctionLikeDeclaration(node); - case 155: + case 157: return ts.forEach(node.properties, isContextSensitive); - case 154: + case 156: return ts.forEach(node.elements, isContextSensitive); - case 171: + case 173: return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse); - case 170: + case 172: return node.operatorToken.kind === 49 && (isContextSensitive(node.left) || isContextSensitive(node.right)); - case 225: + case 227: return isContextSensitive(node.initializer); + case 136: case 135: - case 134: return isContextSensitiveFunctionLikeDeclaration(node); - case 162: + case 164: return isContextSensitive(node.expression); } return false; @@ -13079,23 +13468,20 @@ var ts; function isContextSensitiveFunctionLikeDeclaration(node) { return !node.typeParameters && node.parameters.length && !ts.forEach(node.parameters, function (p) { return p.type; }); } - function getTypeWithoutConstructors(type) { + function getTypeWithoutSignatures(type) { if (type.flags & 48128) { var resolved = resolveObjectOrUnionTypeMembers(type); if (resolved.constructSignatures.length) { var result = createObjectType(32768, type.symbol); result.members = resolved.members; result.properties = resolved.properties; - result.callSignatures = resolved.callSignatures; + result.callSignatures = emptyArray; result.constructSignatures = emptyArray; type = result; } } return type; } - var subtypeRelation = {}; - var assignableRelation = {}; - var identityRelation = {}; function isTypeIdenticalTo(source, target) { return checkTypeRelatedTo(source, target, identityRelation, undefined); } @@ -13346,9 +13732,9 @@ var ts; maybeStack[depth][id] = 1; depth++; var saveExpandingFlags = expandingFlags; - if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack)) + if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack, depth)) expandingFlags |= 1; - if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack)) + if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack, depth)) expandingFlags |= 2; var result; if (expandingFlags === 3) { @@ -13381,21 +13767,6 @@ var ts; } return result; } - function isDeeplyNestedGeneric(type, stack) { - if (type.flags & (4096 | 65536) && depth >= 10) { - var symbol = type.symbol; - var count = 0; - for (var i = 0; i < depth; i++) { - var t = stack[i]; - if (t.flags & (4096 | 65536) && t.symbol === symbol) { - count++; - if (count >= 10) - return true; - } - } - } - return false; - } function propertiesRelatedTo(source, target, reportErrors) { if (relation === identityRelation) { return propertiesIdenticalTo(source, target); @@ -13566,6 +13937,33 @@ var ts; } result &= related; } + if (source.typePredicate && target.typePredicate) { + var hasDifferentParameterIndex = source.typePredicate.parameterIndex !== target.typePredicate.parameterIndex; + var hasDifferentTypes; + if (hasDifferentParameterIndex || + (hasDifferentTypes = !isTypeIdenticalTo(source.typePredicate.type, target.typePredicate.type))) { + if (reportErrors) { + var sourceParamText = source.typePredicate.parameterName; + var targetParamText = target.typePredicate.parameterName; + var sourceTypeText = typeToString(source.typePredicate.type); + var targetTypeText = typeToString(target.typePredicate.type); + if (hasDifferentParameterIndex) { + reportError(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, sourceParamText, targetParamText); + } + else if (hasDifferentTypes) { + reportError(ts.Diagnostics.Type_0_is_not_assignable_to_type_1, sourceTypeText, targetTypeText); + } + reportError(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, sourceParamText + " is " + sourceTypeText, targetParamText + " is " + targetTypeText); + } + return 0; + } + } + else if (!source.typePredicate && target.typePredicate) { + if (reportErrors) { + reportError(ts.Diagnostics.Signature_0_must_have_a_type_predicate, signatureToString(source)); + } + return 0; + } var t = getReturnTypeOfSignature(target); if (t === voidType) return result; @@ -13655,6 +14053,21 @@ var ts; return 0; } } + function isDeeplyNestedGeneric(type, stack, depth) { + if (type.flags & (4096 | 65536) && depth >= 5) { + var symbol = type.symbol; + var count = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (t.flags & (4096 | 65536) && t.symbol === symbol) { + count++; + if (count >= 5) + return true; + } + } + } + return false; + } function isPropertyIdenticalTo(sourceProp, targetProp) { return compareProperties(sourceProp, targetProp, compareTypes) !== 0; } @@ -13845,22 +14258,22 @@ var ts; var typeAsString = typeToString(getWidenedType(type)); var diagnostic; switch (declaration.kind) { + case 134: case 133: - case 132: diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; break; - case 130: + case 131: diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; break; - case 201: + case 203: + case 136: case 135: - case 134: - case 137: case 138: - case 163: - case 164: + case 139: + case 165: + case 166: if (!declaration.name) { error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); return; @@ -13932,20 +14345,6 @@ var ts; } return false; } - function isWithinDepthLimit(type, stack) { - if (depth >= 5) { - var target_1 = type.target; - var count = 0; - for (var i = 0; i < depth; i++) { - var t = stack[i]; - if (t.flags & 4096 && t.target === target_1) { - count++; - } - } - return count < 5; - } - return true; - } function inferFromTypes(source, target) { if (source === anyFunctionType) { return; @@ -14003,22 +14402,26 @@ var ts; } else if (source.flags & 48128 && (target.flags & (4096 | 8192) || (target.flags & 32768) && target.symbol && target.symbol.flags & (8192 | 2048))) { - if (!isInProcess(source, target) && isWithinDepthLimit(source, sourceStack) && isWithinDepthLimit(target, targetStack)) { - if (depth === 0) { - sourceStack = []; - targetStack = []; - } - sourceStack[depth] = source; - targetStack[depth] = target; - depth++; - inferFromProperties(source, target); - inferFromSignatures(source, target, 0); - inferFromSignatures(source, target, 1); - inferFromIndexTypes(source, target, 0, 0); - inferFromIndexTypes(source, target, 1, 1); - inferFromIndexTypes(source, target, 0, 1); - depth--; + if (isInProcess(source, target)) { + return; } + if (isDeeplyNestedGeneric(source, sourceStack, depth) && isDeeplyNestedGeneric(target, targetStack, depth)) { + return; + } + if (depth === 0) { + sourceStack = []; + targetStack = []; + } + sourceStack[depth] = source; + targetStack[depth] = target; + depth++; + inferFromProperties(source, target); + inferFromSignatures(source, target, 0); + inferFromSignatures(source, target, 1); + inferFromIndexTypes(source, target, 0, 0); + inferFromIndexTypes(source, target, 1, 1); + inferFromIndexTypes(source, target, 0, 1); + depth--; } } function inferFromProperties(source, target) { @@ -14043,7 +14446,14 @@ var ts; } function inferFromSignature(source, target) { forEachMatchingParameterType(source, target, inferFromTypes); - inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + if (source.typePredicate && target.typePredicate) { + if (target.typePredicate.parameterIndex === source.typePredicate.parameterIndex) { + inferFromTypes(source.typePredicate.type, target.typePredicate.type); + } + } + else { + inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } } function inferFromIndexTypes(source, target, sourceKind, targetKind) { var targetIndexType = getIndexTypeOfType(target, targetKind); @@ -14103,10 +14513,10 @@ var ts; function isInTypeQuery(node) { while (node) { switch (node.kind) { - case 145: + case 147: return true; case 65: - case 127: + case 128: node = node.parent; continue; default: @@ -14148,7 +14558,7 @@ var ts; function isAssignedInBinaryExpression(node) { if (node.operatorToken.kind >= 53 && node.operatorToken.kind <= 64) { var n = node.left; - while (n.kind === 162) { + while (n.kind === 164) { n = n.expression; } if (n.kind === 65 && getResolvedSymbol(n) === symbol) { @@ -14165,46 +14575,46 @@ var ts; } function isAssignedIn(node) { switch (node.kind) { - case 170: + case 172: return isAssignedInBinaryExpression(node); - case 199: - case 153: - return isAssignedInVariableDeclaration(node); - case 151: - case 152: - case 154: + case 201: case 155: + return isAssignedInVariableDeclaration(node); + case 153: + case 154: case 156: case 157: case 158: case 159: + case 160: case 161: - case 162: - case 168: - case 165: - case 166: + case 163: + case 164: + case 170: case 167: + case 168: case 169: case 171: - case 174: - case 180: - case 181: + case 173: + case 176: + case 182: case 183: - case 184: case 185: case 186: case 187: case 188: case 189: - case 192: - case 193: + case 190: + case 191: case 194: - case 221: - case 222: case 195: case 196: - case 197: + case 223: case 224: + case 197: + case 198: + case 199: + case 226: return ts.forEachChild(node, isAssignedIn); } return false; @@ -14241,17 +14651,17 @@ var ts; node = node.parent; var narrowedType = type; switch (node.kind) { - case 184: + case 186: if (child !== node.expression) { narrowedType = narrowType(type, node.expression, child === node.thenStatement); } break; - case 171: + case 173: if (child !== node.condition) { narrowedType = narrowType(type, node.condition, child === node.whenTrue); } break; - case 170: + case 172: if (child === node.right) { if (node.operatorToken.kind === 48) { narrowedType = narrowType(type, node.left, true); @@ -14261,14 +14671,14 @@ var ts; } } break; - case 228: - case 206: - case 201: - case 135: - case 134: - case 137: - case 138: + case 230: + case 208: + case 203: case 136: + case 135: + case 138: + case 139: + case 137: break loop; } if (narrowedType !== type) { @@ -14282,7 +14692,7 @@ var ts; } return type; function narrowTypeByEquality(type, expr, assumeTrue) { - if (expr.left.kind !== 166 || expr.right.kind !== 8) { + if (expr.left.kind !== 168 || expr.right.kind !== 8) { return type; } var left = expr.left; @@ -14361,20 +14771,44 @@ var ts; } } if (targetType) { - if (isTypeSubtypeOf(targetType, type)) { - return targetType; - } - if (type.flags & 16384) { - return getUnionType(ts.filter(type.types, function (t) { return isTypeSubtypeOf(t, targetType); })); + return getNarrowedType(type, targetType); + } + return type; + } + function getNarrowedType(originalType, narrowedTypeCandidate) { + if (isTypeSubtypeOf(narrowedTypeCandidate, originalType)) { + return narrowedTypeCandidate; + } + if (originalType.flags & 16384) { + return getUnionType(ts.filter(originalType.types, function (t) { return isTypeSubtypeOf(t, narrowedTypeCandidate); })); + } + return originalType; + } + function narrowTypeByTypePredicate(type, expr, assumeTrue) { + if (type.flags & 1) { + return type; + } + var signature = getResolvedSignature(expr); + if (signature.typePredicate && + expr.arguments[signature.typePredicate.parameterIndex] && + getSymbolAtLocation(expr.arguments[signature.typePredicate.parameterIndex]) === symbol) { + if (!assumeTrue) { + if (type.flags & 16384) { + return getUnionType(ts.filter(type.types, function (t) { return !isTypeSubtypeOf(t, signature.typePredicate.type); })); + } + return type; } + return getNarrowedType(type, signature.typePredicate.type); } return type; } function narrowType(type, expr, assumeTrue) { switch (expr.kind) { - case 162: + case 160: + return narrowTypeByTypePredicate(type, expr, assumeTrue); + case 164: return narrowType(type, expr.expression, assumeTrue); - case 170: + case 172: var operator = expr.operatorToken.kind; if (operator === 30 || operator === 31) { return narrowTypeByEquality(type, expr, assumeTrue); @@ -14389,7 +14823,7 @@ var ts; return narrowTypeByInstanceof(type, expr, assumeTrue); } break; - case 168: + case 170: if (expr.operator === 46) { return narrowType(type, expr.operand, !assumeTrue); } @@ -14400,7 +14834,7 @@ var ts; } function checkIdentifier(node) { var symbol = getResolvedSymbol(node); - if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 164 && languageVersion < 2) { + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 166 && languageVersion < 2) { error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); } if (symbol.flags & 8388608 && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { @@ -14424,15 +14858,15 @@ var ts; function checkBlockScopedBindingCapturedInLoop(node, symbol) { if (languageVersion >= 2 || (symbol.flags & 2) === 0 || - symbol.valueDeclaration.parent.kind === 224) { + symbol.valueDeclaration.parent.kind === 226) { return; } var container = symbol.valueDeclaration; - while (container.kind !== 200) { + while (container.kind !== 202) { container = container.parent; } container = container.parent; - if (container.kind === 181) { + if (container.kind === 183) { container = container.parent; } var inFunction = isInsideFunction(node.parent, container); @@ -14449,9 +14883,9 @@ var ts; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 202 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 204 ? container.parent : undefined; getNodeLinks(node).flags |= 2; - if (container.kind === 133 || container.kind === 136) { + if (container.kind === 134 || container.kind === 137) { getNodeLinks(classNode).flags |= 4; } else { @@ -14461,36 +14895,36 @@ var ts; function checkThisExpression(node) { var container = ts.getThisContainer(node, true); var needToCaptureLexicalThis = false; - if (container.kind === 164) { + if (container.kind === 166) { container = ts.getThisContainer(container, false); needToCaptureLexicalThis = (languageVersion < 2); } switch (container.kind) { - case 206: + case 208: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body); break; - case 205: + case 207: error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); break; - case 136: + case 137: if (isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); } break; + case 134: case 133: - case 132: if (container.flags & 128) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); } break; - case 128: + case 129: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name); break; } if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 202 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 204 ? container.parent : undefined; if (classNode) { var symbol = getSymbolOfNode(classNode); return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); @@ -14499,23 +14933,21 @@ var ts; } function isInConstructorArgumentInitializer(node, constructorDecl) { for (var n = node; n && n !== constructorDecl; n = n.parent) { - if (n.kind === 130) { + if (n.kind === 131) { return true; } } return false; } function checkSuperExpression(node) { - var isCallExpression = node.parent.kind === 158 && node.parent.expression === node; - var enclosingClass = ts.getAncestor(node, 202); - var baseClass; - if (enclosingClass && ts.getClassExtendsHeritageClauseElement(enclosingClass)) { - var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); - var baseTypes = getBaseTypes(classType); - baseClass = baseTypes.length && baseTypes[0]; - } - if (!baseClass) { - error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + var isCallExpression = node.parent.kind === 160 && node.parent.expression === node; + var classDeclaration = ts.getAncestor(node, 204); + var classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); + var baseClassType = classType && getBaseTypes(classType)[0]; + if (!baseClassType) { + if (!classDeclaration || !ts.getClassExtendsHeritageClauseElement(classDeclaration)) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + } return unknownType; } var container = ts.getSuperContainer(node, true); @@ -14523,31 +14955,31 @@ var ts; var canUseSuperExpression = false; var needToCaptureLexicalThis; if (isCallExpression) { - canUseSuperExpression = container.kind === 136; + canUseSuperExpression = container.kind === 137; } else { needToCaptureLexicalThis = false; - while (container && container.kind === 164) { + while (container && container.kind === 166) { container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = languageVersion < 2; } - if (container && container.parent && container.parent.kind === 202) { + if (container && container.parent && container.parent.kind === 204) { if (container.flags & 128) { canUseSuperExpression = - container.kind === 135 || - container.kind === 134 || - container.kind === 137 || - container.kind === 138; + container.kind === 136 || + container.kind === 135 || + container.kind === 138 || + container.kind === 139; } else { canUseSuperExpression = - container.kind === 135 || - container.kind === 134 || - container.kind === 137 || + container.kind === 136 || + container.kind === 135 || container.kind === 138 || + container.kind === 139 || + container.kind === 134 || container.kind === 133 || - container.kind === 132 || - container.kind === 136; + container.kind === 137; } } } @@ -14555,13 +14987,13 @@ var ts; var returnType; if ((container.flags & 128) || isCallExpression) { getNodeLinks(node).flags |= 32; - returnType = getTypeOfSymbol(baseClass.symbol); + returnType = getBaseConstructorTypeOfClass(classType); } else { getNodeLinks(node).flags |= 16; - returnType = baseClass; + returnType = baseClassType; } - if (container.kind === 136 && isInConstructorArgumentInitializer(node, container)) { + if (container.kind === 137 && isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); returnType = unknownType; } @@ -14571,7 +15003,7 @@ var ts; return returnType; } } - if (container && container.kind === 128) { + if (container && container.kind === 129) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); } else if (isCallExpression) { @@ -14609,7 +15041,7 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130) { + if (declaration.kind === 131) { var type = getContextuallyTypedParameterType(declaration); if (type) { return type; @@ -14642,8 +15074,8 @@ var ts; } function getContextualReturnType(functionDecl) { if (functionDecl.type || - functionDecl.kind === 136 || - functionDecl.kind === 137 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 138))) { + functionDecl.kind === 137 || + functionDecl.kind === 138 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 139))) { return getReturnTypeOfSignature(getSignatureFromDeclaration(functionDecl)); } var signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl); @@ -14662,7 +15094,7 @@ var ts; return undefined; } function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { - if (template.parent.kind === 160) { + if (template.parent.kind === 162) { return getContextualTypeForArgument(template.parent, substitutionExpression); } return undefined; @@ -14770,34 +15202,34 @@ var ts; } var parent = node.parent; switch (parent.kind) { - case 199: - case 130: + case 201: + case 131: + case 134: case 133: - case 132: - case 153: + case 155: return getContextualTypeForInitializerExpression(node); - case 164: - case 192: + case 166: + case 194: return getContextualTypeForReturnExpression(node); - case 173: + case 175: return getContextualTypeForYieldOperand(parent); - case 158: - case 159: - return getContextualTypeForArgument(parent, node); + case 160: case 161: + return getContextualTypeForArgument(parent, node); + case 163: return getTypeFromTypeNode(parent.type); - case 170: + case 172: return getContextualTypeForBinaryOperand(node); - case 225: + case 227: return getContextualTypeForObjectLiteralElement(parent); - case 154: + case 156: return getContextualTypeForElementExpression(node); - case 171: + case 173: return getContextualTypeForConditionalOperand(node); - case 178: - ts.Debug.assert(parent.parent.kind === 172); + case 180: + ts.Debug.assert(parent.parent.kind === 174); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case 162: + case 164: return getContextualType(parent); } return undefined; @@ -14812,7 +15244,7 @@ var ts; } } function isFunctionExpressionOrArrowFunction(node) { - return node.kind === 163 || node.kind === 164; + return node.kind === 165 || node.kind === 166; } function getContextualSignatureForFunctionLikeDeclaration(node) { return isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node) @@ -14820,7 +15252,7 @@ var ts; : undefined; } function getContextualSignature(node) { - ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 || ts.isObjectLiteralMethod(node)); var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); @@ -14864,13 +15296,13 @@ var ts; } function isAssignmentTarget(node) { var parent = node.parent; - if (parent.kind === 170 && parent.operatorToken.kind === 53 && parent.left === node) { + if (parent.kind === 172 && parent.operatorToken.kind === 53 && parent.left === node) { return true; } - if (parent.kind === 225) { + if (parent.kind === 227) { return isAssignmentTarget(parent.parent); } - if (parent.kind === 154) { + if (parent.kind === 156) { return isAssignmentTarget(parent); } return false; @@ -14889,7 +15321,7 @@ var ts; var inDestructuringPattern = isAssignmentTarget(node); for (var _i = 0; _i < elements.length; _i++) { var e = elements[_i]; - if (inDestructuringPattern && e.kind === 174) { + if (inDestructuringPattern && e.kind === 176) { var restArrayType = checkExpression(e.expression, contextualMapper); var restElementType = getIndexTypeOfType(restArrayType, 1) || (languageVersion >= 2 ? getElementTypeOfIterable(restArrayType, undefined) : undefined); @@ -14901,7 +15333,7 @@ var ts; var type = checkExpression(e, contextualMapper); elementTypes.push(type); } - hasSpreadElement = hasSpreadElement || e.kind === 174; + hasSpreadElement = hasSpreadElement || e.kind === 176; } if (!hasSpreadElement) { var contextualType = getContextualType(node); @@ -14912,7 +15344,7 @@ var ts; return createArrayType(getUnionType(elementTypes)); } function isNumericName(name) { - return name.kind === 128 ? isNumericComputedName(name) : isNumericLiteralName(name.text); + return name.kind === 129 ? isNumericComputedName(name) : isNumericLiteralName(name.text); } function isNumericComputedName(name) { return isTypeAnyOrAllConstituentTypesHaveKind(checkComputedPropertyName(name), 132); @@ -14945,18 +15377,18 @@ var ts; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var memberDecl = _a[_i]; var member = memberDecl.symbol; - if (memberDecl.kind === 225 || - memberDecl.kind === 226 || + if (memberDecl.kind === 227 || + memberDecl.kind === 228 || ts.isObjectLiteralMethod(memberDecl)) { var type = void 0; - if (memberDecl.kind === 225) { + if (memberDecl.kind === 227) { type = checkPropertyAssignment(memberDecl, contextualMapper); } - else if (memberDecl.kind === 135) { + else if (memberDecl.kind === 136) { type = checkObjectLiteralMethod(memberDecl, contextualMapper); } else { - ts.Debug.assert(memberDecl.kind === 226); + ts.Debug.assert(memberDecl.kind === 228); type = checkExpression(memberDecl.name, contextualMapper); } typeFlags |= type.flags; @@ -14971,7 +15403,7 @@ var ts; member = prop; } else { - ts.Debug.assert(memberDecl.kind === 137 || memberDecl.kind === 138); + ts.Debug.assert(memberDecl.kind === 138 || memberDecl.kind === 139); checkAccessorDeclaration(memberDecl); } if (!ts.hasDynamicName(memberDecl)) { @@ -15004,7 +15436,7 @@ var ts; } } function getDeclarationKindFromSymbol(s) { - return s.valueDeclaration ? s.valueDeclaration.kind : 133; + return s.valueDeclaration ? s.valueDeclaration.kind : 134; } function getDeclarationFlagsFromSymbol(s) { return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0; @@ -15014,7 +15446,7 @@ var ts; if (!(flags & (32 | 64))) { return; } - var enclosingClassDeclaration = ts.getAncestor(node, 202); + var enclosingClassDeclaration = ts.getAncestor(node, 204); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); if (flags & 32) { @@ -15044,7 +15476,7 @@ var ts; return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right); } function checkPropertyAccessExpressionOrQualifiedName(node, left, right) { - var type = checkExpressionOrQualifiedName(left); + var type = checkExpression(left); if (isTypeAny(type)) { return type; } @@ -15061,7 +15493,7 @@ var ts; } getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & 32) { - if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 135) { + if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 136) { error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { @@ -15071,14 +15503,14 @@ var ts; return getTypeOfSymbol(prop); } function isValidPropertyAccess(node, propertyName) { - var left = node.kind === 156 + var left = node.kind === 158 ? node.expression : node.left; - var type = checkExpressionOrQualifiedName(left); + var type = checkExpression(left); if (type !== unknownType && !isTypeAny(type)) { var prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & 32) { - if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 135) { + if (left.kind === 91 && getDeclarationKindFromSymbol(prop) !== 136) { return false; } else { @@ -15093,7 +15525,7 @@ var ts; function checkIndexedAccess(node) { if (!node.argumentExpression) { var sourceFile = getSourceFile(node); - if (node.parent.kind === 159 && node.parent.expression === node) { + if (node.parent.kind === 161 && node.parent.expression === node) { var start = ts.skipTrivia(sourceFile.text, node.expression.end); var end = node.end; grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead); @@ -15189,7 +15621,7 @@ var ts; return true; } function resolveUntypedCall(node) { - if (node.kind === 160) { + if (node.kind === 162) { checkExpression(node.template); } else { @@ -15242,7 +15674,7 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 174) { + if (args[i].kind === 176) { return i; } } @@ -15252,11 +15684,11 @@ var ts; var adjustedArgCount; var typeArguments; var callIsIncomplete; - if (node.kind === 160) { + if (node.kind === 162) { var tagExpression = node; adjustedArgCount = args.length; typeArguments = undefined; - if (tagExpression.template.kind === 172) { + if (tagExpression.template.kind === 174) { var templateExpression = tagExpression.template; var lastSpan = ts.lastOrUndefined(templateExpression.templateSpans); ts.Debug.assert(lastSpan !== undefined); @@ -15271,7 +15703,7 @@ var ts; else { var callExpression = node; if (!callExpression.arguments) { - ts.Debug.assert(callExpression.kind === 159); + ts.Debug.assert(callExpression.kind === 161); return signature.minArgumentCount === 0; } adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; @@ -15323,10 +15755,10 @@ var ts; } for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176) { + if (arg.kind !== 178) { var paramType = getTypeAtPosition(signature, i); var argType = void 0; - if (i === 0 && args[i].parent.kind === 160) { + if (i === 0 && args[i].parent.kind === 162) { argType = globalTemplateStringsArrayType; } else { @@ -15366,9 +15798,9 @@ var ts; function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176) { + if (arg.kind !== 178) { var paramType = getTypeAtPosition(signature, i); - var argType = i === 0 && node.kind === 160 + var argType = i === 0 && node.kind === 162 ? globalTemplateStringsArrayType : arg.kind === 8 && !reportErrors ? getStringLiteralType(arg) @@ -15382,10 +15814,10 @@ var ts; } function getEffectiveCallArguments(node) { var args; - if (node.kind === 160) { + if (node.kind === 162) { var template = node.template; args = [template]; - if (template.kind === 172) { + if (template.kind === 174) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); @@ -15396,21 +15828,11 @@ var ts; } return args; } - function getEffectiveTypeArguments(callExpression) { - if (callExpression.expression.kind === 91) { - var containingClass = ts.getAncestor(callExpression, 202); - var baseClassTypeNode = containingClass && ts.getClassExtendsHeritageClauseElement(containingClass); - return baseClassTypeNode && baseClassTypeNode.typeArguments; - } - else { - return callExpression.typeArguments; - } - } function resolveCall(node, signatures, candidatesOutArray) { - var isTaggedTemplate = node.kind === 160; + var isTaggedTemplate = node.kind === 162; var typeArguments; if (!isTaggedTemplate) { - typeArguments = getEffectiveTypeArguments(node); + typeArguments = node.typeArguments; if (node.expression.kind !== 91) { ts.forEach(typeArguments, checkSourceElement); } @@ -15451,8 +15873,8 @@ var ts; checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && node.typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true); + if (!isTaggedTemplate && typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], true); } else { ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); @@ -15536,7 +15958,9 @@ var ts; if (node.expression.kind === 91) { var superType = checkSuperExpression(node.expression); if (superType !== unknownType) { - return resolveCall(node, getSignaturesOfType(superType, 1), candidatesOutArray); + var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getAncestor(node, 204)); + var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); + return resolveCall(node, baseConstructors, candidatesOutArray); } return resolveUntypedCall(node); } @@ -15617,13 +16041,13 @@ var ts; var links = getNodeLinks(node); if (!links.resolvedSignature || candidatesOutArray) { links.resolvedSignature = anySignature; - if (node.kind === 158) { + if (node.kind === 160) { links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); } - else if (node.kind === 159) { + else if (node.kind === 161) { links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); } - else if (node.kind === 160) { + else if (node.kind === 162) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } else { @@ -15638,12 +16062,12 @@ var ts; if (node.expression.kind === 91) { return voidType; } - if (node.kind === 159) { + if (node.kind === 161) { var declaration = signature.declaration; if (declaration && - declaration.kind !== 136 && - declaration.kind !== 140 && - declaration.kind !== 144) { + declaration.kind !== 137 && + declaration.kind !== 141 && + declaration.kind !== 146) { if (compilerOptions.noImplicitAny) { error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); } @@ -15690,7 +16114,7 @@ var ts; return unknownType; } var type; - if (func.body.kind !== 180) { + if (func.body.kind !== 182) { type = checkExpressionCached(func.body, contextualMapper); } else { @@ -15767,7 +16191,7 @@ var ts; }); } function bodyContainsSingleThrowStatement(body) { - return (body.statements.length === 1) && (body.statements[0].kind === 196); + return (body.statements.length === 1) && (body.statements[0].kind === 198); } function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) { if (!produceDiagnostics) { @@ -15776,7 +16200,7 @@ var ts; if (returnType === voidType || isTypeAny(returnType)) { return; } - if (ts.nodeIsMissing(func.body) || func.body.kind !== 180) { + if (ts.nodeIsMissing(func.body) || func.body.kind !== 182) { return; } var bodyBlock = func.body; @@ -15789,10 +16213,10 @@ var ts; error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement); } function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) { - ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); - var hasGrammarError = checkGrammarDeclarationNameInStrictMode(node) || checkGrammarFunctionLikeDeclaration(node); - if (!hasGrammarError && node.kind === 163) { - checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); + ts.Debug.assert(node.kind !== 136 || ts.isObjectLiteralMethod(node)); + var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); + if (!hasGrammarError && node.kind === 165) { + checkGrammarForGenerator(node); } if (contextualMapper === identityMapper && isContextSensitive(node)) { return anyFunctionType; @@ -15818,14 +16242,14 @@ var ts; checkSignatureDeclaration(node); } } - if (produceDiagnostics && node.kind !== 135 && node.kind !== 134) { + if (produceDiagnostics && node.kind !== 136 && node.kind !== 135) { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); } return type; } function checkFunctionExpressionOrObjectLiteralMethodBody(node) { - ts.Debug.assert(node.kind !== 135 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 || ts.isObjectLiteralMethod(node)); if (node.type && !node.asteriskToken) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } @@ -15833,7 +16257,7 @@ var ts; if (!node.type) { getReturnTypeOfSignature(getSignatureFromDeclaration(node)); } - if (node.body.kind === 180) { + if (node.body.kind === 182) { checkSourceElement(node.body); } else { @@ -15863,13 +16287,13 @@ var ts; var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3) !== 0; } - case 156: { + case 158: { var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || (symbol.flags & ~8) !== 0; } - case 157: + case 159: return true; - case 162: + case 164: return isReferenceOrErrorExpression(n.expression); default: return false; @@ -15878,11 +16302,11 @@ var ts; function isConstVariableReference(n) { switch (n.kind) { case 65: - case 156: { + case 158: { var symbol = findSymbol(n); return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 8192) !== 0; } - case 157: { + case 159: { var index = n.argumentExpression; var symbol = findSymbol(n.expression); if (symbol && index && index.kind === 8) { @@ -15892,7 +16316,7 @@ var ts; } return false; } - case 162: + case 164: return isConstVariableReference(n.expression); default: return false; @@ -15909,10 +16333,7 @@ var ts; return true; } function checkDeleteExpression(node) { - if (node.parserContextFlags & 1 && node.expression.kind === 65) { - grammarErrorOnNode(node.expression, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode); - } - var operandType = checkExpression(node.expression); + checkExpression(node.expression); return booleanType; } function checkTypeOfExpression(node) { @@ -15924,9 +16345,6 @@ var ts; return undefinedType; } function checkPrefixUnaryExpression(node) { - if ((node.operator === 38 || node.operator === 39)) { - checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); - } var operandType = checkExpression(node.operand); switch (node.operator) { case 33: @@ -15949,7 +16367,6 @@ var ts; return unknownType; } function checkPostfixUnaryExpression(node) { - checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); var operandType = checkExpression(node.operand); var ok = checkArithmeticOperandType(node.operand, operandType, ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type); if (ok) { @@ -16017,7 +16434,7 @@ var ts; var properties = node.properties; for (var _i = 0; _i < properties.length; _i++) { var p = properties[_i]; - if (p.kind === 225 || p.kind === 226) { + if (p.kind === 227 || p.kind === 228) { var name_12 = p.name; var type = isTypeAny(sourceType) ? sourceType @@ -16042,8 +16459,8 @@ var ts; var elements = node.elements; for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176) { - if (e.kind !== 174) { + if (e.kind !== 178) { + if (e.kind !== 176) { var propName = "" + i; var type = isTypeAny(sourceType) ? sourceType @@ -16068,7 +16485,7 @@ var ts; } else { var restExpression = e.expression; - if (restExpression.kind === 170 && restExpression.operatorToken.kind === 53) { + if (restExpression.kind === 172 && restExpression.operatorToken.kind === 53) { error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } else { @@ -16081,14 +16498,14 @@ var ts; return sourceType; } function checkDestructuringAssignment(target, sourceType, contextualMapper) { - if (target.kind === 170 && target.operatorToken.kind === 53) { + if (target.kind === 172 && target.operatorToken.kind === 53) { checkBinaryExpression(target, contextualMapper); target = target.left; } - if (target.kind === 155) { + if (target.kind === 157) { return checkObjectLiteralAssignment(target, sourceType, contextualMapper); } - if (target.kind === 154) { + if (target.kind === 156) { return checkArrayLiteralAssignment(target, sourceType, contextualMapper); } return checkReferenceAssignment(target, sourceType, contextualMapper); @@ -16101,11 +16518,8 @@ var ts; return sourceType; } function checkBinaryExpression(node, contextualMapper) { - if (ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { - checkGrammarEvalOrArgumentsInStrictMode(node, node.left); - } var operator = node.operatorToken.kind; - if (operator === 53 && (node.left.kind === 155 || node.left.kind === 154)) { + if (operator === 53 && (node.left.kind === 157 || node.left.kind === 156)) { return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); } var leftType = checkExpression(node.left, contextualMapper); @@ -16251,7 +16665,7 @@ var ts; if (ts.isFunctionLike(parent) && current === parent.body) { return false; } - else if (current.kind === 202 || current.kind === 175) { + else if (current.kind === 204 || current.kind === 177) { return true; } current = parent; @@ -16312,14 +16726,14 @@ var ts; return links.resolvedType; } function checkPropertyAssignment(node, contextualMapper) { - if (node.name.kind === 128) { + if (node.name.kind === 129) { checkComputedPropertyName(node.name); } return checkExpression(node.initializer, contextualMapper); } function checkObjectLiteralMethod(node, contextualMapper) { checkGrammarMethod(node); - if (node.name.kind === 128) { + if (node.name.kind === 129) { checkComputedPropertyName(node.name); } var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); @@ -16341,12 +16755,8 @@ var ts; return type; } function checkExpression(node, contextualMapper) { - checkGrammarIdentifierInStrictMode(node); - return checkExpressionOrQualifiedName(node, contextualMapper); - } - function checkExpressionOrQualifiedName(node, contextualMapper) { var type; - if (node.kind == 127) { + if (node.kind === 128) { type = checkQualifiedName(node); } else { @@ -16354,9 +16764,9 @@ var ts; type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper); } if (isConstEnumObjectType(type)) { - var ok = (node.parent.kind === 156 && node.parent.expression === node) || - (node.parent.kind === 157 && node.parent.expression === node) || - ((node.kind === 65 || node.kind === 127) && isInRightSideOfImportOrExportAssignment(node)); + var ok = (node.parent.kind === 158 && node.parent.expression === node) || + (node.parent.kind === 159 && node.parent.expression === node) || + ((node.kind === 65 || node.kind === 128) && isInRightSideOfImportOrExportAssignment(node)); if (!ok) { error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment); } @@ -16382,60 +16792,59 @@ var ts; return booleanType; case 7: return checkNumericLiteral(node); - case 172: + case 174: return checkTemplateExpression(node); case 8: case 10: return stringType; case 9: return globalRegExpType; - case 154: - return checkArrayLiteral(node, contextualMapper); - case 155: - return checkObjectLiteral(node, contextualMapper); case 156: - return checkPropertyAccessExpression(node); + return checkArrayLiteral(node, contextualMapper); case 157: - return checkIndexedAccess(node); + return checkObjectLiteral(node, contextualMapper); case 158: + return checkPropertyAccessExpression(node); case 159: - return checkCallExpression(node); + return checkIndexedAccess(node); case 160: - return checkTaggedTemplateExpression(node); case 161: - return checkTypeAssertion(node); + return checkCallExpression(node); case 162: - return checkExpression(node.expression, contextualMapper); - case 175: - return checkClassExpression(node); + return checkTaggedTemplateExpression(node); case 163: + return checkTypeAssertion(node); case 164: - return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); - case 166: - return checkTypeOfExpression(node); + return checkExpression(node.expression, contextualMapper); + case 177: + return checkClassExpression(node); case 165: - return checkDeleteExpression(node); - case 167: - return checkVoidExpression(node); + case 166: + return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); case 168: - return checkPrefixUnaryExpression(node); + return checkTypeOfExpression(node); + case 167: + return checkDeleteExpression(node); case 169: - return checkPostfixUnaryExpression(node); + return checkVoidExpression(node); case 170: - return checkBinaryExpression(node, contextualMapper); + return checkPrefixUnaryExpression(node); case 171: - return checkConditionalExpression(node, contextualMapper); - case 174: - return checkSpreadElementExpression(node, contextualMapper); - case 176: - return undefinedType; + return checkPostfixUnaryExpression(node); + case 172: + return checkBinaryExpression(node, contextualMapper); case 173: + return checkConditionalExpression(node, contextualMapper); + case 176: + return checkSpreadElementExpression(node, contextualMapper); + case 178: + return undefinedType; + case 175: return checkYieldExpression(node); } return unknownType; } function checkTypeParameter(node) { - checkGrammarDeclarationNameInStrictMode(node); if (node.expression) { grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected); } @@ -16450,14 +16859,12 @@ var ts; // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code // or if its FunctionBody is strict code(11.1.5). - // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a - // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) - checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + checkGrammarDecorators(node) || checkGrammarModifiers(node); checkVariableLikeDeclaration(node); var func = ts.getContainingFunction(node); if (node.flags & 112) { func = ts.getContainingFunction(node); - if (!(func.kind === 136 && ts.nodeIsPresent(func.body))) { + if (!(func.kind === 137 && ts.nodeIsPresent(func.body))) { error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } @@ -16472,32 +16879,106 @@ var ts; if (!node.asteriskToken || !node.body) { return false; } - return node.kind === 135 || - node.kind === 201 || - node.kind === 163; + return node.kind === 136 || + node.kind === 203 || + node.kind === 165; + } + function getTypePredicateParameterIndex(parameterList, parameter) { + if (parameterList) { + for (var i = 0; i < parameterList.length; i++) { + var param = parameterList[i]; + if (param.name.kind === 65 && + param.name.text === parameter.text) { + return i; + } + } + } + return -1; + } + function isInLegalTypePredicatePosition(node) { + switch (node.parent.kind) { + case 166: + case 140: + case 203: + case 165: + case 145: + case 136: + case 135: + return node === node.parent.type; + } + return false; } function checkSignatureDeclaration(node) { - if (node.kind === 141) { + if (node.kind === 142) { checkGrammarIndexSignature(node); } - else if (node.kind === 143 || node.kind === 201 || node.kind === 144 || - node.kind === 139 || node.kind === 136 || - node.kind === 140) { + else if (node.kind === 145 || node.kind === 203 || node.kind === 146 || + node.kind === 140 || node.kind === 137 || + node.kind === 141) { checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); ts.forEach(node.parameters, checkParameter); if (node.type) { - checkSourceElement(node.type); + if (node.type.kind === 143) { + var typePredicate = getSignatureFromDeclaration(node).typePredicate; + var typePredicateNode = node.type; + if (isInLegalTypePredicatePosition(typePredicateNode)) { + if (typePredicate.parameterIndex >= 0) { + if (node.parameters[typePredicate.parameterIndex].dotDotDotToken) { + error(typePredicateNode.parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter); + } + else { + checkTypeAssignableTo(typePredicate.type, getTypeAtLocation(node.parameters[typePredicate.parameterIndex]), typePredicateNode.type); + } + } + else if (typePredicateNode.parameterName) { + var hasReportedError = false; + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var param = _a[_i]; + if (hasReportedError) { + break; + } + if (param.name.kind === 153 || + param.name.kind === 154) { + (function checkBindingPattern(pattern) { + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (element.name.kind === 65 && + element.name.text === typePredicate.parameterName) { + error(typePredicateNode.parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, typePredicate.parameterName); + hasReportedError = true; + break; + } + else if (element.name.kind === 154 || + element.name.kind === 153) { + checkBindingPattern(element.name); + } + } + })(param.name); + } + } + if (!hasReportedError) { + error(typePredicateNode.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName); + } + } + } + else { + error(typePredicateNode, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + } + } + else { + checkSourceElement(node.type); + } } if (produceDiagnostics) { checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { - case 140: + case 141: error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; - case 139: + case 140: error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; } @@ -16519,7 +17000,7 @@ var ts; checkSpecializedSignatureDeclaration(node); } function checkTypeForDuplicateIndexSignatures(node) { - if (node.kind === 203) { + if (node.kind === 205) { var nodeSymbol = getSymbolOfNode(node); if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { return; @@ -16534,7 +17015,7 @@ var ts; var declaration = decl; if (declaration.parameters.length === 1 && declaration.parameters[0].type) { switch (declaration.parameters[0].type.kind) { - case 122: + case 123: if (!seenStringIndexer) { seenStringIndexer = true; } @@ -16542,7 +17023,7 @@ var ts; error(declaration, ts.Diagnostics.Duplicate_string_index_signature); } break; - case 120: + case 121: if (!seenNumericIndexer) { seenNumericIndexer = true; } @@ -16579,17 +17060,17 @@ var ts; return; } function isSuperCallExpression(n) { - return n.kind === 158 && n.expression.kind === 91; + return n.kind === 160 && n.expression.kind === 91; } function containsSuperCall(n) { if (isSuperCallExpression(n)) { return true; } switch (n.kind) { - case 163: - case 201: - case 164: - case 155: return false; + case 165: + case 203: + case 166: + case 157: return false; default: return ts.forEachChild(n, containsSuperCall); } } @@ -16597,12 +17078,12 @@ var ts; if (n.kind === 93) { error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); } - else if (n.kind !== 163 && n.kind !== 201) { + else if (n.kind !== 165 && n.kind !== 203) { ts.forEachChild(n, markThisReferencesAsErrors); } } function isInstancePropertyWithInitializer(n) { - return n.kind === 133 && + return n.kind === 134 && !(n.flags & 128) && !!n.initializer; } @@ -16612,7 +17093,7 @@ var ts; ts.forEach(node.parameters, function (p) { return p.flags & (16 | 32 | 64); }); if (superCallShouldBeFirst) { var statements = node.body.statements; - if (!statements.length || statements[0].kind !== 183 || !isSuperCallExpression(statements[0].expression)) { + if (!statements.length || statements[0].kind !== 185 || !isSuperCallExpression(statements[0].expression)) { error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties); } else { @@ -16628,13 +17109,13 @@ var ts; function checkAccessorDeclaration(node) { if (produceDiagnostics) { checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); - if (node.kind === 137) { + if (node.kind === 138) { if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) { error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement); } } if (!ts.hasDynamicName(node)) { - var otherKind = node.kind === 137 ? 138 : 137; + var otherKind = node.kind === 138 ? 139 : 138; var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); if (otherAccessor) { if (((node.flags & 112) !== (otherAccessor.flags & 112))) { @@ -16656,26 +17137,26 @@ var ts; function checkMissingDeclaration(node) { checkDecorators(node); } + function checkTypeArgumentConstraints(typeParameters, typeArguments) { + var result = true; + for (var i = 0; i < typeParameters.length; i++) { + var constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + var typeArgument = typeArguments[i]; + result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + } + } + return result; + } function checkTypeReferenceNode(node) { - checkGrammarTypeReferenceInStrictMode(node.typeName); - return checkTypeReferenceOrExpressionWithTypeArguments(node); - } - function checkExpressionWithTypeArguments(node) { - checkGrammarExpressionWithTypeArgumentsInStrictMode(node.expression); - return checkTypeReferenceOrExpressionWithTypeArguments(node); - } - function checkTypeReferenceOrExpressionWithTypeArguments(node) { checkGrammarTypeArguments(node, node.typeArguments); - var type = getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); + var type = getTypeFromTypeReference(node); if (type !== unknownType && node.typeArguments) { - var len = node.typeArguments.length; - for (var i = 0; i < len; i++) { - checkSourceElement(node.typeArguments[i]); - var constraint = getConstraintOfTypeParameter(type.target.typeParameters[i]); - if (produceDiagnostics && constraint) { - var typeArgument = type.typeArguments[i]; - checkTypeAssignableTo(typeArgument, constraint, node, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); - } + ts.forEach(node.typeArguments, checkSourceElement); + if (produceDiagnostics) { + var symbol = getNodeLinks(node).resolvedSymbol; + var typeParameters = symbol.flags & 524288 ? getSymbolLinks(symbol).typeParameters : type.target.localTypeParameters; + checkTypeArgumentConstraints(typeParameters, node.typeArguments); } } } @@ -16719,9 +17200,9 @@ var ts; return; } var signaturesToCheck; - if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 203) { - ts.Debug.assert(signatureDeclarationNode.kind === 139 || signatureDeclarationNode.kind === 140); - var signatureKind = signatureDeclarationNode.kind === 139 ? 0 : 1; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 205) { + ts.Debug.assert(signatureDeclarationNode.kind === 140 || signatureDeclarationNode.kind === 141); + var signatureKind = signatureDeclarationNode.kind === 140 ? 0 : 1; var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); var containingType = getDeclaredTypeOfSymbol(containingSymbol); signaturesToCheck = getSignaturesOfType(containingType, signatureKind); @@ -16739,7 +17220,7 @@ var ts; } function getEffectiveDeclarationFlags(n, flagsToCheck) { var flags = ts.getCombinedNodeFlags(n); - if (n.parent.kind !== 203 && ts.isInAmbientContext(n)) { + if (n.parent.kind !== 205 && ts.isInAmbientContext(n)) { if (!(flags & 2)) { flags |= 1; } @@ -16812,7 +17293,7 @@ var ts; if (subsequentNode.kind === node.kind) { var errorNode_1 = subsequentNode.name || subsequentNode; if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { - ts.Debug.assert(node.kind === 135 || node.kind === 134); + ts.Debug.assert(node.kind === 136 || node.kind === 135); ts.Debug.assert((node.flags & 128) !== (subsequentNode.flags & 128)); var diagnostic = node.flags & 128 ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static; error(errorNode_1, diagnostic); @@ -16839,11 +17320,11 @@ var ts; var current = declarations[_i]; var node = current; var inAmbientContext = ts.isInAmbientContext(node); - var inAmbientContextOrInterface = node.parent.kind === 203 || node.parent.kind === 146 || inAmbientContext; + var inAmbientContextOrInterface = node.parent.kind === 205 || node.parent.kind === 148 || inAmbientContext; if (inAmbientContextOrInterface) { previousDeclaration = undefined; } - if (node.kind === 201 || node.kind === 135 || node.kind === 134 || node.kind === 136) { + if (node.kind === 203 || node.kind === 136 || node.kind === 135 || node.kind === 137) { var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); someNodeFlags |= currentNodeFlags; allNodeFlags &= currentNodeFlags; @@ -16940,16 +17421,16 @@ var ts; } function getDeclarationSpaces(d) { switch (d.kind) { - case 203: + case 205: return 2097152; - case 206: + case 208: return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; - case 202: - case 205: + case 204: + case 207: return 2097152 | 1048576; - case 209: + case 211: var result = 0; var target = resolveAlias(getSymbolOfNode(d)); ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); @@ -16963,54 +17444,54 @@ var ts; var expression = node.expression; var exprType = checkExpression(expression); switch (node.parent.kind) { - case 202: + case 204: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); checkTypeAssignableTo(exprType, classDecoratorType, node); break; - case 133: + case 134: checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); break; - case 135: - case 137: + case 136: case 138: + case 139: var methodType = getTypeOfNode(node.parent); var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); checkTypeAssignableTo(exprType, methodDecoratorType, node); break; - case 130: + case 131: checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); break; } } function checkTypeNodeAsExpression(node) { - if (node && node.kind === 142) { + if (node && node.kind === 144) { var type = getTypeFromTypeNode(node); var shouldCheckIfUnknownType = type === unknownType && compilerOptions.isolatedModules; if (!type || (!shouldCheckIfUnknownType && type.flags & (2097279 | 132 | 258))) { return; } if (shouldCheckIfUnknownType || type.symbol.valueDeclaration) { - checkExpressionOrQualifiedName(node.typeName); + checkExpression(node.typeName); } } } function checkTypeAnnotationAsExpression(node) { switch (node.kind) { - case 133: + case 134: checkTypeNodeAsExpression(node.type); break; - case 130: + case 131: checkTypeNodeAsExpression(node.type); break; - case 135: - checkTypeNodeAsExpression(node.type); - break; - case 137: + case 136: checkTypeNodeAsExpression(node.type); break; case 138: + checkTypeNodeAsExpression(node.type); + break; + case 139: checkTypeNodeAsExpression(getSetAccessorTypeAnnotationNode(node)); break; } @@ -17033,43 +17514,40 @@ var ts; } if (compilerOptions.emitDecoratorMetadata) { switch (node.kind) { - case 202: + case 204: var constructor = ts.getFirstConstructorWithBody(node); if (constructor) { checkParameterTypeAnnotationsAsExpressions(constructor); } break; - case 135: + case 136: checkParameterTypeAnnotationsAsExpressions(node); + case 139: case 138: - case 137: - case 133: - case 130: + case 134: + case 131: checkTypeAnnotationAsExpression(node); break; } } emitDecorate = true; - if (node.kind === 130) { + if (node.kind === 131) { emitParam = true; } ts.forEach(node.decorators, checkDecorator); } function checkFunctionDeclaration(node) { if (produceDiagnostics) { - checkFunctionLikeDeclaration(node) || - checkGrammarFunctionName(node.name) || - checkGrammarForGenerator(node); + checkFunctionLikeDeclaration(node) || checkGrammarForGenerator(node); checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); } } function checkFunctionLikeDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSignatureDeclaration(node); - if (node.name && node.name.kind === 128) { + if (node.name && node.name.kind === 129) { checkComputedPropertyName(node.name); } if (!ts.hasDynamicName(node)) { @@ -17099,11 +17577,11 @@ var ts; } } function checkBlock(node) { - if (node.kind === 180) { + if (node.kind === 182) { checkGrammarStatementInAmbientContext(node); } ts.forEach(node.statements, checkSourceElement); - if (ts.isFunctionBlock(node) || node.kind === 207) { + if (ts.isFunctionBlock(node) || node.kind === 209) { checkFunctionExpressionBodies(node); } } @@ -17121,19 +17599,19 @@ var ts; if (!(identifier && identifier.text === name)) { return false; } - if (node.kind === 133 || - node.kind === 132 || + if (node.kind === 134 || + node.kind === 133 || + node.kind === 136 || node.kind === 135 || - node.kind === 134 || - node.kind === 137 || - node.kind === 138) { + node.kind === 138 || + node.kind === 139) { return false; } if (ts.isInAmbientContext(node)) { return false; } var root = ts.getRootDeclaration(node); - if (root.kind === 130 && ts.nodeIsMissing(root.parent.body)) { + if (root.kind === 131 && ts.nodeIsMissing(root.parent.body)) { return false; } return true; @@ -17163,7 +17641,7 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; } - var enclosingClass = ts.getAncestor(node, 202); + var enclosingClass = ts.getAncestor(node, 204); if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; } @@ -17181,11 +17659,11 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { return; } - if (node.kind === 206 && ts.getModuleInstanceState(node) !== 1) { + if (node.kind === 208 && ts.getModuleInstanceState(node) !== 1) { return; } var parent = getDeclarationContainer(node); - if (parent.kind === 228 && ts.isExternalModule(parent)) { + if (parent.kind === 230 && ts.isExternalModule(parent)) { error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); } } @@ -17196,7 +17674,7 @@ var ts; if ((ts.getCombinedNodeFlags(node) & 12288) !== 0 || ts.isParameterDeclaration(node)) { return; } - if (node.kind === 199 && !node.initializer) { + if (node.kind === 201 && !node.initializer) { return; } var symbol = getSymbolOfNode(node); @@ -17206,15 +17684,15 @@ var ts; localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2) { if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 12288) { - var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 200); - var container = varDeclList.parent.kind === 181 && varDeclList.parent.parent + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 202); + var container = varDeclList.parent.kind === 183 && varDeclList.parent.parent ? varDeclList.parent.parent : undefined; var namesShareScope = container && - (container.kind === 180 && ts.isFunctionLike(container.parent) || - container.kind === 207 || - container.kind === 206 || - container.kind === 228); + (container.kind === 182 && ts.isFunctionLike(container.parent) || + container.kind === 209 || + container.kind === 208 || + container.kind === 230); if (!namesShareScope) { var name_13 = symbolToString(localDeclarationSymbol); error(node, ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name_13, name_13); @@ -17224,7 +17702,7 @@ var ts; } } function checkParameterInitializer(node) { - if (ts.getRootDeclaration(node).kind !== 130) { + if (ts.getRootDeclaration(node).kind !== 131) { return; } var func = ts.getContainingFunction(node); @@ -17233,7 +17711,7 @@ var ts; if (n.kind === 65) { var referencedSymbol = getNodeLinks(n).resolvedSymbol; if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455) === referencedSymbol) { - if (referencedSymbol.valueDeclaration.kind === 130) { + if (referencedSymbol.valueDeclaration.kind === 131) { if (referencedSymbol.valueDeclaration === node) { error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); return; @@ -17251,10 +17729,9 @@ var ts; } } function checkVariableLikeDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSourceElement(node.type); - if (node.name.kind === 128) { + if (node.name.kind === 129) { checkComputedPropertyName(node.name); if (node.initializer) { checkExpressionCached(node.initializer); @@ -17263,7 +17740,7 @@ var ts; if (ts.isBindingPattern(node.name)) { ts.forEach(node.name.elements, checkSourceElement); } - if (node.initializer && ts.getRootDeclaration(node).kind === 130 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + if (node.initializer && ts.getRootDeclaration(node).kind === 131 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); return; } @@ -17291,9 +17768,9 @@ var ts; checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); } } - if (node.kind !== 133 && node.kind !== 132) { + if (node.kind !== 134 && node.kind !== 133) { checkExportsOnMergedDeclarations(node); - if (node.kind === 199 || node.kind === 153) { + if (node.kind === 201 || node.kind === 155) { checkVarDeclaredNamesNotShadowed(node); } checkCollisionWithCapturedSuperVariable(node, node.name); @@ -17322,7 +17799,7 @@ var ts; } function inBlockOrObjectLiteralExpression(node) { while (node) { - if (node.kind === 180 || node.kind === 155) { + if (node.kind === 182 || node.kind === 157) { return true; } node = node.parent; @@ -17350,12 +17827,12 @@ var ts; } function checkForStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { - if (node.initializer && node.initializer.kind == 200) { + if (node.initializer && node.initializer.kind === 202) { checkGrammarVariableDeclarationList(node.initializer); } } if (node.initializer) { - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { ts.forEach(node.initializer.declarations, checkVariableDeclaration); } else { @@ -17370,13 +17847,13 @@ var ts; } function checkForOfStatement(node) { checkGrammarForInOrForOfStatement(node); - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { checkForInOrForOfVariableDeclaration(node); } else { var varExpr = node.initializer; var iteratedType = checkRightHandSideOfForOf(node.expression); - if (varExpr.kind === 154 || varExpr.kind === 155) { + if (varExpr.kind === 156 || varExpr.kind === 157) { checkDestructuringAssignment(varExpr, iteratedType || unknownType); } else { @@ -17391,7 +17868,7 @@ var ts; } function checkForInStatement(node) { checkGrammarForInOrForOfStatement(node); - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { var variable = node.initializer.declarations[0]; if (variable && ts.isBindingPattern(variable.name)) { error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); @@ -17401,7 +17878,7 @@ var ts; else { var varExpr = node.initializer; var leftType = checkExpression(varExpr); - if (varExpr.kind === 154 || varExpr.kind === 155) { + if (varExpr.kind === 156 || varExpr.kind === 157) { error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); } else if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, 258)) { @@ -17563,7 +18040,7 @@ var ts; checkGrammarStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node); } function isGetAccessorWithAnnotatatedSetAccessor(node) { - return !!(node.kind === 137 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 138))); + return !!(node.kind === 138 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 139))); } function checkReturnStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { @@ -17575,31 +18052,28 @@ var ts; if (node.expression) { var func = ts.getContainingFunction(node); if (func) { - var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); + var signature = getSignatureFromDeclaration(func); + var returnType = getReturnTypeOfSignature(signature); var exprType = checkExpressionCached(node.expression); if (func.asteriskToken) { return; } - if (func.kind === 138) { + if (func.kind === 139) { error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); } - else if (func.kind === 136) { + else if (func.kind === 137) { if (!isTypeAssignableTo(exprType, returnType)) { error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } } - else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) { + else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) { checkTypeAssignableTo(exprType, returnType, node.expression, undefined); } } } } function checkWithStatement(node) { - if (!checkGrammarStatementInAmbientContext(node)) { - if (node.parserContextFlags & 1) { - grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); - } - } + checkGrammarStatementInAmbientContext(node); checkExpression(node.expression); error(node.expression, ts.Diagnostics.All_symbols_within_a_with_block_will_be_resolved_to_any); } @@ -17609,7 +18083,7 @@ var ts; var hasDuplicateDefaultClause = false; var expressionType = checkExpression(node.expression); ts.forEach(node.caseBlock.clauses, function (clause) { - if (clause.kind === 222 && !hasDuplicateDefaultClause) { + if (clause.kind === 224 && !hasDuplicateDefaultClause) { if (firstDefaultClause === undefined) { firstDefaultClause = clause; } @@ -17621,7 +18095,7 @@ var ts; hasDuplicateDefaultClause = true; } } - if (produceDiagnostics && clause.kind === 221) { + if (produceDiagnostics && clause.kind === 223) { var caseClause = clause; var caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { @@ -17638,7 +18112,7 @@ var ts; if (ts.isFunctionLike(current)) { break; } - if (current.kind === 195 && current.label.text === node.label.text) { + if (current.kind === 197 && current.label.text === node.label.text) { var sourceFile = ts.getSourceFileOfNode(node); grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNodeFromSourceText(sourceFile.text, node.label)); break; @@ -17682,7 +18156,6 @@ var ts; grammarErrorOnNode(localSymbol.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, identifierName); } } - checkGrammarEvalOrArgumentsInStrictMode(node, catchClause.variableDeclaration.name); } } checkBlock(catchClause.block); @@ -17702,7 +18175,7 @@ var ts; checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0); checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1); }); - if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 202) { + if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 204) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; @@ -17733,7 +18206,7 @@ var ts; return; } var errorNode; - if (prop.valueDeclaration.name.kind === 128 || prop.parent === containingType.symbol) { + if (prop.valueDeclaration.name.kind === 129 || prop.parent === containingType.symbol) { errorNode = prop.valueDeclaration; } else if (indexDeclaration) { @@ -17783,7 +18256,6 @@ var ts; return unknownType; } function checkClassDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); if (!node.name && !(node.flags & 256)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } @@ -17801,35 +18273,38 @@ var ts; var staticType = getTypeOfSymbol(symbol); var baseTypeNode = ts.getClassExtendsHeritageClauseElement(node); if (baseTypeNode) { - if (!ts.isSupportedExpressionWithTypeArguments(baseTypeNode)) { - error(baseTypeNode.expression, ts.Diagnostics.Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses); - } emitExtends = emitExtends || !ts.isInAmbientContext(node); - checkExpressionWithTypeArguments(baseTypeNode); - } - var baseTypes = getBaseTypes(type); - if (baseTypes.length) { - if (produceDiagnostics) { + var baseTypes = getBaseTypes(type); + if (baseTypes.length && produceDiagnostics) { var baseType = baseTypes[0]; + var staticBaseType = getBaseConstructorTypeOfClass(type); + if (baseTypeNode.typeArguments) { + ts.forEach(baseTypeNode.typeArguments, checkSourceElement); + for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); _i < _a.length; _i++) { + var constructor = _a[_i]; + if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) { + break; + } + } + } checkTypeAssignableTo(type, baseType, node.name || node, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1); - var staticBaseType = getTypeOfSymbol(baseType.symbol); - checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); - if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, 107455)) { - error(baseTypeNode, ts.Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType)); + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); + if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32)) { + var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); + if (ts.forEach(constructors, function (sig) { return getReturnTypeOfSignature(sig) !== baseType; })) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type); + } } checkKindsOfPropertyMemberOverrides(type, baseType); } } - if (baseTypes.length || (baseTypeNode && compilerOptions.isolatedModules)) { - checkExpressionOrQualifiedName(baseTypeNode.expression); - } var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node); if (implementedTypeNodes) { ts.forEach(implementedTypeNodes, function (typeRefNode) { if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) { error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments); } - checkExpressionWithTypeArguments(typeRefNode); + checkTypeReferenceNode(typeRefNode); if (produceDiagnostics) { var t = getTypeFromTypeNode(typeRefNode); if (t !== unknownType) { @@ -17911,7 +18386,7 @@ var ts; } } function isAccessor(kind) { - return kind === 137 || kind === 138; + return kind === 138 || kind === 139; } function areTypeParametersIdentical(list1, list2) { if (!list1 && !list2) { @@ -17971,13 +18446,13 @@ var ts; return ok; } function checkInterfaceDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); checkTypeParameters(node.typeParameters); if (produceDiagnostics) { checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 203); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 205); if (symbol.declarations.length > 1) { if (node !== firstInterfaceDecl && !areTypeParametersIdentical(firstInterfaceDecl.typeParameters, node.typeParameters)) { error(node.name, ts.Diagnostics.All_declarations_of_an_interface_must_have_identical_type_parameters); @@ -17997,7 +18472,7 @@ var ts; if (!ts.isSupportedExpressionWithTypeArguments(heritageElement)) { error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments); } - checkExpressionWithTypeArguments(heritageElement); + checkTypeReferenceNode(heritageElement); }); ts.forEach(node.members, checkSourceElement); if (produceDiagnostics) { @@ -18018,7 +18493,7 @@ var ts; var ambient = ts.isInAmbientContext(node); var enumIsConst = ts.isConst(node); ts.forEach(node.members, function (member) { - if (member.name.kind !== 128 && isNumericLiteralName(member.name.text)) { + if (member.name.kind !== 129 && isNumericLiteralName(member.name.text)) { error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); } var initializer = member.initializer; @@ -18054,7 +18529,7 @@ var ts; return evalConstant(initializer); function evalConstant(e) { switch (e.kind) { - case 168: + case 170: var value = evalConstant(e.operand); if (value === undefined) { return undefined; @@ -18065,7 +18540,7 @@ var ts; case 47: return ~value; } return undefined; - case 170: + case 172: var left = evalConstant(e.left); if (left === undefined) { return undefined; @@ -18090,11 +18565,11 @@ var ts; return undefined; case 7: return +e.text; - case 162: + case 164: return evalConstant(e.expression); case 65: - case 157: - case 156: + case 159: + case 158: var member = initializer.parent; var currentType = getTypeOfSymbol(getSymbolOfNode(member.parent)); var enumType; @@ -18105,7 +18580,7 @@ var ts; } else { var expression; - if (e.kind === 157) { + if (e.kind === 159) { if (e.argumentExpression === undefined || e.argumentExpression.kind !== 8) { return undefined; @@ -18122,7 +18597,7 @@ var ts; if (current.kind === 65) { break; } - else if (current.kind === 156) { + else if (current.kind === 158) { current = current.expression; } else { @@ -18157,7 +18632,7 @@ var ts; if (!produceDiagnostics) { return; } - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); @@ -18179,7 +18654,7 @@ var ts; } var seenEnumMissingInitialInitializer = false; ts.forEach(enumSymbol.declarations, function (declaration) { - if (declaration.kind !== 205) { + if (declaration.kind !== 207) { return false; } var enumDeclaration = declaration; @@ -18202,8 +18677,8 @@ var ts; var declarations = symbol.declarations; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; - if ((declaration.kind === 202 || - (declaration.kind === 201 && ts.nodeIsPresent(declaration.body))) && + if ((declaration.kind === 204 || + (declaration.kind === 203 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { return declaration; } @@ -18225,7 +18700,14 @@ var ts; } function checkModuleDeclaration(node) { if (produceDiagnostics) { - if (!checkGrammarDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { + var isAmbientExternalModule = node.name.kind === 8; + var contextErrorMessage = isAmbientExternalModule + ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file + : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module; + if (checkGrammarModuleElementContext(node, contextErrorMessage)) { + return; + } + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { if (!ts.isInAmbientContext(node) && node.name.kind === 8) { grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); } @@ -18247,13 +18729,13 @@ var ts; error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged); } } - var mergedClass = ts.getDeclarationOfKind(symbol, 202); + var mergedClass = ts.getDeclarationOfKind(symbol, 204); if (mergedClass && inSameLexicalScope(node, mergedClass)) { getNodeLinks(node).flags |= 2048; } } - if (node.name.kind === 8) { + if (isAmbientExternalModule) { if (!isGlobalSourceFile(node.parent)) { error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules); } @@ -18266,10 +18748,10 @@ var ts; } function getFirstIdentifier(node) { while (true) { - if (node.kind === 127) { + if (node.kind === 128) { node = node.left; } - else if (node.kind === 156) { + else if (node.kind === 158) { node = node.expression; } else { @@ -18285,9 +18767,9 @@ var ts; error(moduleName, ts.Diagnostics.String_literal_expected); return false; } - var inAmbientExternalModule = node.parent.kind === 207 && node.parent.parent.name.kind === 8; - if (node.parent.kind !== 228 && !inAmbientExternalModule) { - error(moduleName, node.kind === 216 ? + var inAmbientExternalModule = node.parent.kind === 209 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 230 && !inAmbientExternalModule) { + error(moduleName, node.kind === 218 ? ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module); return false; @@ -18306,7 +18788,7 @@ var ts; (symbol.flags & 793056 ? 793056 : 0) | (symbol.flags & 1536 ? 1536 : 0); if (target.flags & excludedMeanings) { - var message = node.kind === 218 ? + var message = node.kind === 220 ? ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0; error(node, message, symbolToString(symbol)); @@ -18319,7 +18801,10 @@ var ts; checkAliasSymbol(node); } function checkImportDeclaration(node) { - if (!checkGrammarImportDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + return; + } + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); } if (checkExternalImportOrExportDeclaration(node)) { @@ -18329,7 +18814,7 @@ var ts; checkImportBinding(importClause); } if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212) { + if (importClause.namedBindings.kind === 214) { checkImportBinding(importClause.namedBindings); } else { @@ -18340,7 +18825,10 @@ var ts; } } function checkImportEqualsDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node); + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + return; + } + checkGrammarDecorators(node) || checkGrammarModifiers(node); if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) { checkImportBinding(node); if (node.flags & 1) { @@ -18368,14 +18856,17 @@ var ts; } } function checkExportDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) { + return; + } if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); } if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { if (node.exportClause) { ts.forEach(node.exportClause.elements, checkExportSpecifier); - var inAmbientExternalModule = node.parent.kind === 207 && node.parent.parent.name.kind === 8; - if (node.parent.kind !== 228 && !inAmbientExternalModule) { + var inAmbientExternalModule = node.parent.kind === 209 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 230 && !inAmbientExternalModule) { error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace); } } @@ -18387,6 +18878,11 @@ var ts; } } } + function checkGrammarModuleElementContext(node, errorMessage) { + if (node.parent.kind !== 230 && node.parent.kind !== 209 && node.parent.kind !== 208) { + return grammarErrorOnFirstToken(node, errorMessage); + } + } function checkExportSpecifier(node) { checkAliasSymbol(node); if (!node.parent.parent.moduleSpecifier) { @@ -18394,8 +18890,11 @@ var ts; } } function checkExportAssignment(node) { - var container = node.parent.kind === 228 ? node.parent : node.parent.parent; - if (container.kind === 206 && container.name.kind === 65) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) { + return; + } + var container = node.parent.kind === 230 ? node.parent : node.parent.parent; + if (container.kind === 208 && container.name.kind === 65) { error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace); return; } @@ -18419,10 +18918,10 @@ var ts; } } function getModuleStatements(node) { - if (node.kind === 228) { + if (node.kind === 230) { return node.statements; } - if (node.kind === 206 && node.body.kind === 207) { + if (node.kind === 208 && node.body.kind === 209) { return node.body.statements; } return emptyArray; @@ -18447,170 +18946,175 @@ var ts; links.exportsChecked = true; } } + function checkTypePredicate(node) { + if (!isInLegalTypePredicatePosition(node)) { + error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + } + } function checkSourceElement(node) { if (!node) return; switch (node.kind) { - case 129: - return checkTypeParameter(node); case 130: + return checkTypeParameter(node); + case 131: return checkParameter(node); + case 134: case 133: - case 132: return checkPropertyDeclaration(node); - case 143: - case 144: - case 139: + case 145: + case 146: case 140: - return checkSignatureDeclaration(node); case 141: return checkSignatureDeclaration(node); - case 135: - case 134: - return checkMethodDeclaration(node); - case 136: - return checkConstructorDeclaration(node); - case 137: - case 138: - return checkAccessorDeclaration(node); case 142: + return checkSignatureDeclaration(node); + case 136: + case 135: + return checkMethodDeclaration(node); + case 137: + return checkConstructorDeclaration(node); + case 138: + case 139: + return checkAccessorDeclaration(node); + case 144: return checkTypeReferenceNode(node); - case 145: - return checkTypeQuery(node); - case 146: - return checkTypeLiteral(node); + case 143: + return checkTypePredicate(node); case 147: - return checkArrayType(node); + return checkTypeQuery(node); case 148: - return checkTupleType(node); + return checkTypeLiteral(node); case 149: - return checkUnionType(node); + return checkArrayType(node); case 150: + return checkTupleType(node); + case 151: + return checkUnionType(node); + case 152: return checkSourceElement(node.type); - case 201: - return checkFunctionDeclaration(node); - case 180: - case 207: - return checkBlock(node); - case 181: - return checkVariableStatement(node); - case 183: - return checkExpressionStatement(node); - case 184: - return checkIfStatement(node); - case 185: - return checkDoStatement(node); - case 186: - return checkWhileStatement(node); - case 187: - return checkForStatement(node); - case 188: - return checkForInStatement(node); - case 189: - return checkForOfStatement(node); - case 190: - case 191: - return checkBreakOrContinueStatement(node); - case 192: - return checkReturnStatement(node); - case 193: - return checkWithStatement(node); - case 194: - return checkSwitchStatement(node); - case 195: - return checkLabeledStatement(node); - case 196: - return checkThrowStatement(node); - case 197: - return checkTryStatement(node); - case 199: - return checkVariableDeclaration(node); - case 153: - return checkBindingElement(node); - case 202: - return checkClassDeclaration(node); case 203: - return checkInterfaceDeclaration(node); - case 204: - return checkTypeAliasDeclaration(node); - case 205: - return checkEnumDeclaration(node); - case 206: - return checkModuleDeclaration(node); - case 210: - return checkImportDeclaration(node); - case 209: - return checkImportEqualsDeclaration(node); - case 216: - return checkExportDeclaration(node); - case 215: - return checkExportAssignment(node); + return checkFunctionDeclaration(node); case 182: - checkGrammarStatementInAmbientContext(node); - return; + case 209: + return checkBlock(node); + case 183: + return checkVariableStatement(node); + case 185: + return checkExpressionStatement(node); + case 186: + return checkIfStatement(node); + case 187: + return checkDoStatement(node); + case 188: + return checkWhileStatement(node); + case 189: + return checkForStatement(node); + case 190: + return checkForInStatement(node); + case 191: + return checkForOfStatement(node); + case 192: + case 193: + return checkBreakOrContinueStatement(node); + case 194: + return checkReturnStatement(node); + case 195: + return checkWithStatement(node); + case 196: + return checkSwitchStatement(node); + case 197: + return checkLabeledStatement(node); case 198: + return checkThrowStatement(node); + case 199: + return checkTryStatement(node); + case 201: + return checkVariableDeclaration(node); + case 155: + return checkBindingElement(node); + case 204: + return checkClassDeclaration(node); + case 205: + return checkInterfaceDeclaration(node); + case 206: + return checkTypeAliasDeclaration(node); + case 207: + return checkEnumDeclaration(node); + case 208: + return checkModuleDeclaration(node); + case 212: + return checkImportDeclaration(node); + case 211: + return checkImportEqualsDeclaration(node); + case 218: + return checkExportDeclaration(node); + case 217: + return checkExportAssignment(node); + case 184: checkGrammarStatementInAmbientContext(node); return; - case 219: + case 200: + checkGrammarStatementInAmbientContext(node); + return; + case 221: return checkMissingDeclaration(node); } } function checkFunctionExpressionBodies(node) { switch (node.kind) { - case 163: - case 164: + case 165: + case 166: ts.forEach(node.parameters, checkFunctionExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; + case 136: case 135: - case 134: ts.forEach(node.decorators, checkFunctionExpressionBodies); ts.forEach(node.parameters, checkFunctionExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } break; - case 136: case 137: case 138: - case 201: + case 139: + case 203: ts.forEach(node.parameters, checkFunctionExpressionBodies); break; - case 193: + case 195: checkFunctionExpressionBodies(node.expression); break; - case 131: - case 130: - case 133: case 132: - case 151: - case 152: + case 131: + case 134: + case 133: case 153: case 154: case 155: - case 225: case 156: case 157: + case 227: case 158: case 159: case 160: - case 172: - case 178: case 161: case 162: - case 166: - case 167: - case 165: - case 168: - case 169: - case 170: - case 171: case 174: case 180: - case 207: - case 181: + case 163: + case 164: + case 168: + case 169: + case 167: + case 170: + case 171: + case 172: + case 173: + case 176: + case 182: + case 209: case 183: - case 184: case 185: case 186: case 187: @@ -18619,21 +19123,23 @@ var ts; case 190: case 191: case 192: + case 193: case 194: - case 208: - case 221: - case 222: - case 195: case 196: - case 197: + case 210: + case 223: case 224: + case 197: + case 198: case 199: - case 200: + case 226: + case 201: case 202: - case 205: - case 227: - case 215: - case 228: + case 204: + case 207: + case 229: + case 217: + case 230: ts.forEachChild(node, checkFunctionExpressionBodies); break; } @@ -18646,6 +19152,9 @@ var ts; function checkSourceFileWorker(node) { var links = getNodeLinks(node); if (!(links.flags & 1)) { + if (node.isDefaultLib && compilerOptions.skipDefaultLibCheck) { + return; + } checkGrammarSourceFile(node); emitExtends = false; emitDecorate = false; @@ -18693,7 +19202,7 @@ var ts; function isInsideWithStatementBody(node) { if (node) { while (node.parent) { - if (node.parent.kind === 193 && node.parent.statement === node) { + if (node.parent.kind === 195 && node.parent.statement === node) { return true; } node = node.parent; @@ -18715,23 +19224,23 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228: + case 230: if (!ts.isExternalModule(location)) { break; } - case 206: + case 208: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 205: + case 207: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 202: - case 203: + case 204: + case 205: if (!(memberFlags & 128)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 163: + case 165: if (location.name) { copySymbol(location.symbol, meaning); } @@ -18767,22 +19276,22 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228: + case 230: if (!ts.isExternalModule(location)) break; - case 206: + case 208: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 205: + case 207: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 202: - case 203: + case 204: + case 205: if (!(memberFlags & 128)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 163: + case 165: if (location.name) { copySymbol(location.symbol, meaning); } @@ -18795,42 +19304,42 @@ var ts; return symbolsToArray(symbols); } function isTypeDeclarationName(name) { - return name.kind == 65 && + return name.kind === 65 && isTypeDeclaration(name.parent) && name.parent.name === name; } function isTypeDeclaration(node) { switch (node.kind) { - case 129: - case 202: - case 203: + case 130: case 204: case 205: + case 206: + case 207: return true; } } function isTypeReferenceIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 127) { + while (node.parent && node.parent.kind === 128) { node = node.parent; } - return node.parent && node.parent.kind === 142; + return node.parent && node.parent.kind === 144; } function isHeritageClauseElementIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 156) { + while (node.parent && node.parent.kind === 158) { node = node.parent; } - return node.parent && node.parent.kind === 177; + return node.parent && node.parent.kind === 179; } function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { - while (nodeOnRightSide.parent.kind === 127) { + while (nodeOnRightSide.parent.kind === 128) { nodeOnRightSide = nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 209) { + if (nodeOnRightSide.parent.kind === 211) { return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 215) { + if (nodeOnRightSide.parent.kind === 217) { return nodeOnRightSide.parent.expression === nodeOnRightSide && nodeOnRightSide.parent; } return undefined; @@ -18842,10 +19351,10 @@ var ts; if (ts.isDeclarationName(entityName)) { return getSymbolOfNode(entityName.parent); } - if (entityName.parent.kind === 215) { + if (entityName.parent.kind === 217) { return resolveEntityName(entityName, 107455 | 793056 | 1536 | 8388608); } - if (entityName.kind !== 156) { + if (entityName.kind !== 158) { if (isInRightSideOfImportOrExportAssignment(entityName)) { return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); } @@ -18854,7 +19363,7 @@ var ts; entityName = entityName.parent; } if (isHeritageClauseElementIdentifier(entityName)) { - var meaning = entityName.parent.kind === 177 ? 793056 : 1536; + var meaning = entityName.parent.kind === 179 ? 793056 : 1536; meaning |= 8388608; return resolveEntityName(entityName, meaning); } @@ -18866,14 +19375,14 @@ var ts; var meaning = 107455 | 8388608; return resolveEntityName(entityName, meaning); } - else if (entityName.kind === 156) { + else if (entityName.kind === 158) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkPropertyAccessExpression(entityName); } return getNodeLinks(entityName).resolvedSymbol; } - else if (entityName.kind === 127) { + else if (entityName.kind === 128) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkQualifiedName(entityName); @@ -18882,7 +19391,7 @@ var ts; } } else if (isTypeReferenceIdentifier(entityName)) { - var meaning = entityName.parent.kind === 142 ? 793056 : 1536; + var meaning = entityName.parent.kind === 144 ? 793056 : 1536; meaning |= 8388608; return resolveEntityName(entityName, meaning); } @@ -18896,14 +19405,14 @@ var ts; return getSymbolOfNode(node.parent); } if (node.kind === 65 && isInRightSideOfImportOrExportAssignment(node)) { - return node.parent.kind === 215 + return node.parent.kind === 217 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); } switch (node.kind) { case 65: - case 156: - case 127: + case 158: + case 128: return getSymbolOfEntityNameOrPropertyAccessExpression(node); case 93: case 91: @@ -18911,7 +19420,7 @@ var ts; return type.symbol; case 114: var constructorDeclaration = node.parent; - if (constructorDeclaration && constructorDeclaration.kind === 136) { + if (constructorDeclaration && constructorDeclaration.kind === 137) { return constructorDeclaration.parent.symbol; } return undefined; @@ -18919,12 +19428,12 @@ var ts; var moduleName; if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) || - ((node.parent.kind === 210 || node.parent.kind === 216) && + ((node.parent.kind === 212 || node.parent.kind === 218) && node.parent.moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } case 7: - if (node.parent.kind == 157 && node.parent.argumentExpression === node) { + if (node.parent.kind === 159 && node.parent.argumentExpression === node) { var objectType = checkExpression(node.parent.expression); if (objectType === unknownType) return undefined; @@ -18938,7 +19447,7 @@ var ts; return undefined; } function getShorthandAssignmentValueSymbol(location) { - if (location && location.kind === 226) { + if (location && location.kind === 228) { return resolveEntityName(location.name, 107455); } return undefined; @@ -18953,6 +19462,9 @@ var ts; if (ts.isExpression(node)) { return getTypeOfExpression(node); } + if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(node)) { + return getBaseTypes(getDeclaredTypeOfSymbol(getSymbolOfNode(node.parent.parent)))[0]; + } if (isTypeDeclaration(node)) { var symbol = getSymbolOfNode(node); return getDeclaredTypeOfSymbol(symbol); @@ -19011,81 +19523,81 @@ var ts; } return [symbol]; } - function isExternalModuleSymbol(symbol) { - return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 228; - } - function getAliasNameSubstitution(symbol, getGeneratedNameForNode) { - if (languageVersion >= 2) { - return undefined; - } - var node = getDeclarationOfAliasSymbol(symbol); - if (node) { - if (node.kind === 211) { - var defaultKeyword; - if (languageVersion === 0) { - defaultKeyword = "[\"default\"]"; - } - else { - defaultKeyword = ".default"; - } - return getGeneratedNameForNode(node.parent) + defaultKeyword; - } - if (node.kind === 214) { - var moduleName = getGeneratedNameForNode(node.parent.parent.parent); - var propertyName = node.propertyName || node.name; - return moduleName + "." + ts.unescapeIdentifier(propertyName.text); - } - } - } - function getExportNameSubstitution(symbol, location, getGeneratedNameForNode) { - if (isExternalModuleSymbol(symbol.parent)) { - if (languageVersion >= 2 || compilerOptions.module === 4) { - return undefined; - } - return "exports." + ts.unescapeIdentifier(symbol.name); - } - var node = location; - var containerSymbol = getParentOfSymbol(symbol); - while (node) { - if ((node.kind === 206 || node.kind === 205) && getSymbolOfNode(node) === containerSymbol) { - return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); - } - node = node.parent; - } - } - function getExpressionNameSubstitution(node, getGeneratedNameForNode) { - var symbol = getNodeLinks(node).resolvedSymbol || (ts.isDeclarationName(node) ? getSymbolOfNode(node.parent) : undefined); + function getReferencedExportContainer(node) { + var symbol = getReferencedValueSymbol(node); if (symbol) { - if (symbol.parent) { - return getExportNameSubstitution(symbol, node.parent, getGeneratedNameForNode); + if (symbol.flags & 1048576) { + var exportSymbol = getMergedSymbol(symbol.exportSymbol); + if (exportSymbol.flags & 944) { + return undefined; + } + symbol = exportSymbol; } - var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); - if (symbol !== exportSymbol && !(exportSymbol.flags & 944)) { - return getExportNameSubstitution(exportSymbol, node.parent, getGeneratedNameForNode); - } - if (symbol.flags & 8388608) { - return getAliasNameSubstitution(symbol, getGeneratedNameForNode); + var parentSymbol = getParentOfSymbol(symbol); + if (parentSymbol) { + if (parentSymbol.flags & 512 && parentSymbol.valueDeclaration.kind === 230) { + return parentSymbol.valueDeclaration; + } + for (var n = node.parent; n; n = n.parent) { + if ((n.kind === 208 || n.kind === 207) && getSymbolOfNode(n) === parentSymbol) { + return n; + } + } } } } + function getReferencedImportDeclaration(node) { + var symbol = getReferencedValueSymbol(node); + return symbol && symbol.flags & 8388608 ? getDeclarationOfAliasSymbol(symbol) : undefined; + } + function isStatementWithLocals(node) { + switch (node.kind) { + case 182: + case 210: + case 189: + case 190: + case 191: + return true; + } + return false; + } + function isNestedRedeclarationSymbol(symbol) { + if (symbol.flags & 418) { + var links = getSymbolLinks(symbol); + if (links.isNestedRedeclaration === undefined) { + var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration); + links.isNestedRedeclaration = isStatementWithLocals(container) && + !!resolveName(container.parent, symbol.name, 107455, undefined, undefined); + } + return links.isNestedRedeclaration; + } + return false; + } + function getReferencedNestedRedeclaration(node) { + var symbol = getReferencedValueSymbol(node); + return symbol && isNestedRedeclarationSymbol(symbol) ? symbol.valueDeclaration : undefined; + } + function isNestedRedeclaration(node) { + return isNestedRedeclarationSymbol(getSymbolOfNode(node)); + } function isValueAliasDeclaration(node) { switch (node.kind) { - case 209: case 211: - case 212: + case 213: case 214: - case 218: - return isAliasResolvedToValue(getSymbolOfNode(node)); case 216: + case 220: + return isAliasResolvedToValue(getSymbolOfNode(node)); + case 218: var exportClause = node.exportClause; return exportClause && ts.forEach(exportClause.elements, isValueAliasDeclaration); - case 215: + case 217: return node.expression && node.expression.kind === 65 ? isAliasResolvedToValue(getSymbolOfNode(node)) : true; } return false; } function isTopLevelValueImportEqualsWithEntityName(node) { - if (node.parent.kind !== 228 || !ts.isInternalModuleImportEqualsDeclaration(node)) { + if (node.parent.kind !== 230 || !ts.isInternalModuleImportEqualsDeclaration(node)) { return false; } var isValue = isAliasResolvedToValue(getSymbolOfNode(node)); @@ -19130,7 +19642,7 @@ var ts; return getNodeLinks(node).enumMemberValue; } function getConstantValue(node) { - if (node.kind === 227) { + if (node.kind === 229) { return getEnumMemberValue(node); } var symbol = getNodeLinks(node).resolvedSymbol; @@ -19141,10 +19653,9 @@ var ts; } return undefined; } - function serializeEntityName(node, getGeneratedNameForNode, fallbackPath) { + function serializeEntityName(node, fallbackPath) { if (node.kind === 65) { - var substitution = getExpressionNameSubstitution(node, getGeneratedNameForNode); - var text = substitution || node.text; + var text = node.text; if (fallbackPath) { fallbackPath.push(text); } @@ -19153,14 +19664,14 @@ var ts; } } else { - var left = serializeEntityName(node.left, getGeneratedNameForNode, fallbackPath); - var right = serializeEntityName(node.right, getGeneratedNameForNode, fallbackPath); + var left = serializeEntityName(node.left, fallbackPath); + var right = serializeEntityName(node.right, fallbackPath); if (!fallbackPath) { return left + "." + right; } } } - function serializeTypeReferenceNode(node, getGeneratedNameForNode) { + function serializeTypeReferenceNode(node) { var type = getTypeFromTypeNode(node); if (type.flags & 16) { return "void 0"; @@ -19182,42 +19693,42 @@ var ts; } else if (type === unknownType) { var fallbackPath = []; - serializeEntityName(node.typeName, getGeneratedNameForNode, fallbackPath); + serializeEntityName(node.typeName, fallbackPath); return fallbackPath; } else if (type.symbol && type.symbol.valueDeclaration) { - return serializeEntityName(node.typeName, getGeneratedNameForNode); + return serializeEntityName(node.typeName); } else if (typeHasCallOrConstructSignatures(type)) { return "Function"; } return "Object"; } - function serializeTypeNode(node, getGeneratedNameForNode) { + function serializeTypeNode(node) { if (node) { switch (node.kind) { case 99: return "void 0"; - case 150: - return serializeTypeNode(node.type, getGeneratedNameForNode); - case 143: - case 144: + case 152: + return serializeTypeNode(node.type); + case 145: + case 146: return "Function"; - case 147: - case 148: + case 149: + case 150: return "Array"; case 113: return "Boolean"; - case 122: + case 123: case 8: return "String"; - case 120: + case 121: return "Number"; - case 142: - return serializeTypeReferenceNode(node, getGeneratedNameForNode); - case 145: - case 146: - case 149: + case 144: + return serializeTypeReferenceNode(node); + case 147: + case 148: + case 151: case 112: break; default: @@ -19227,23 +19738,23 @@ var ts; } return "Object"; } - function serializeTypeOfNode(node, getGeneratedNameForNode) { + function serializeTypeOfNode(node) { switch (node.kind) { - case 202: return "Function"; - case 133: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 130: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 137: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 138: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node), getGeneratedNameForNode); + case 204: return "Function"; + case 134: return serializeTypeNode(node.type); + case 131: return serializeTypeNode(node.type); + case 138: return serializeTypeNode(node.type); + case 139: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node)); } if (ts.isFunctionLike(node)) { return "Function"; } return "void 0"; } - function serializeParameterTypesOfNode(node, getGeneratedNameForNode) { + function serializeParameterTypesOfNode(node) { if (node) { var valueDeclaration; - if (node.kind === 202) { + if (node.kind === 204) { valueDeclaration = ts.getFirstConstructorWithBody(node); } else if (ts.isFunctionLike(node) && ts.nodeIsPresent(node.body)) { @@ -19258,19 +19769,19 @@ var ts; for (var i = 0; i < parameterCount; i++) { if (parameters[i].dotDotDotToken) { var parameterType = parameters[i].type; - if (parameterType.kind === 147) { + if (parameterType.kind === 149) { parameterType = parameterType.elementType; } - else if (parameterType.kind === 142 && parameterType.typeArguments && parameterType.typeArguments.length === 1) { + else if (parameterType.kind === 144 && parameterType.typeArguments && parameterType.typeArguments.length === 1) { parameterType = parameterType.typeArguments[0]; } else { parameterType = undefined; } - result[i] = serializeTypeNode(parameterType, getGeneratedNameForNode); + result[i] = serializeTypeNode(parameterType); } else { - result[i] = serializeTypeOfNode(parameters[i], getGeneratedNameForNode); + result[i] = serializeTypeOfNode(parameters[i]); } } return result; @@ -19279,9 +19790,9 @@ var ts; } return emptyArray; } - function serializeReturnTypeOfNode(node, getGeneratedNameForNode) { + function serializeReturnTypeOfNode(node) { if (node && ts.isFunctionLike(node)) { - return serializeTypeNode(node.type, getGeneratedNameForNode); + return serializeTypeNode(node.type); } return "void 0"; } @@ -19303,25 +19814,24 @@ var ts; function hasGlobalName(name) { return ts.hasProperty(globals, name); } - function resolvesToSomeValue(location, name) { - ts.Debug.assert(!ts.nodeIsSynthesized(location), "resolvesToSomeValue called with a synthesized location"); - return !!resolveName(location, name, 107455, undefined, undefined); + function getReferencedValueSymbol(reference) { + return getNodeLinks(reference).resolvedSymbol || + resolveName(reference, reference.text, 107455 | 1048576 | 8388608, undefined, undefined); } function getReferencedValueDeclaration(reference) { ts.Debug.assert(!ts.nodeIsSynthesized(reference)); - var symbol = getNodeLinks(reference).resolvedSymbol || - resolveName(reference, reference.text, 107455 | 8388608, undefined, undefined); + var symbol = getReferencedValueSymbol(reference); return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration; } function getBlockScopedVariableId(n) { ts.Debug.assert(!ts.nodeIsSynthesized(n)); - var isVariableDeclarationOrBindingElement = n.parent.kind === 153 || (n.parent.kind === 199 && n.parent.name === n); + var isVariableDeclarationOrBindingElement = n.parent.kind === 155 || (n.parent.kind === 201 && n.parent.name === n); var symbol = (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) || getNodeLinks(n).resolvedSymbol || resolveName(n, n.text, 107455 | 8388608, undefined, undefined); var isLetOrConst = symbol && (symbol.flags & 2) && - symbol.valueDeclaration.parent.kind !== 224; + symbol.valueDeclaration.parent.kind !== 226; if (isLetOrConst) { getSymbolLinks(symbol); return symbol.id; @@ -19341,7 +19851,10 @@ var ts; } function createResolver() { return { - getExpressionNameSubstitution: getExpressionNameSubstitution, + getReferencedExportContainer: getReferencedExportContainer, + getReferencedImportDeclaration: getReferencedImportDeclaration, + getReferencedNestedRedeclaration: getReferencedNestedRedeclaration, + isNestedRedeclaration: isNestedRedeclaration, isValueAliasDeclaration: isValueAliasDeclaration, hasGlobalName: hasGlobalName, isReferencedAliasDeclaration: isReferencedAliasDeclaration, @@ -19355,7 +19868,6 @@ var ts; isSymbolAccessible: isSymbolAccessible, isEntityNameVisible: isEntityNameVisible, getConstantValue: getConstantValue, - resolvesToSomeValue: resolvesToSomeValue, collectLinkedAliases: collectLinkedAliases, getBlockScopedVariableId: getBlockScopedVariableId, getReferencedValueDeclaration: getReferencedValueDeclaration, @@ -19406,105 +19918,6 @@ var ts; } anyArrayType = createArrayType(anyType); } - function isReservedWordInStrictMode(node) { - return (node.parserContextFlags & 1) && - (102 <= node.originalKeywordKind && node.originalKeywordKind <= 110); - } - function reportStrictModeGrammarErrorInClassDeclaration(identifier, message, arg0, arg1, arg2) { - if (ts.getAncestor(identifier, 202) || ts.getAncestor(identifier, 175)) { - return grammarErrorOnNode(identifier, message, arg0); - } - return false; - } - function checkGrammarImportDeclarationNameInStrictMode(node) { - if (node.importClause) { - var impotClause = node.importClause; - if (impotClause.namedBindings) { - var nameBindings = impotClause.namedBindings; - if (nameBindings.kind === 212) { - var name_15 = nameBindings.name; - if (isReservedWordInStrictMode(name_15)) { - var nameText = ts.declarationNameToString(name_15); - return grammarErrorOnNode(name_15, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - else if (nameBindings.kind === 213) { - var reportError = false; - for (var _i = 0, _a = nameBindings.elements; _i < _a.length; _i++) { - var element = _a[_i]; - var name_16 = element.name; - if (isReservedWordInStrictMode(name_16)) { - var nameText = ts.declarationNameToString(name_16); - reportError = reportError || grammarErrorOnNode(name_16, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - return reportError; - } - } - } - return false; - } - function checkGrammarDeclarationNameInStrictMode(node) { - var name = node.name; - if (name && name.kind === 65 && isReservedWordInStrictMode(name)) { - var nameText = ts.declarationNameToString(name); - switch (node.kind) { - case 130: - case 199: - case 201: - case 129: - case 153: - case 203: - case 204: - case 205: - return checkGrammarIdentifierInStrictMode(name); - case 202: - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText); - case 206: - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - case 209: - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - return false; - } - function checkGrammarTypeReferenceInStrictMode(typeName) { - if (typeName.kind === 65) { - checkGrammarTypeNameInStrictMode(typeName); - } - else if (typeName.kind === 127) { - checkGrammarTypeNameInStrictMode(typeName.right); - checkGrammarTypeReferenceInStrictMode(typeName.left); - } - } - function checkGrammarExpressionWithTypeArgumentsInStrictMode(expression) { - if (expression && expression.kind === 65) { - return checkGrammarIdentifierInStrictMode(expression); - } - else if (expression && expression.kind === 156) { - checkGrammarExpressionWithTypeArgumentsInStrictMode(expression.expression); - } - } - function checkGrammarIdentifierInStrictMode(node, nameText) { - if (node && node.kind === 65 && isReservedWordInStrictMode(node)) { - if (!nameText) { - nameText = ts.declarationNameToString(node); - } - var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || - grammarErrorOnNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - return errorReport; - } - return false; - } - function checkGrammarTypeNameInStrictMode(node) { - if (node && node.kind === 65 && isReservedWordInStrictMode(node)) { - var nameText = ts.declarationNameToString(node); - var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || - grammarErrorOnNode(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode, nameText); - return errorReport; - } - return false; - } function checkGrammarDecorators(node) { if (!node.decorators) { return false; @@ -19515,7 +19928,7 @@ var ts; else if (languageVersion < 1) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher); } - else if (node.kind === 137 || node.kind === 138) { + else if (node.kind === 138 || node.kind === 139) { var accessors = ts.getAllAccessorDeclarations(node.parent.members, node); if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name); @@ -19525,33 +19938,33 @@ var ts; } function checkGrammarModifiers(node) { switch (node.kind) { - case 137: case 138: - case 136: - case 133: - case 132: - case 135: + case 139: + case 137: case 134: - case 141: - case 206: - case 210: - case 209: - case 216: - case 215: - case 130: + case 133: + case 136: + case 135: + case 142: + case 208: + case 212: + case 211: + case 218: + case 217: + case 131: break; - case 202: - case 203: - case 181: - case 201: case 204: - if (node.modifiers && node.parent.kind !== 207 && node.parent.kind !== 228) { + case 205: + case 183: + case 203: + case 206: + if (node.modifiers && node.parent.kind !== 209 && node.parent.kind !== 230) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); } break; - case 205: + case 207: if (node.modifiers && (node.modifiers.length > 1 || node.modifiers[0].kind !== 70) && - node.parent.kind !== 207 && node.parent.kind !== 228) { + node.parent.kind !== 209 && node.parent.kind !== 230) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); } break; @@ -19587,7 +20000,7 @@ var ts; else if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } - else if (node.parent.kind === 207 || node.parent.kind === 228) { + else if (node.parent.kind === 209 || node.parent.kind === 230) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } flags |= ts.modifierToFlag(modifier.kind); @@ -19596,10 +20009,10 @@ var ts; if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); } - else if (node.parent.kind === 207 || node.parent.kind === 228) { + else if (node.parent.kind === 209 || node.parent.kind === 230) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } - else if (node.kind === 130) { + else if (node.kind === 131) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } flags |= 128; @@ -19612,10 +20025,10 @@ var ts; else if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } - else if (node.parent.kind === 202) { + else if (node.parent.kind === 204) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } - else if (node.kind === 130) { + else if (node.kind === 131) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); } flags |= 1; @@ -19624,13 +20037,13 @@ var ts; if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); } - else if (node.parent.kind === 202) { + else if (node.parent.kind === 204) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } - else if (node.kind === 130) { + else if (node.kind === 131) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); } - else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 207) { + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 209) { return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } flags |= 2; @@ -19638,7 +20051,7 @@ var ts; break; } } - if (node.kind === 136) { + if (node.kind === 137) { if (flags & 128) { return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } @@ -19649,10 +20062,10 @@ var ts; return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } } - else if ((node.kind === 210 || node.kind === 209) && flags & 2) { + else if ((node.kind === 212 || node.kind === 211) && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); } - else if (node.kind === 130 && (flags & 112) && ts.isBindingPattern(node.name)) { + else if (node.kind === 131 && (flags & 112) && ts.isBindingPattern(node.name)) { return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } } @@ -19715,7 +20128,7 @@ var ts; checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file); } function checkGrammarArrowFunction(node, file) { - if (node.kind === 164) { + if (node.kind === 166) { var arrowFunction = node; var startLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.pos).line; var endLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.end).line; @@ -19750,7 +20163,7 @@ var ts; if (!parameter.type) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation); } - if (parameter.type.kind !== 122 && parameter.type.kind !== 120) { + if (parameter.type.kind !== 123 && parameter.type.kind !== 121) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); } if (!node.type) { @@ -19782,7 +20195,7 @@ var ts; var sourceFile = ts.getSourceFileOfNode(node); for (var _i = 0; _i < arguments.length; _i++) { var arg = arguments[_i]; - if (arg.kind === 176) { + if (arg.kind === 178) { return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); } } @@ -19853,19 +20266,19 @@ var ts; return false; } function checkGrammarComputedPropertyName(node) { - if (node.kind !== 128) { + if (node.kind !== 129) { return false; } var computedPropertyName = node; - if (computedPropertyName.expression.kind === 170 && computedPropertyName.expression.operatorToken.kind === 23) { + if (computedPropertyName.expression.kind === 172 && computedPropertyName.expression.operatorToken.kind === 23) { return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); } } function checkGrammarForGenerator(node) { if (node.asteriskToken) { - ts.Debug.assert(node.kind === 201 || - node.kind === 163 || - node.kind === 135); + ts.Debug.assert(node.kind === 203 || + node.kind === 165 || + node.kind === 136); if (ts.isInAmbientContext(node)) { return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context); } @@ -19877,9 +20290,6 @@ var ts; } } } - function checkGrammarFunctionName(name) { - return checkGrammarEvalOrArgumentsInStrictMode(name, name); - } function checkGrammarForInvalidQuestionMark(node, questionToken, message) { if (questionToken) { return grammarErrorOnNode(questionToken, message); @@ -19891,55 +20301,52 @@ var ts; var GetAccessor = 2; var SetAccesor = 4; var GetOrSetAccessor = GetAccessor | SetAccesor; - var inStrictMode = (node.parserContextFlags & 1) !== 0; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var prop = _a[_i]; - var name_17 = prop.name; - if (prop.kind === 176 || - name_17.kind === 128) { - checkGrammarComputedPropertyName(name_17); + var name_15 = prop.name; + if (prop.kind === 178 || + name_15.kind === 129) { + checkGrammarComputedPropertyName(name_15); continue; } var currentKind = void 0; - if (prop.kind === 225 || prop.kind === 226) { + if (prop.kind === 227 || prop.kind === 228) { checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); - if (name_17.kind === 7) { - checkGrammarNumericLiteral(name_17); + if (name_15.kind === 7) { + checkGrammarNumericLiteral(name_15); } currentKind = Property; } - else if (prop.kind === 135) { + else if (prop.kind === 136) { currentKind = Property; } - else if (prop.kind === 137) { + else if (prop.kind === 138) { currentKind = GetAccessor; } - else if (prop.kind === 138) { + else if (prop.kind === 139) { currentKind = SetAccesor; } else { ts.Debug.fail("Unexpected syntax kind:" + prop.kind); } - if (!ts.hasProperty(seen, name_17.text)) { - seen[name_17.text] = currentKind; + if (!ts.hasProperty(seen, name_15.text)) { + seen[name_15.text] = currentKind; } else { - var existingKind = seen[name_17.text]; + var existingKind = seen[name_15.text]; if (currentKind === Property && existingKind === Property) { - if (inStrictMode) { - grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode); - } + continue; } else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) { if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) { - seen[name_17.text] = currentKind | existingKind; + seen[name_15.text] = currentKind | existingKind; } else { - return grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); + return grammarErrorOnNode(name_15, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); } } else { - return grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); + return grammarErrorOnNode(name_15, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); } } } @@ -19948,24 +20355,24 @@ var ts; if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; } - if (forInOrOfStatement.initializer.kind === 200) { + if (forInOrOfStatement.initializer.kind === 202) { var variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { if (variableList.declarations.length > 1) { - var diagnostic = forInOrOfStatement.kind === 188 + var diagnostic = forInOrOfStatement.kind === 190 ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement; return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic); } var firstDeclaration = variableList.declarations[0]; if (firstDeclaration.initializer) { - var diagnostic = forInOrOfStatement.kind === 188 + var diagnostic = forInOrOfStatement.kind === 190 ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer; return grammarErrorOnNode(firstDeclaration.name, diagnostic); } if (firstDeclaration.type) { - var diagnostic = forInOrOfStatement.kind === 188 + var diagnostic = forInOrOfStatement.kind === 190 ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation; return grammarErrorOnNode(firstDeclaration, diagnostic); @@ -19988,10 +20395,10 @@ var ts; else if (accessor.typeParameters) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); } - else if (kind === 137 && accessor.parameters.length) { + else if (kind === 138 && accessor.parameters.length) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); } - else if (kind === 138) { + else if (kind === 139) { if (accessor.type) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); } @@ -20016,7 +20423,7 @@ var ts; } } function checkGrammarForNonSymbolComputedProperty(node, message) { - if (node.kind === 128 && !ts.isWellKnownSymbolSyntactically(node.expression)) { + if (node.kind === 129 && !ts.isWellKnownSymbolSyntactically(node.expression)) { return grammarErrorOnNode(node, message); } } @@ -20026,7 +20433,7 @@ var ts; checkGrammarForGenerator(node)) { return true; } - if (node.parent.kind === 155) { + if (node.parent.kind === 157) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -20034,7 +20441,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 202) { + if (node.parent.kind === 204) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -20045,22 +20452,22 @@ var ts; return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol); } } - else if (node.parent.kind === 203) { + else if (node.parent.kind === 205) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol); } - else if (node.parent.kind === 146) { + else if (node.parent.kind === 148) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol); } } function isIterationStatement(node, lookInLabeledStatements) { switch (node.kind) { + case 189: + case 190: + case 191: case 187: case 188: - case 189: - case 185: - case 186: return true; - case 195: + case 197: return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); } return false; @@ -20072,9 +20479,9 @@ var ts; return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); } switch (current.kind) { - case 195: + case 197: if (node.label && current.label.text === node.label.text) { - var isMisplacedContinueLabel = node.kind === 190 + var isMisplacedContinueLabel = node.kind === 192 && !isIterationStatement(current.statement, true); if (isMisplacedContinueLabel) { return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement); @@ -20082,8 +20489,8 @@ var ts; return false; } break; - case 194: - if (node.kind === 191 && !node.label) { + case 196: + if (node.kind === 193 && !node.label) { return false; } break; @@ -20096,13 +20503,13 @@ var ts; current = current.parent; } if (node.label) { - var message = node.kind === 191 + var message = node.kind === 193 ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); } else { - var message = node.kind === 191 + var message = node.kind === 193 ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); @@ -20114,17 +20521,16 @@ var ts; if (node !== ts.lastOrUndefined(elements)) { return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern); } - if (node.name.kind === 152 || node.name.kind === 151) { + if (node.name.kind === 154 || node.name.kind === 153) { return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern); } if (node.initializer) { return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } } - return checkGrammarEvalOrArgumentsInStrictMode(node, node.name); } function checkGrammarVariableDeclaration(node) { - if (node.parent.parent.kind !== 188 && node.parent.parent.kind !== 189) { + if (node.parent.parent.kind !== 190 && node.parent.parent.kind !== 191) { if (ts.isInAmbientContext(node)) { if (node.initializer) { var equalsTokenLength = "=".length; @@ -20141,8 +20547,7 @@ var ts; } } var checkLetConstNames = languageVersion >= 2 && (ts.isLet(node) || ts.isConst(node)); - return (checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name)) || - checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name); } function checkGrammarNameInLetOrConstDeclarations(name) { if (name.kind === 65) { @@ -20154,7 +20559,7 @@ var ts; var elements = name.elements; for (var _i = 0; _i < elements.length; _i++) { var element = elements[_i]; - if (element.kind !== 176) { + if (element.kind !== 178) { checkGrammarNameInLetOrConstDeclarations(element.name); } } @@ -20171,15 +20576,15 @@ var ts; } function allowLetAndConstDeclarations(parent) { switch (parent.kind) { - case 184: - case 185: case 186: - case 193: case 187: case 188: - case 189: - return false; case 195: + case 189: + case 190: + case 191: + return false; + case 197: return allowLetAndConstDeclarations(parent.parent); } return true; @@ -20195,7 +20600,7 @@ var ts; } } function isIntegerLiteral(expression) { - if (expression.kind === 168) { + if (expression.kind === 170) { var unaryExpression = expression; if (unaryExpression.operator === 33 || unaryExpression.operator === 34) { expression = unaryExpression.operand; @@ -20214,7 +20619,7 @@ var ts; var inAmbientContext = ts.isInAmbientContext(enumDecl); for (var _i = 0, _a = enumDecl.members; _i < _a.length; _i++) { var node = _a[_i]; - if (node.name.kind === 128) { + if (node.name.kind === 129) { hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); } else if (inAmbientContext) { @@ -20256,23 +20661,6 @@ var ts; return true; } } - function checkGrammarEvalOrArgumentsInStrictMode(contextNode, name) { - if (name && name.kind === 65) { - var identifier = name; - if (contextNode && (contextNode.parserContextFlags & 1) && isEvalOrArgumentsIdentifier(identifier)) { - var nameText = ts.declarationNameToString(identifier); - var reportErrorInClassDeclaration = reportStrictModeGrammarErrorInClassDeclaration(identifier, ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode, nameText); - if (!reportErrorInClassDeclaration) { - return grammarErrorOnNode(identifier, ts.Diagnostics.Invalid_use_of_0_in_strict_mode, nameText); - } - return reportErrorInClassDeclaration; - } - } - } - function isEvalOrArgumentsIdentifier(node) { - return node.kind === 65 && - (node.text === "eval" || node.text === "arguments"); - } function checkGrammarConstructorTypeParameters(node) { if (node.typeParameters) { return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration); @@ -20284,18 +20672,18 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 202) { + if (node.parent.kind === 204) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 203) { + else if (node.parent.kind === 205) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 146) { + else if (node.parent.kind === 148) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { return true; } @@ -20305,11 +20693,11 @@ var ts; } } function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { - if (node.kind === 203 || - node.kind === 210 || - node.kind === 209 || - node.kind === 216 || - node.kind === 215 || + if (node.kind === 205 || + node.kind === 212 || + node.kind === 211 || + node.kind === 218 || + node.kind === 217 || (node.flags & 2) || (node.flags & (1 | 256))) { return false; @@ -20319,7 +20707,7 @@ var ts; function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { var decl = _a[_i]; - if (ts.isDeclaration(decl) || decl.kind === 181) { + if (ts.isDeclaration(decl) || decl.kind === 183) { if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { return true; } @@ -20338,7 +20726,7 @@ var ts; if (!links.hasReportedStatementInAmbientContext && ts.isFunctionLike(node.parent)) { return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); } - if (node.parent.kind === 180 || node.parent.kind === 207 || node.parent.kind === 228) { + if (node.parent.kind === 182 || node.parent.kind === 209 || node.parent.kind === 230) { var links_1 = getNodeLinks(node.parent); if (!links_1.hasReportedStatementInAmbientContext) { return links_1.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); @@ -20349,13 +20737,8 @@ var ts; } } function checkGrammarNumericLiteral(node) { - if (node.flags & 16384) { - if (node.parserContextFlags & 1) { - return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode); - } - else if (languageVersion >= 1) { - return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); - } + if (node.flags & 16384 && languageVersion >= 1) { + return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); } } function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) { @@ -20366,8 +20749,6 @@ var ts; return true; } } - initializeTypeChecker(); - return checker; } ts.createTypeChecker = createTypeChecker; })(ts || (ts = {})); @@ -20419,7 +20800,7 @@ var ts; var oldWriter = writer; ts.forEach(moduleElementDeclarationEmitInfo, function (aliasEmitInfo) { if (aliasEmitInfo.isVisible) { - ts.Debug.assert(aliasEmitInfo.node.kind === 210); + ts.Debug.assert(aliasEmitInfo.node.kind === 212); createAndSetNewTextWriterWithSymbolWriter(); ts.Debug.assert(aliasEmitInfo.indent === 0); writeImportDeclaration(aliasEmitInfo.node); @@ -20492,10 +20873,10 @@ var ts; var oldWriter = writer; ts.forEach(nodes, function (declaration) { var nodeToCheck; - if (declaration.kind === 199) { + if (declaration.kind === 201) { nodeToCheck = declaration.parent.parent; } - else if (declaration.kind === 213 || declaration.kind === 214 || declaration.kind === 211) { + else if (declaration.kind === 215 || declaration.kind === 216 || declaration.kind === 213) { ts.Debug.fail("We should be getting ImportDeclaration instead to write"); } else { @@ -20506,7 +20887,7 @@ var ts; moduleElementEmitInfo = ts.forEach(asynchronousSubModuleDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined; }); } if (moduleElementEmitInfo) { - if (moduleElementEmitInfo.node.kind === 210) { + if (moduleElementEmitInfo.node.kind === 212) { moduleElementEmitInfo.isVisible = true; } else { @@ -20514,12 +20895,12 @@ var ts; for (var declarationIndent = moduleElementEmitInfo.indent; declarationIndent; declarationIndent--) { increaseIndent(); } - if (nodeToCheck.kind === 206) { + if (nodeToCheck.kind === 208) { ts.Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined); asynchronousSubModuleDeclarationEmitInfo = []; } writeModuleElement(nodeToCheck); - if (nodeToCheck.kind === 206) { + if (nodeToCheck.kind === 208) { moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo; asynchronousSubModuleDeclarationEmitInfo = undefined; } @@ -20607,39 +20988,39 @@ var ts; function emitType(type) { switch (type.kind) { case 112: - case 122: - case 120: - case 113: case 123: + case 121: + case 113: + case 124: case 99: case 8: return writeTextOfNode(currentSourceFile, type); - case 177: + case 179: return emitExpressionWithTypeArguments(type); - case 142: - return emitTypeReference(type); - case 145: - return emitTypeQuery(type); - case 147: - return emitArrayType(type); - case 148: - return emitTupleType(type); - case 149: - return emitUnionType(type); - case 150: - return emitParenType(type); - case 143: case 144: - return emitSignatureDeclarationWithJsDocComments(type); + return emitTypeReference(type); + case 147: + return emitTypeQuery(type); + case 149: + return emitArrayType(type); + case 150: + return emitTupleType(type); + case 151: + return emitUnionType(type); + case 152: + return emitParenType(type); + case 145: case 146: + return emitSignatureDeclarationWithJsDocComments(type); + case 148: return emitTypeLiteral(type); case 65: return emitEntityName(type); - case 127: + case 128: return emitEntityName(type); } function emitEntityName(entityName) { - var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 209 ? entityName.parent : enclosingDeclaration); + var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 211 ? entityName.parent : enclosingDeclaration); handleSymbolAccessibilityError(visibilityResult); writeEntityName(entityName); function writeEntityName(entityName) { @@ -20647,8 +21028,8 @@ var ts; writeTextOfNode(currentSourceFile, entityName); } else { - var left = entityName.kind === 127 ? entityName.left : entityName.expression; - var right = entityName.kind === 127 ? entityName.right : entityName.name; + var left = entityName.kind === 128 ? entityName.left : entityName.expression; + var right = entityName.kind === 128 ? entityName.right : entityName.name; writeEntityName(left); write("."); writeTextOfNode(currentSourceFile, right); @@ -20657,7 +21038,7 @@ var ts; } function emitExpressionWithTypeArguments(node) { if (ts.isSupportedExpressionWithTypeArguments(node)) { - ts.Debug.assert(node.expression.kind === 65 || node.expression.kind === 156); + ts.Debug.assert(node.expression.kind === 65 || node.expression.kind === 158); emitEntityName(node.expression); if (node.typeArguments) { write("<"); @@ -20718,9 +21099,9 @@ var ts; } var count = 0; while (true) { - var name_18 = baseName + "_" + (++count); - if (!ts.hasProperty(currentSourceFile.identifiers, name_18)) { - return name_18; + var name_16 = baseName + "_" + (++count); + if (!ts.hasProperty(currentSourceFile.identifiers, name_16)) { + return name_16; } } } @@ -20761,10 +21142,10 @@ var ts; if (isModuleElementVisible) { writeModuleElement(node); } - else if (node.kind === 209 || - (node.parent.kind === 228 && ts.isExternalModule(currentSourceFile))) { + else if (node.kind === 211 || + (node.parent.kind === 230 && ts.isExternalModule(currentSourceFile))) { var isVisible; - if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 228) { + if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 230) { asynchronousSubModuleDeclarationEmitInfo.push({ node: node, outputPos: writer.getTextPos(), @@ -20773,7 +21154,7 @@ var ts; }); } else { - if (node.kind === 210) { + if (node.kind === 212) { var importDeclaration = node; if (importDeclaration.importClause) { isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) || @@ -20791,23 +21172,23 @@ var ts; } function writeModuleElement(node) { switch (node.kind) { - case 201: - return writeFunctionDeclaration(node); - case 181: - return writeVariableStatement(node); case 203: - return writeInterfaceDeclaration(node); - case 202: - return writeClassDeclaration(node); - case 204: - return writeTypeAliasDeclaration(node); + return writeFunctionDeclaration(node); + case 183: + return writeVariableStatement(node); case 205: - return writeEnumDeclaration(node); + return writeInterfaceDeclaration(node); + case 204: + return writeClassDeclaration(node); case 206: + return writeTypeAliasDeclaration(node); + case 207: + return writeEnumDeclaration(node); + case 208: return writeModuleDeclaration(node); - case 209: + case 211: return writeImportEqualsDeclaration(node); - case 210: + case 212: return writeImportDeclaration(node); default: ts.Debug.fail("Unknown symbol kind"); @@ -20821,7 +21202,7 @@ var ts; if (node.flags & 256) { write("default "); } - else if (node.kind !== 203) { + else if (node.kind !== 205) { write("declare "); } } @@ -20865,7 +21246,7 @@ var ts; } function isVisibleNamedBinding(namedBindings) { if (namedBindings) { - if (namedBindings.kind === 212) { + if (namedBindings.kind === 214) { return resolver.isDeclarationVisible(namedBindings); } else { @@ -20891,7 +21272,7 @@ var ts; if (currentWriterPos !== writer.getTextPos()) { write(", "); } - if (node.importClause.namedBindings.kind === 212) { + if (node.importClause.namedBindings.kind === 214) { write("* as "); writeTextOfNode(currentSourceFile, node.importClause.namedBindings.name); } @@ -20940,9 +21321,14 @@ var ts; function writeModuleDeclaration(node) { emitJsDocComments(node); emitModuleElementDeclarationFlags(node); - write("module "); + if (node.flags & 32768) { + write("namespace "); + } + else { + write("module "); + } writeTextOfNode(currentSourceFile, node.name); - while (node.body.kind !== 207) { + while (node.body.kind !== 209) { node = node.body; write("."); writeTextOfNode(currentSourceFile, node.name); @@ -21003,7 +21389,7 @@ var ts; writeLine(); } function isPrivateMethodTypeParameter(node) { - return node.parent.kind === 135 && (node.parent.flags & 32); + return node.parent.kind === 136 && (node.parent.flags & 32); } function emitTypeParameters(typeParameters) { function emitTypeParameter(node) { @@ -21013,15 +21399,15 @@ var ts; writeTextOfNode(currentSourceFile, node.name); if (node.constraint && !isPrivateMethodTypeParameter(node)) { write(" extends "); - if (node.parent.kind === 143 || - node.parent.kind === 144 || - (node.parent.parent && node.parent.parent.kind === 146)) { - ts.Debug.assert(node.parent.kind === 135 || - node.parent.kind === 134 || - node.parent.kind === 143 || - node.parent.kind === 144 || - node.parent.kind === 139 || - node.parent.kind === 140); + if (node.parent.kind === 145 || + node.parent.kind === 146 || + (node.parent.parent && node.parent.parent.kind === 148)) { + ts.Debug.assert(node.parent.kind === 136 || + node.parent.kind === 135 || + node.parent.kind === 145 || + node.parent.kind === 146 || + node.parent.kind === 140 || + node.parent.kind === 141); emitType(node.constraint); } else { @@ -21031,31 +21417,31 @@ var ts; function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.parent.kind) { - case 202: + case 204: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; break; - case 203: + case 205: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; break; - case 140: + case 141: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 139: + case 140: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; break; + case 136: case 135: - case 134: if (node.parent.flags & 128) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202) { + else if (node.parent.parent.kind === 204) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } break; - case 201: + case 203: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -21085,7 +21471,7 @@ var ts; } function getHeritageClauseVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (node.parent.parent.kind === 202) { + if (node.parent.parent.kind === 204) { diagnosticMessage = isImplementsList ? ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : ts.Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1; @@ -21162,16 +21548,16 @@ var ts; writeLine(); } function emitVariableDeclaration(node) { - if (node.kind !== 199 || resolver.isDeclarationVisible(node)) { + if (node.kind !== 201 || resolver.isDeclarationVisible(node)) { if (ts.isBindingPattern(node.name)) { emitBindingPattern(node.name); } else { writeTextOfNode(currentSourceFile, node.name); - if ((node.kind === 133 || node.kind === 132) && ts.hasQuestionToken(node)) { + if ((node.kind === 134 || node.kind === 133) && ts.hasQuestionToken(node)) { write("?"); } - if ((node.kind === 133 || node.kind === 132) && node.parent.kind === 146) { + if ((node.kind === 134 || node.kind === 133) && node.parent.kind === 148) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.flags & 32)) { @@ -21180,14 +21566,14 @@ var ts; } } function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { - if (node.kind === 199) { + if (node.kind === 201) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1; } - else if (node.kind === 133 || node.kind === 132) { + else if (node.kind === 134 || node.kind === 133) { if (node.flags & 128) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? @@ -21195,7 +21581,7 @@ var ts; ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.kind === 202) { + else if (node.parent.kind === 204) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -21221,7 +21607,7 @@ var ts; var elements = []; for (var _i = 0, _a = bindingPattern.elements; _i < _a.length; _i++) { var element = _a[_i]; - if (element.kind !== 176) { + if (element.kind !== 178) { elements.push(element); } } @@ -21287,7 +21673,7 @@ var ts; accessorWithTypeAnnotation = node; var type = getTypeAnnotationFromAccessor(node); if (!type) { - var anotherAccessor = node.kind === 137 ? accessors.setAccessor : accessors.getAccessor; + var anotherAccessor = node.kind === 138 ? accessors.setAccessor : accessors.getAccessor; type = getTypeAnnotationFromAccessor(anotherAccessor); if (type) { accessorWithTypeAnnotation = anotherAccessor; @@ -21300,7 +21686,7 @@ var ts; } function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 137 + return accessor.kind === 138 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type @@ -21309,7 +21695,7 @@ var ts; } function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (accessorWithTypeAnnotation.kind === 138) { + if (accessorWithTypeAnnotation.kind === 139) { if (accessorWithTypeAnnotation.parent.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 : @@ -21355,17 +21741,17 @@ var ts; } if (!resolver.isImplementationOfOverload(node)) { emitJsDocComments(node); - if (node.kind === 201) { + if (node.kind === 203) { emitModuleElementDeclarationFlags(node); } - else if (node.kind === 135) { + else if (node.kind === 136) { emitClassMemberDeclarationFlags(node); } - if (node.kind === 201) { + if (node.kind === 203) { write("function "); writeTextOfNode(currentSourceFile, node.name); } - else if (node.kind === 136) { + else if (node.kind === 137) { write("constructor"); } else { @@ -21382,11 +21768,11 @@ var ts; emitSignatureDeclaration(node); } function emitSignatureDeclaration(node) { - if (node.kind === 140 || node.kind === 144) { + if (node.kind === 141 || node.kind === 146) { write("new "); } emitTypeParameters(node.typeParameters); - if (node.kind === 141) { + if (node.kind === 142) { write("["); } else { @@ -21395,20 +21781,20 @@ var ts; var prevEnclosingDeclaration = enclosingDeclaration; enclosingDeclaration = node; emitCommaList(node.parameters, emitParameterDeclaration); - if (node.kind === 141) { + if (node.kind === 142) { write("]"); } else { write(")"); } - var isFunctionTypeOrConstructorType = node.kind === 143 || node.kind === 144; - if (isFunctionTypeOrConstructorType || node.parent.kind === 146) { + var isFunctionTypeOrConstructorType = node.kind === 145 || node.kind === 146; + if (isFunctionTypeOrConstructorType || node.parent.kind === 148) { if (node.type) { write(isFunctionTypeOrConstructorType ? " => " : ": "); emitType(node.type); } } - else if (node.kind !== 136 && !(node.flags & 32)) { + else if (node.kind !== 137 && !(node.flags & 32)) { writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); } enclosingDeclaration = prevEnclosingDeclaration; @@ -21419,23 +21805,23 @@ var ts; function getReturnTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.kind) { - case 140: + case 141: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 139: + case 140: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 141: + case 142: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0; break; + case 136: case 135: - case 134: if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? @@ -21443,7 +21829,7 @@ var ts; ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0; } - else if (node.parent.kind === 202) { + else if (node.parent.kind === 204) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : @@ -21456,7 +21842,7 @@ var ts; ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; } break; - case 201: + case 203: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : @@ -21488,9 +21874,9 @@ var ts; write("?"); } decreaseIndent(); - if (node.parent.kind === 143 || - node.parent.kind === 144 || - node.parent.parent.kind === 146) { + if (node.parent.kind === 145 || + node.parent.kind === 146 || + node.parent.parent.kind === 148) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.parent.flags & 32)) { @@ -21506,22 +21892,22 @@ var ts; } function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { switch (node.parent.kind) { - case 136: + case 137: return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1; - case 140: + case 141: return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; - case 139: + case 140: return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + case 136: case 135: - case 134: if (node.parent.flags & 128) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? @@ -21529,7 +21915,7 @@ var ts; ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202) { + else if (node.parent.parent.kind === 204) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -21541,7 +21927,7 @@ var ts; ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } - case 201: + case 203: return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -21552,12 +21938,12 @@ var ts; } } function emitBindingPattern(bindingPattern) { - if (bindingPattern.kind === 151) { + if (bindingPattern.kind === 153) { write("{"); emitCommaList(bindingPattern.elements, emitBindingElement); write("}"); } - else if (bindingPattern.kind === 152) { + else if (bindingPattern.kind === 154) { write("["); var elements = bindingPattern.elements; emitCommaList(elements, emitBindingElement); @@ -21576,10 +21962,10 @@ var ts; typeName: bindingElement.name } : undefined; } - if (bindingElement.kind === 176) { + if (bindingElement.kind === 178) { write(" "); } - else if (bindingElement.kind === 153) { + else if (bindingElement.kind === 155) { if (bindingElement.propertyName) { writeTextOfNode(currentSourceFile, bindingElement.propertyName); write(": "); @@ -21602,39 +21988,39 @@ var ts; } function emitNode(node) { switch (node.kind) { - case 201: - case 206: - case 209: case 203: - case 202: - case 204: + case 208: + case 211: case 205: + case 204: + case 206: + case 207: return emitModuleElement(node, isModuleElementVisible(node)); - case 181: + case 183: return emitModuleElement(node, isVariableStatementVisible(node)); - case 210: + case 212: return emitModuleElement(node, !node.importClause); - case 216: + case 218: return emitExportDeclaration(node); + case 137: case 136: case 135: - case 134: return writeFunctionDeclaration(node); - case 140: - case 139: case 141: + case 140: + case 142: return emitSignatureDeclarationWithJsDocComments(node); - case 137: case 138: + case 139: return emitAccessorDeclaration(node); + case 134: case 133: - case 132: return emitPropertyDeclaration(node); - case 227: + case 229: return emitEnumMemberDeclaration(node); - case 215: + case 217: return emitExportAssignment(node); - case 228: + case 230: return emitSourceFile(node); } } @@ -21680,7 +22066,7 @@ var ts; } ts.isExternalModuleOrDeclarationFile = isExternalModuleOrDeclarationFile; function emitFiles(resolver, host, targetSourceFile) { - var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n __.prototype = b.prototype;\n d.prototype = new __();\n};"; + var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};"; var decorateHelper = "\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") return Reflect.decorate(decorators, target, key, desc);\n switch (arguments.length) {\n case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);\n case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);\n case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);\n }\n};"; var metadataHelper = "\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};"; var paramHelper = "\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); }\n};"; @@ -21744,7 +22130,6 @@ var ts; var exportFunctionForFile; var generatedNameSet = {}; var nodeToGeneratedName = []; - var blockScopedVariableToGeneratedName; var computedPropertyNamesToGeneratedNames; var extendsEmitted = false; var decorateEmitted = false; @@ -21804,9 +22189,9 @@ var ts; var count = tempFlags & 268435455; tempFlags++; if (count !== 8 && count !== 13) { - var name_19 = count < 26 ? "_" + String.fromCharCode(97 + count) : "_" + (count - 26); - if (isUniqueName(name_19)) { - return name_19; + var name_17 = count < 26 ? "_" + String.fromCharCode(97 + count) : "_" + (count - 26); + if (isUniqueName(name_17)) { + return name_17; } } } @@ -21824,72 +22209,39 @@ var ts; i++; } } - function assignGeneratedName(node, name) { - nodeToGeneratedName[ts.getNodeId(node)] = ts.unescapeIdentifier(name); - } - function generateNameForFunctionOrClassDeclaration(node) { - if (!node.name) { - assignGeneratedName(node, makeUniqueName("default")); - } - } function generateNameForModuleOrEnum(node) { - if (node.name.kind === 65) { - var name_20 = node.name.text; - assignGeneratedName(node, isUniqueLocalName(name_20, node) ? name_20 : makeUniqueName(name_20)); - } + var name = node.name.text; + return isUniqueLocalName(name, node) ? name : makeUniqueName(name); } function generateNameForImportOrExportDeclaration(node) { var expr = ts.getExternalModuleName(node); var baseName = expr.kind === 8 ? ts.escapeIdentifier(ts.makeIdentifierFromModuleName(expr.text)) : "module"; - assignGeneratedName(node, makeUniqueName(baseName)); + return makeUniqueName(baseName); } - function generateNameForImportDeclaration(node) { - if (node.importClause) { - generateNameForImportOrExportDeclaration(node); - } - } - function generateNameForExportDeclaration(node) { - if (node.moduleSpecifier) { - generateNameForImportOrExportDeclaration(node); - } - } - function generateNameForExportAssignment(node) { - if (node.expression && node.expression.kind !== 65) { - assignGeneratedName(node, makeUniqueName("default")); - } + function generateNameForExportDefault() { + return makeUniqueName("default"); } function generateNameForNode(node) { switch (node.kind) { - case 201: - case 202: - case 175: - generateNameForFunctionOrClassDeclaration(node); - break; - case 206: - generateNameForModuleOrEnum(node); - generateNameForNode(node.body); - break; - case 205: - generateNameForModuleOrEnum(node); - break; - case 210: - generateNameForImportDeclaration(node); - break; - case 216: - generateNameForExportDeclaration(node); - break; - case 215: - generateNameForExportAssignment(node); - break; + case 65: + return makeUniqueName(node.text); + case 208: + case 207: + return generateNameForModuleOrEnum(node); + case 212: + case 218: + return generateNameForImportOrExportDeclaration(node); + case 203: + case 204: + case 177: + case 217: + return generateNameForExportDefault(); } } function getGeneratedNameForNode(node) { - var nodeId = ts.getNodeId(node); - if (!nodeToGeneratedName[nodeId]) { - generateNameForNode(node); - } - return nodeToGeneratedName[nodeId]; + var id = ts.getNodeId(node); + return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = ts.unescapeIdentifier(generateNameForNode(node))); } function initializeEmitterWithSourceMaps() { var sourceMapDir; @@ -21913,7 +22265,7 @@ var ts; return; } var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; - if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) { + if (lastEncodedSourceMapSpan.emittedLine === lastRecordedSourceMapSpan.emittedLine) { if (sourceMapData.sourceMapMappings) { sourceMapData.sourceMapMappings += ","; } @@ -21966,8 +22318,8 @@ var ts; var emittedLine = writer.getLine(); var emittedColumn = writer.getColumn(); if (!lastRecordedSourceMapSpan || - lastRecordedSourceMapSpan.emittedLine != emittedLine || - lastRecordedSourceMapSpan.emittedColumn != emittedColumn || + lastRecordedSourceMapSpan.emittedLine !== emittedLine || + lastRecordedSourceMapSpan.emittedColumn !== emittedColumn || (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex && (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line || (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) { @@ -22021,8 +22373,8 @@ var ts; if (scopeName) { var parentIndex = getSourceMapNameIndex(); if (parentIndex !== -1) { - var name_21 = node.name; - if (!name_21 || name_21.kind !== 128) { + var name_18 = node.name; + if (!name_18 || name_18.kind !== 129) { scopeName = "." + scopeName; } scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; @@ -22039,19 +22391,19 @@ var ts; if (scopeName) { recordScopeNameStart(scopeName); } - else if (node.kind === 201 || - node.kind === 163 || + else if (node.kind === 203 || + node.kind === 165 || + node.kind === 136 || node.kind === 135 || - node.kind === 134 || - node.kind === 137 || node.kind === 138 || - node.kind === 206 || - node.kind === 202 || - node.kind === 205) { + node.kind === 139 || + node.kind === 208 || + node.kind === 204 || + node.kind === 207) { if (node.name) { - var name_22 = node.name; - scopeName = name_22.kind === 128 - ? ts.getTextOfNode(name_22) + var name_19 = node.name; + scopeName = name_19.kind === 129 + ? ts.getTextOfNode(name_19) : node.name.text; } recordScopeNameStart(scopeName); @@ -22144,19 +22496,19 @@ var ts; else { sourceMapDir = ts.getDirectoryPath(ts.normalizePath(jsFilePath)); } - function emitNodeWithSourceMap(node, allowGeneratedIdentifiers) { + function emitNodeWithSourceMap(node) { if (node) { if (ts.nodeIsSynthesized(node)) { - return emitNodeWithoutSourceMap(node, false); + return emitNodeWithoutSourceMap(node); } - if (node.kind != 228) { + if (node.kind !== 230) { recordEmitNodeStartSpan(node); - emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers); + emitNodeWithoutSourceMap(node); recordEmitNodeEndSpan(node); } else { recordNewSourceFileStart(node); - emitNodeWithoutSourceMap(node, false); + emitNodeWithoutSourceMap(node); } } } @@ -22394,10 +22746,10 @@ var ts; emitParenthesizedIf(node.tag, needsParenthesisForPropertyAccessOrInvocation(node.tag)); write("("); emit(tempVariable); - if (node.template.kind === 172) { + if (node.template.kind === 174) { ts.forEach(node.template.templateSpans, function (templateSpan) { write(", "); - var needsParens = templateSpan.expression.kind === 170 + var needsParens = templateSpan.expression.kind === 172 && templateSpan.expression.operatorToken.kind === 23; emitParenthesizedIf(templateSpan.expression, needsParens); }); @@ -22421,7 +22773,7 @@ var ts; } for (var i = 0, n = node.templateSpans.length; i < n; i++) { var templateSpan = node.templateSpans[i]; - var needsParens = templateSpan.expression.kind !== 162 + var needsParens = templateSpan.expression.kind !== 164 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; if (i > 0 || headEmitted) { write(" + "); @@ -22454,11 +22806,11 @@ var ts; } function templateNeedsParens(template, parent) { switch (parent.kind) { - case 158: - case 159: - return parent.expression === template; case 160: + case 161: + return parent.expression === template; case 162: + case 164: return false; default: return comparePrecedenceToBinaryPlus(parent) !== -1; @@ -22466,7 +22818,7 @@ var ts; } function comparePrecedenceToBinaryPlus(expression) { switch (expression.kind) { - case 170: + case 172: switch (expression.operatorToken.kind) { case 35: case 36: @@ -22478,8 +22830,8 @@ var ts; default: return -1; } + case 175: case 173: - case 171: return -1; default: return 1; @@ -22491,11 +22843,11 @@ var ts; emit(span.literal); } function emitExpressionForPropertyName(node) { - ts.Debug.assert(node.kind !== 153); + ts.Debug.assert(node.kind !== 155); if (node.kind === 8) { emitLiteral(node); } - else if (node.kind === 128) { + else if (node.kind === 129) { if (ts.nodeIsDecorated(node.parent)) { if (!computedPropertyNamesToGeneratedNames) { computedPropertyNamesToGeneratedNames = []; @@ -22523,75 +22875,122 @@ var ts; write("\""); } } - function isNotExpressionIdentifier(node) { + function isExpressionIdentifier(node) { var parent = node.parent; switch (parent.kind) { - case 130: - case 199: - case 153: - case 133: + case 156: + case 172: + case 160: + case 223: + case 129: + case 173: case 132: - case 225: - case 226: + case 167: + case 187: + case 159: + case 217: + case 185: + case 179: + case 189: + case 190: + case 191: + case 186: + case 161: + case 164: + case 171: + case 170: + case 194: + case 228: + case 176: + case 196: + case 162: + case 180: + case 198: + case 163: + case 168: + case 169: + case 188: + case 195: + case 175: + return true; + case 155: + case 229: + case 131: case 227: - case 135: case 134: case 201: - case 137: - case 138: - case 163: - case 202: - case 203: - case 205: - case 206: - case 209: + return parent.initializer === node; + case 158: + return parent.expression === node; + case 166: + case 165: + return parent.body === node; case 211: - case 212: - return parent.name === node; - case 214: - case 218: - return parent.name === node || parent.propertyName === node; - case 191: - case 190: - case 215: - return false; - case 195: - return node.parent.label === node; + return parent.moduleReference === node; + case 128: + return parent.left === node; } + return false; } function emitExpressionIdentifier(node) { - var substitution = resolver.getExpressionNameSubstitution(node, getGeneratedNameForNode); - if (substitution) { - write(substitution); + var container = resolver.getReferencedExportContainer(node); + if (container) { + if (container.kind === 230) { + if (languageVersion < 2 && compilerOptions.module !== 4) { + write("exports."); + } + } + else { + write(getGeneratedNameForNode(container)); + write("."); + } } - else { - writeTextOfNode(currentSourceFile, node); - } - } - function getGeneratedNameForIdentifier(node) { - if (ts.nodeIsSynthesized(node) || !blockScopedVariableToGeneratedName) { - return undefined; - } - var variableId = resolver.getBlockScopedVariableId(node); - if (variableId === undefined) { - return undefined; - } - return blockScopedVariableToGeneratedName[variableId]; - } - function emitIdentifier(node, allowGeneratedIdentifiers) { - if (allowGeneratedIdentifiers) { - var generatedName = getGeneratedNameForIdentifier(node); - if (generatedName) { - write(generatedName); + else if (languageVersion < 2) { + var declaration = resolver.getReferencedImportDeclaration(node); + if (declaration) { + if (declaration.kind === 213) { + write(getGeneratedNameForNode(declaration.parent)); + write(languageVersion === 0 ? '["default"]' : ".default"); + return; + } + else if (declaration.kind === 216) { + write(getGeneratedNameForNode(declaration.parent.parent.parent)); + write("."); + writeTextOfNode(currentSourceFile, declaration.propertyName || declaration.name); + return; + } + } + declaration = resolver.getReferencedNestedRedeclaration(node); + if (declaration) { + write(getGeneratedNameForNode(declaration.name)); return; } } + writeTextOfNode(currentSourceFile, node); + } + function isNameOfNestedRedeclaration(node) { + if (languageVersion < 2) { + var parent_7 = node.parent; + switch (parent_7.kind) { + case 155: + case 204: + case 207: + case 201: + return parent_7.name === node && resolver.isNestedRedeclaration(parent_7); + } + } + return false; + } + function emitIdentifier(node) { if (!node.parent) { write(node.text); } - else if (!isNotExpressionIdentifier(node)) { + else if (isExpressionIdentifier(node)) { emitExpressionIdentifier(node); } + else if (isNameOfNestedRedeclaration(node)) { + write(getGeneratedNameForNode(node)); + } else { writeTextOfNode(currentSourceFile, node); } @@ -22632,7 +23031,7 @@ var ts; } function emitBindingElement(node) { if (node.propertyName) { - emit(node.propertyName, false); + emit(node.propertyName); write(": "); } if (node.dotDotDotToken) { @@ -22663,11 +23062,11 @@ var ts; function needsParenthesisForPropertyAccessOrInvocation(node) { switch (node.kind) { case 65: - case 154: case 156: - case 157: case 158: - case 162: + case 159: + case 160: + case 164: return false; } return true; @@ -22684,17 +23083,17 @@ var ts; write(", "); } var e = elements[pos]; - if (e.kind === 174) { + if (e.kind === 176) { e = e.expression; emitParenthesizedIf(e, group === 0 && needsParenthesisForPropertyAccessOrInvocation(e)); pos++; - if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 154) { + if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 156) { write(".slice()"); } } else { var i = pos; - while (i < length && elements[i].kind !== 174) { + while (i < length && elements[i].kind !== 176) { i++; } write("["); @@ -22717,7 +23116,7 @@ var ts; } } function isSpreadElementExpression(node) { - return node.kind === 174; + return node.kind === 176; } function emitArrayLiteral(node) { var elements = node.elements; @@ -22778,7 +23177,7 @@ var ts; writeComma(); var property = properties[i]; emitStart(property); - if (property.kind === 137 || property.kind === 138) { + if (property.kind === 138 || property.kind === 139) { var accessors = ts.getAllAccessorDeclarations(node.properties, property); if (property !== accessors.firstAccessor) { continue; @@ -22829,13 +23228,13 @@ var ts; emitMemberAccessForPropertyName(property.name); emitEnd(property.name); write(" = "); - if (property.kind === 225) { + if (property.kind === 227) { emit(property.initializer); } - else if (property.kind === 226) { + else if (property.kind === 228) { emitExpressionIdentifier(property.name); } - else if (property.kind === 135) { + else if (property.kind === 136) { emitFunctionDeclaration(property); } else { @@ -22867,7 +23266,7 @@ var ts; var numProperties = properties.length; var numInitialNonComputedProperties = numProperties; for (var i = 0, n = properties.length; i < n; i++) { - if (properties[i].name.kind === 128) { + if (properties[i].name.kind === 129) { numInitialNonComputedProperties = i; break; } @@ -22881,35 +23280,35 @@ var ts; emitObjectLiteralBody(node, properties.length); } function createBinaryExpression(left, operator, right, startsOnNewLine) { - var result = ts.createSynthesizedNode(170, startsOnNewLine); + var result = ts.createSynthesizedNode(172, startsOnNewLine); result.operatorToken = ts.createSynthesizedNode(operator); result.left = left; result.right = right; return result; } function createPropertyAccessExpression(expression, name) { - var result = ts.createSynthesizedNode(156); + var result = ts.createSynthesizedNode(158); result.expression = parenthesizeForAccess(expression); result.dotToken = ts.createSynthesizedNode(20); result.name = name; return result; } function createElementAccessExpression(expression, argumentExpression) { - var result = ts.createSynthesizedNode(157); + var result = ts.createSynthesizedNode(159); result.expression = parenthesizeForAccess(expression); result.argumentExpression = argumentExpression; return result; } function parenthesizeForAccess(expr) { - while (expr.kind === 161) { + while (expr.kind === 163) { expr = expr.expression; } if (ts.isLeftHandSideExpression(expr) && - expr.kind !== 159 && + expr.kind !== 161 && expr.kind !== 7) { return expr; } - var node = ts.createSynthesizedNode(162); + var node = ts.createSynthesizedNode(164); node.expression = expr; return node; } @@ -22922,32 +23321,26 @@ var ts; if (languageVersion >= 2 && node.asteriskToken) { write("*"); } - emit(node.name, false); + emit(node.name); if (languageVersion < 2) { write(": function "); } emitSignatureAndBody(node); } function emitPropertyAssignment(node) { - emit(node.name, false); + emit(node.name); write(": "); emit(node.initializer); } + function isNamespaceExportReference(node) { + var container = resolver.getReferencedExportContainer(node); + return container && container.kind !== 230; + } function emitShorthandPropertyAssignment(node) { - emit(node.name, false); - if (languageVersion < 2) { + writeTextOfNode(currentSourceFile, node.name); + if (languageVersion < 2 || isNamespaceExportReference(node.name)) { write(": "); - var generatedName = getGeneratedNameForIdentifier(node.name); - if (generatedName) { - write(generatedName); - } - else { - emitExpressionIdentifier(node.name); - } - } - else if (resolver.getExpressionNameSubstitution(node.name, getGeneratedNameForNode)) { - write(": "); - emitExpressionIdentifier(node.name); + emit(node.name); } } function tryEmitConstantValue(node) { @@ -22958,7 +23351,7 @@ var ts; if (constantValue !== undefined) { write(constantValue.toString()); if (!compilerOptions.removeComments) { - var propertyName = node.kind === 156 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + var propertyName = node.kind === 158 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); write(" /* " + propertyName + " */"); } return true; @@ -22988,7 +23381,7 @@ var ts; var indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, node.dotToken); write("."); var indentedAfterDot = indentIfOnDifferentLines(node, node.dotToken, node.name); - emit(node.name, false); + emit(node.name); decreaseIndentIf(indentedBeforeDot, indentedAfterDot); } function emitQualifiedName(node) { @@ -23006,10 +23399,10 @@ var ts; write("]"); } function hasSpreadElement(elements) { - return ts.forEach(elements, function (e) { return e.kind === 174; }); + return ts.forEach(elements, function (e) { return e.kind === 176; }); } function skipParentheses(node) { - while (node.kind === 162 || node.kind === 161) { + while (node.kind === 164 || node.kind === 163) { node = node.expression; } return node; @@ -23030,12 +23423,12 @@ var ts; function emitCallWithSpread(node) { var target; var expr = skipParentheses(node.expression); - if (expr.kind === 156) { + if (expr.kind === 158) { target = emitCallTarget(expr.expression); write("."); emit(expr.name); } - else if (expr.kind === 157) { + else if (expr.kind === 159) { target = emitCallTarget(expr.expression); write("["); emit(expr.argumentExpression); @@ -23076,7 +23469,7 @@ var ts; } else { emit(node.expression); - superCall = node.expression.kind === 156 && node.expression.expression.kind === 91; + superCall = node.expression.kind === 158 && node.expression.expression.kind === 91; } if (superCall && languageVersion < 2) { write(".call("); @@ -23127,20 +23520,20 @@ var ts; } } function emitParenExpression(node) { - if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 164) { - if (node.expression.kind === 161) { + if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 166) { + if (node.expression.kind === 163) { var operand = node.expression.expression; - while (operand.kind == 161) { + while (operand.kind === 163) { operand = operand.expression; } - if (operand.kind !== 168 && - operand.kind !== 167 && - operand.kind !== 166 && - operand.kind !== 165 && + if (operand.kind !== 170 && operand.kind !== 169 && - operand.kind !== 159 && - !(operand.kind === 158 && node.parent.kind === 159) && - !(operand.kind === 163 && node.parent.kind === 158)) { + operand.kind !== 168 && + operand.kind !== 167 && + operand.kind !== 171 && + operand.kind !== 161 && + !(operand.kind === 160 && node.parent.kind === 161) && + !(operand.kind === 165 && node.parent.kind === 160)) { emit(operand); return; } @@ -23169,7 +23562,7 @@ var ts; if (!isCurrentFileSystemExternalModule() || node.kind !== 65 || ts.nodeIsSynthesized(node)) { return false; } - var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 199 || node.parent.kind === 153); + var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 201 || node.parent.kind === 155); var targetDeclaration = isVariableDeclarationOrBindingElement ? node.parent : resolver.getReferencedValueDeclaration(node); @@ -23183,7 +23576,7 @@ var ts; write("\", "); } write(ts.tokenToString(node.operator)); - if (node.operand.kind === 168) { + if (node.operand.kind === 170) { var operand = node.operand; if (node.operator === 33 && (operand.operator === 33 || operand.operator === 38)) { write(" "); @@ -23226,10 +23619,10 @@ var ts; } var current = node; while (current) { - if (current.kind === 228) { + if (current.kind === 230) { return !isExported || ((ts.getCombinedNodeFlags(node) & 1) !== 0); } - else if (ts.isFunctionLike(current) || current.kind === 207) { + else if (ts.isFunctionLike(current) || current.kind === 209) { return false; } else { @@ -23239,8 +23632,8 @@ var ts; } function emitBinaryExpression(node) { if (languageVersion < 2 && node.operatorToken.kind === 53 && - (node.left.kind === 155 || node.left.kind === 154)) { - emitDestructuring(node, node.parent.kind === 183); + (node.left.kind === 157 || node.left.kind === 156)) { + emitDestructuring(node, node.parent.kind === 185); } else { var exportChanged = node.operatorToken.kind >= 53 && @@ -23287,7 +23680,7 @@ var ts; } } function isSingleLineEmptyBlock(node) { - if (node && node.kind === 180) { + if (node && node.kind === 182) { var block = node; return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); } @@ -23302,12 +23695,12 @@ var ts; emitToken(14, node.pos); increaseIndent(); scopeEmitStart(node.parent); - if (node.kind === 207) { - ts.Debug.assert(node.parent.kind === 206); + if (node.kind === 209) { + ts.Debug.assert(node.parent.kind === 208); emitCaptureThisForNodeIfNecessary(node.parent); } emitLines(node.statements); - if (node.kind === 207) { + if (node.kind === 209) { emitTempDeclarations(true); } decreaseIndent(); @@ -23316,7 +23709,7 @@ var ts; scopeEmitEnd(); } function emitEmbeddedStatement(node) { - if (node.kind === 180) { + if (node.kind === 182) { write(" "); emit(node); } @@ -23328,7 +23721,7 @@ var ts; } } function emitExpressionStatement(node) { - emitParenthesizedIf(node.expression, node.expression.kind === 164); + emitParenthesizedIf(node.expression, node.expression.kind === 166); write(";"); } function emitIfStatement(node) { @@ -23341,7 +23734,7 @@ var ts; if (node.elseStatement) { writeLine(); emitToken(76, node.thenStatement.end); - if (node.elseStatement.kind === 184) { + if (node.elseStatement.kind === 186) { write(" "); emit(node.elseStatement); } @@ -23353,7 +23746,7 @@ var ts; function emitDoStatement(node) { write("do"); emitEmbeddedStatement(node.statement); - if (node.statement.kind === 180) { + if (node.statement.kind === 182) { write(" "); } else { @@ -23422,7 +23815,7 @@ var ts; var endPos = emitToken(82, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer && node.initializer.kind === 200) { + if (node.initializer && node.initializer.kind === 202) { var variableDeclarationList = node.initializer; var startIsEmitted = tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); if (startIsEmitted) { @@ -23443,13 +23836,13 @@ var ts; emitEmbeddedStatement(node.statement); } function emitForInOrForOfStatement(node) { - if (languageVersion < 2 && node.kind === 189) { + if (languageVersion < 2 && node.kind === 191) { return emitDownLevelForOfStatement(node); } var endPos = emitToken(82, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); @@ -23459,7 +23852,7 @@ var ts; else { emit(node.initializer); } - if (node.kind === 188) { + if (node.kind === 190) { write(" in "); } else { @@ -23527,7 +23920,7 @@ var ts; increaseIndent(); var rhsIterationValue = createElementAccessExpression(rhsReference, counter); emitStart(node.initializer); - if (node.initializer.kind === 200) { + if (node.initializer.kind === 202) { write("var "); var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length > 0) { @@ -23549,7 +23942,7 @@ var ts; } else { var assignmentExpression = createBinaryExpression(node.initializer, 53, rhsIterationValue, false); - if (node.initializer.kind === 154 || node.initializer.kind === 155) { + if (node.initializer.kind === 156 || node.initializer.kind === 157) { emitDestructuring(assignmentExpression, true, undefined); } else { @@ -23558,7 +23951,7 @@ var ts; } emitEnd(node.initializer); write(";"); - if (node.statement.kind === 180) { + if (node.statement.kind === 182) { emitLines(node.statement.statements); } else { @@ -23570,7 +23963,7 @@ var ts; write("}"); } function emitBreakOrContinueStatement(node) { - emitToken(node.kind === 191 ? 66 : 71, node.pos); + emitToken(node.kind === 193 ? 66 : 71, node.pos); emitOptional(" ", node.label); write(";"); } @@ -23615,7 +24008,7 @@ var ts; ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); } function emitCaseOrDefaultClause(node) { - if (node.kind === 221) { + if (node.kind === 223) { write("case "); emit(node.expression); write(":"); @@ -23670,7 +24063,7 @@ var ts; function getContainingModule(node) { do { node = node.parent; - } while (node && node.kind !== 206); + } while (node && node.kind !== 208); return node; } function emitContainingModuleName(node) { @@ -23695,7 +24088,7 @@ var ts; function createVoidZero() { var zero = ts.createSynthesizedNode(7); zero.text = "0"; - var result = ts.createSynthesizedNode(167); + var result = ts.createSynthesizedNode(169); result.expression = zero; return result; } @@ -23764,15 +24157,15 @@ var ts; function emitDestructuring(root, isAssignmentExpressionStatement, value) { var emitCount = 0; var canDefineTempVariablesInPlace = false; - if (root.kind === 199) { + if (root.kind === 201) { var isExported = ts.getCombinedNodeFlags(root) & 1; var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root); canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind; } - else if (root.kind === 130) { + else if (root.kind === 131) { canDefineTempVariablesInPlace = true; } - if (root.kind === 170) { + if (root.kind === 172) { emitAssignmentExpression(root); } else { @@ -23783,8 +24176,7 @@ var ts; if (emitCount++) { write(", "); } - renameNonTopLevelLetAndConst(name); - var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 199 || name.parent.kind === 153); + var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 201 || name.parent.kind === 155); var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name); if (exportChanged) { write(exportFunctionForFile + "(\""); @@ -23816,14 +24208,14 @@ var ts; } function createDefaultValueCheck(value, defaultValue) { value = ensureIdentifier(value); - var equals = ts.createSynthesizedNode(170); + var equals = ts.createSynthesizedNode(172); equals.left = value; equals.operatorToken = ts.createSynthesizedNode(30); equals.right = createVoidZero(); return createConditionalExpression(equals, defaultValue, value); } function createConditionalExpression(condition, whenTrue, whenFalse) { - var cond = ts.createSynthesizedNode(171); + var cond = ts.createSynthesizedNode(173); cond.condition = condition; cond.questionToken = ts.createSynthesizedNode(50); cond.whenTrue = whenTrue; @@ -23837,13 +24229,15 @@ var ts; return node; } function createPropertyAccessForDestructuringProperty(object, propName) { - if (propName.kind !== 65) { - return createElementAccessExpression(object, propName); + var syntheticName = ts.createSynthesizedNode(propName.kind); + syntheticName.text = propName.text; + if (syntheticName.kind !== 65) { + return createElementAccessExpression(object, syntheticName); } - return createPropertyAccessExpression(object, propName); + return createPropertyAccessExpression(object, syntheticName); } function createSliceCall(value, sliceIndex) { - var call = ts.createSynthesizedNode(158); + var call = ts.createSynthesizedNode(160); var sliceIdentifier = ts.createSynthesizedNode(65); sliceIdentifier.text = "slice"; call.expression = createPropertyAccessExpression(value, sliceIdentifier); @@ -23858,8 +24252,8 @@ var ts; } for (var _a = 0; _a < properties.length; _a++) { var p = properties[_a]; - if (p.kind === 225 || p.kind === 226) { - var propName = (p.name); + if (p.kind === 227 || p.kind === 228) { + var propName = p.name; emitDestructuringAssignment(p.initializer || propName, createPropertyAccessForDestructuringProperty(value, propName)); } } @@ -23871,8 +24265,8 @@ var ts; } for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176) { - if (e.kind !== 174) { + if (e.kind !== 178) { + if (e.kind !== 176) { emitDestructuringAssignment(e, createElementAccessExpression(value, createNumericLiteral(i))); } else if (i === elements.length - 1) { @@ -23882,14 +24276,14 @@ var ts; } } function emitDestructuringAssignment(target, value) { - if (target.kind === 170 && target.operatorToken.kind === 53) { + if (target.kind === 172 && target.operatorToken.kind === 53) { value = createDefaultValueCheck(value, target.right); target = target.left; } - if (target.kind === 155) { + if (target.kind === 157) { emitObjectLiteralAssignment(target, value); } - else if (target.kind === 154) { + else if (target.kind === 156) { emitArrayLiteralAssignment(target, value); } else { @@ -23903,14 +24297,14 @@ var ts; emitDestructuringAssignment(target, value); } else { - if (root.parent.kind !== 162) { + if (root.parent.kind !== 164) { write("("); } value = ensureIdentifier(value); emitDestructuringAssignment(target, value); write(", "); emit(value); - if (root.parent.kind !== 162) { + if (root.parent.kind !== 164) { write(")"); } } @@ -23930,11 +24324,11 @@ var ts; } for (var i = 0; i < elements.length; i++) { var element = elements[i]; - if (pattern.kind === 151) { + if (pattern.kind === 153) { var propName = element.propertyName || element.name; emitBindingElement(element, createPropertyAccessForDestructuringProperty(value, propName)); } - else if (element.kind !== 176) { + else if (element.kind !== 178) { if (!element.dotDotDotToken) { emitBindingElement(element, createElementAccessExpression(value, createNumericLiteral(i))); } @@ -23960,14 +24354,13 @@ var ts; } } else { - renameNonTopLevelLetAndConst(node.name); var initializer = node.initializer; if (!initializer && languageVersion < 2) { var isUninitializedLet = (resolver.getNodeCheckFlags(node) & 256) && (getCombinedFlagsForIdentifier(node.name) & 4096); if (isUninitializedLet && - node.parent.parent.kind !== 188 && - node.parent.parent.kind !== 189) { + node.parent.parent.kind !== 190 && + node.parent.parent.kind !== 191) { initializer = createVoidZero(); } } @@ -23985,7 +24378,7 @@ var ts; } } function emitExportVariableAssignments(node) { - if (node.kind === 176) { + if (node.kind === 178) { return; } var name = node.name; @@ -23997,48 +24390,15 @@ var ts; } } function getCombinedFlagsForIdentifier(node) { - if (!node.parent || (node.parent.kind !== 199 && node.parent.kind !== 153)) { + if (!node.parent || (node.parent.kind !== 201 && node.parent.kind !== 155)) { return 0; } return ts.getCombinedNodeFlags(node.parent); } - function renameNonTopLevelLetAndConst(node) { - if (languageVersion >= 2 || - ts.nodeIsSynthesized(node) || - node.kind !== 65 || - (node.parent.kind !== 199 && node.parent.kind !== 153)) { - return; - } - var combinedFlags = getCombinedFlagsForIdentifier(node); - if (((combinedFlags & 12288) === 0) || combinedFlags & 1) { - return; - } - var list = ts.getAncestor(node, 200); - if (list.parent.kind === 181) { - var isSourceFileLevelBinding = list.parent.parent.kind === 228; - var isModuleLevelBinding = list.parent.parent.kind === 207; - var isFunctionLevelBinding = list.parent.parent.kind === 180 && ts.isFunctionLike(list.parent.parent.parent); - if (isSourceFileLevelBinding || isModuleLevelBinding || isFunctionLevelBinding) { - return; - } - } - var blockScopeContainer = ts.getEnclosingBlockScopeContainer(node); - var parent = blockScopeContainer.kind === 228 - ? blockScopeContainer - : blockScopeContainer.parent; - if (resolver.resolvesToSomeValue(parent, node.text)) { - var variableId = resolver.getBlockScopedVariableId(node); - if (!blockScopedVariableToGeneratedName) { - blockScopedVariableToGeneratedName = []; - } - var generatedName = makeUniqueName(node.text); - blockScopedVariableToGeneratedName[variableId] = generatedName; - } - } function isES6ExportedDeclaration(node) { return !!(node.flags & 1) && languageVersion >= 2 && - node.parent.kind === 228; + node.parent.kind === 230; } function emitVariableStatement(node) { var startIsEmitted = false; @@ -24083,12 +24443,12 @@ var ts; function emitParameter(node) { if (languageVersion < 2) { if (ts.isBindingPattern(node.name)) { - var name_23 = createTempVariable(0); + var name_20 = createTempVariable(0); if (!tempParameters) { tempParameters = []; } - tempParameters.push(name_23); - emit(name_23); + tempParameters.push(name_20); + emit(name_20); } else { emit(node.name); @@ -24176,12 +24536,12 @@ var ts; } } function emitAccessor(node) { - write(node.kind === 137 ? "get " : "set "); - emit(node.name, false); + write(node.kind === 138 ? "get " : "set "); + emit(node.name); emitSignatureAndBody(node); } function shouldEmitAsArrowFunction(node) { - return node.kind === 164 && languageVersion >= 2; + return node.kind === 166 && languageVersion >= 2; } function emitDeclarationName(node) { if (node.name) { @@ -24192,10 +24552,10 @@ var ts; } } function shouldEmitFunctionName(node) { - if (node.kind === 163) { + if (node.kind === 165) { return !!node.name; } - if (node.kind === 201) { + if (node.kind === 203) { return !!node.name || languageVersion < 2; } } @@ -24203,7 +24563,7 @@ var ts; if (ts.nodeIsMissing(node.body)) { return emitOnlyPinnedOrTripleSlashComments(node); } - if (node.kind !== 135 && node.kind !== 134) { + if (node.kind !== 136 && node.kind !== 135) { emitLeadingComments(node); } if (!shouldEmitAsArrowFunction(node)) { @@ -24223,10 +24583,10 @@ var ts; emitDeclarationName(node); } emitSignatureAndBody(node); - if (languageVersion < 2 && node.kind === 201 && node.parent === currentSourceFile && node.name) { + if (languageVersion < 2 && node.kind === 203 && node.parent === currentSourceFile && node.name) { emitExportMemberAssignments(node.name); } - if (node.kind !== 135 && node.kind !== 134) { + if (node.kind !== 136 && node.kind !== 135) { emitTrailingComments(node); } } @@ -24273,7 +24633,7 @@ var ts; if (!node.body) { write(" { }"); } - else if (node.body.kind === 180) { + else if (node.body.kind === 182) { emitBlockFunctionBody(node, node.body); } else { @@ -24298,10 +24658,10 @@ var ts; } write(" "); var current = body; - while (current.kind === 161) { + while (current.kind === 163) { current = current.expression; } - emitParenthesizedIf(body, current.kind === 155); + emitParenthesizedIf(body, current.kind === 157); } function emitDownLevelExpressionFunctionBody(node, body) { write(" {"); @@ -24373,9 +24733,9 @@ var ts; function findInitialSuperCall(ctor) { if (ctor.body) { var statement = ctor.body.statements[0]; - if (statement && statement.kind === 183) { + if (statement && statement.kind === 185) { var expr = statement.expression; - if (expr && expr.kind === 158) { + if (expr && expr.kind === 160) { var func = expr.expression; if (func && func.kind === 91) { return statement; @@ -24406,7 +24766,7 @@ var ts; emitNodeWithoutSourceMap(memberName); write("]"); } - else if (memberName.kind === 128) { + else if (memberName.kind === 129) { emitComputedPropertyName(memberName); } else { @@ -24418,7 +24778,7 @@ var ts; var properties = []; for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if (member.kind === 133 && isStatic === ((member.flags & 128) !== 0) && member.initializer) { + if (member.kind === 134 && isStatic === ((member.flags & 128) !== 0) && member.initializer) { properties.push(member); } } @@ -24458,11 +24818,11 @@ var ts; } function emitMemberFunctionsForES5AndLower(node) { ts.forEach(node.members, function (member) { - if (member.kind === 179) { + if (member.kind === 181) { writeLine(); write(";"); } - else if (member.kind === 135 || node.kind === 134) { + else if (member.kind === 136 || node.kind === 135) { if (!member.body) { return emitOnlyPinnedOrTripleSlashComments(member); } @@ -24481,7 +24841,7 @@ var ts; write(";"); emitTrailingComments(member); } - else if (member.kind === 137 || member.kind === 138) { + else if (member.kind === 138 || member.kind === 139) { var accessors = ts.getAllAccessorDeclarations(node.members, member); if (member === accessors.firstAccessor) { writeLine(); @@ -24531,22 +24891,22 @@ var ts; function emitMemberFunctionsForES6AndHigher(node) { for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if ((member.kind === 135 || node.kind === 134) && !member.body) { + if ((member.kind === 136 || node.kind === 135) && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } - else if (member.kind === 135 || - member.kind === 137 || - member.kind === 138) { + else if (member.kind === 136 || + member.kind === 138 || + member.kind === 139) { writeLine(); emitLeadingComments(member); emitStart(member); if (member.flags & 128) { write("static "); } - if (member.kind === 137) { + if (member.kind === 138) { write("get "); } - else if (member.kind === 138) { + else if (member.kind === 139) { write("set "); } if (member.asteriskToken) { @@ -24557,7 +24917,7 @@ var ts; emitEnd(member); emitTrailingComments(member); } - else if (member.kind === 179) { + else if (member.kind === 181) { writeLine(); write(";"); } @@ -24578,10 +24938,10 @@ var ts; function emitConstructorWorker(node, baseTypeElement) { var hasInstancePropertyWithInitializer = false; ts.forEach(node.members, function (member) { - if (member.kind === 136 && !member.body) { + if (member.kind === 137 && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } - if (member.kind === 133 && member.initializer && (member.flags & 128) === 0) { + if (member.kind === 134 && member.initializer && (member.flags & 128) === 0) { hasInstancePropertyWithInitializer = true; } }); @@ -24681,7 +25041,7 @@ var ts; } function emitClassLikeDeclarationForES6AndHigher(node) { var thisNodeIsDecorated = ts.nodeIsDecorated(node); - if (node.kind === 202) { + if (node.kind === 204) { if (thisNodeIsDecorated) { if (isES6ExportedDeclaration(node) && !(node.flags & 256)) { write("export "); @@ -24698,7 +25058,7 @@ var ts; } } var staticProperties = getInitializedProperties(node, true); - var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 175; + var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 177; var tempVariable; if (isClassExpressionWithStaticProperties) { tempVariable = createAndRecordTempVariable(0); @@ -24765,7 +25125,7 @@ var ts; } } function emitClassLikeDeclarationBelowES6(node) { - if (node.kind === 202) { + if (node.kind === 204) { if (!shouldHoistDeclarationInSystemJsModule(node)) { write("var "); } @@ -24823,11 +25183,11 @@ var ts; emit(baseTypeNode.expression); } write(")"); - if (node.kind === 202) { + if (node.kind === 204) { write(";"); } emitEnd(node); - if (node.kind === 202) { + if (node.kind === 204) { emitExportMemberAssignment(node); } if (languageVersion < 2 && node.parent === currentSourceFile && node.name) { @@ -24901,13 +25261,13 @@ var ts; } else { decorators = member.decorators; - if (member.kind === 135) { + if (member.kind === 136) { functionLikeMember = member; } } writeLine(); emitStart(member); - if (member.kind !== 133) { + if (member.kind !== 134) { write("Object.defineProperty("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -24937,7 +25297,7 @@ var ts; write(", "); emitExpressionForPropertyName(member.name); emitEnd(member.name); - if (member.kind !== 133) { + if (member.kind !== 134) { write(", Object.getOwnPropertyDescriptor("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -24976,26 +25336,26 @@ var ts; } function shouldEmitTypeMetadata(node) { switch (node.kind) { - case 135: - case 137: + case 136: case 138: - case 133: + case 139: + case 134: return true; } return false; } function shouldEmitReturnTypeMetadata(node) { switch (node.kind) { - case 135: + case 136: return true; } return false; } function shouldEmitParamTypesMetadata(node) { switch (node.kind) { - case 202: - case 135: - case 138: + case 204: + case 136: + case 139: return true; } return false; @@ -25004,7 +25364,7 @@ var ts; var argumentsWritten = 0; if (compilerOptions.emitDecoratorMetadata) { if (shouldEmitTypeMetadata(node)) { - var serializedType = resolver.serializeTypeOfNode(node, getGeneratedNameForNode); + var serializedType = resolver.serializeTypeOfNode(node); if (serializedType) { if (writeComma) { write(", "); @@ -25017,7 +25377,7 @@ var ts; } } if (shouldEmitParamTypesMetadata(node)) { - var serializedTypes = resolver.serializeParameterTypesOfNode(node, getGeneratedNameForNode); + var serializedTypes = resolver.serializeParameterTypesOfNode(node); if (serializedTypes) { if (writeComma || argumentsWritten) { write(", "); @@ -25035,7 +25395,7 @@ var ts; } } if (shouldEmitReturnTypeMetadata(node)) { - var serializedType = resolver.serializeReturnTypeOfNode(node, getGeneratedNameForNode); + var serializedType = resolver.serializeReturnTypeOfNode(node); if (serializedType) { if (writeComma || argumentsWritten) { write(", "); @@ -25165,7 +25525,7 @@ var ts; } } function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { - if (moduleDeclaration.body.kind === 206) { + if (moduleDeclaration.body.kind === 208) { var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); return recursiveInnerModule || moduleDeclaration.body; } @@ -25200,7 +25560,7 @@ var ts; write(getGeneratedNameForNode(node)); emitEnd(node.name); write(") "); - if (node.body.kind === 207) { + if (node.body.kind === 209) { var saveTempFlags = tempFlags; var saveTempVariables = tempVariables; tempFlags = 0; @@ -25257,16 +25617,16 @@ var ts; } } function getNamespaceDeclarationNode(node) { - if (node.kind === 209) { + if (node.kind === 211) { return node; } var importClause = node.importClause; - if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 212) { + if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 214) { return importClause.namedBindings; } } function isDefaultImport(node) { - return node.kind === 210 && node.importClause && !!node.importClause.name; + return node.kind === 212 && node.importClause && !!node.importClause.name; } function emitExportImportAssignments(node) { if (ts.isAliasSymbolDeclaration(node) && resolver.isValueAliasDeclaration(node)) { @@ -25293,7 +25653,7 @@ var ts; if (shouldEmitNamedBindings) { emitLeadingComments(node.importClause.namedBindings); emitStart(node.importClause.namedBindings); - if (node.importClause.namedBindings.kind === 212) { + if (node.importClause.namedBindings.kind === 214) { write("* as "); emit(node.importClause.namedBindings.name); } @@ -25319,7 +25679,7 @@ var ts; } function emitExternalImportDeclaration(node) { if (ts.contains(externalImports, node)) { - var isExportedImport = node.kind === 209 && (node.flags & 1) !== 0; + var isExportedImport = node.kind === 211 && (node.flags & 1) !== 0; var namespaceDeclaration = getNamespaceDeclarationNode(node); if (compilerOptions.module !== 2) { emitLeadingComments(node); @@ -25331,7 +25691,7 @@ var ts; write(" = "); } else { - var isNakedImport = 210 && !node.importClause; + var isNakedImport = 212 && !node.importClause; if (!isNakedImport) { write("var "); write(getGeneratedNameForNode(node)); @@ -25487,8 +25847,8 @@ var ts; write("export default "); var expression = node.expression; emit(expression); - if (expression.kind !== 201 && - expression.kind !== 202) { + if (expression.kind !== 203 && + expression.kind !== 204) { write(";"); } emitEnd(node); @@ -25524,18 +25884,18 @@ var ts; for (var _a = 0, _b = sourceFile.statements; _a < _b.length; _a++) { var node = _b[_a]; switch (node.kind) { - case 210: + case 212: if (!node.importClause || resolver.isReferencedAliasDeclaration(node.importClause, true)) { externalImports.push(node); } break; - case 209: - if (node.moduleReference.kind === 220 && resolver.isReferencedAliasDeclaration(node)) { + case 211: + if (node.moduleReference.kind === 222 && resolver.isReferencedAliasDeclaration(node)) { externalImports.push(node); } break; - case 216: + case 218: if (node.moduleSpecifier) { if (!node.exportClause) { externalImports.push(node); @@ -25548,12 +25908,12 @@ var ts; else { for (var _c = 0, _d = node.exportClause.elements; _c < _d.length; _c++) { var specifier = _d[_c]; - var name_24 = (specifier.propertyName || specifier.name).text; - (exportSpecifiers[name_24] || (exportSpecifiers[name_24] = [])).push(specifier); + var name_21 = (specifier.propertyName || specifier.name).text; + (exportSpecifiers[name_21] || (exportSpecifiers[name_21] = [])).push(specifier); } } break; - case 215: + case 217: if (node.isExportEquals && !exportEquals) { exportEquals = node; } @@ -25573,13 +25933,16 @@ var ts; write("}"); } } - function getLocalNameForExternalImport(importNode) { - var namespaceDeclaration = getNamespaceDeclarationNode(importNode); - if (namespaceDeclaration && !isDefaultImport(importNode)) { + function getLocalNameForExternalImport(node) { + var namespaceDeclaration = getNamespaceDeclarationNode(node); + if (namespaceDeclaration && !isDefaultImport(node)) { return ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, namespaceDeclaration.name); } - else { - return getGeneratedNameForNode(importNode); + if (node.kind === 212 && node.importClause) { + return getGeneratedNameForNode(node); + } + if (node.kind === 218 && node.moduleSpecifier) { + return getGeneratedNameForNode(node); } } function getExternalModuleNameText(importNode) { @@ -25597,8 +25960,8 @@ var ts; var started = false; for (var _a = 0; _a < externalImports.length; _a++) { var importNode = externalImports[_a]; - var skipNode = importNode.kind === 216 || - (importNode.kind === 210 && !importNode.importClause); + var skipNode = importNode.kind === 218 || + (importNode.kind === 212 && !importNode.importClause); if (skipNode) { continue; } @@ -25623,7 +25986,7 @@ var ts; var hasExportDeclarationWithExportClause = false; for (var _a = 0; _a < externalImports.length; _a++) { var externalImport = externalImports[_a]; - if (externalImport.kind === 216 && externalImport.exportClause) { + if (externalImport.kind === 218 && externalImport.exportClause) { hasExportDeclarationWithExportClause = true; break; } @@ -25652,7 +26015,7 @@ var ts; } for (var _d = 0; _d < externalImports.length; _d++) { var externalImport = externalImports[_d]; - if (externalImport.kind !== 216) { + if (externalImport.kind !== 218) { continue; } var exportDecl = externalImport; @@ -25722,11 +26085,11 @@ var ts; var seen = {}; for (var i = 0; i < hoistedVars.length; ++i) { var local = hoistedVars[i]; - var name_25 = local.kind === 65 + var name_22 = local.kind === 65 ? local : local.name; - if (name_25) { - var text = ts.unescapeIdentifier(name_25.text); + if (name_22) { + var text = ts.unescapeIdentifier(name_22.text); if (ts.hasProperty(seen, text)) { continue; } @@ -25737,7 +26100,7 @@ var ts; if (i !== 0) { write(", "); } - if (local.kind === 202 || local.kind === 206 || local.kind === 205) { + if (local.kind === 204 || local.kind === 208 || local.kind === 207) { emitDeclarationName(local); } else { @@ -25771,21 +26134,21 @@ var ts; if (node.flags & 2) { return; } - if (node.kind === 201) { + if (node.kind === 203) { if (!hoistedFunctionDeclarations) { hoistedFunctionDeclarations = []; } hoistedFunctionDeclarations.push(node); return; } - if (node.kind === 202) { + if (node.kind === 204) { if (!hoistedVars) { hoistedVars = []; } hoistedVars.push(node); return; } - if (node.kind === 205) { + if (node.kind === 207) { if (shouldEmitEnumDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; @@ -25794,7 +26157,7 @@ var ts; } return; } - if (node.kind === 206) { + if (node.kind === 208) { if (shouldEmitModuleDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; @@ -25803,17 +26166,17 @@ var ts; } return; } - if (node.kind === 199 || node.kind === 153) { + if (node.kind === 201 || node.kind === 155) { if (shouldHoistVariable(node, false)) { - var name_26 = node.name; - if (name_26.kind === 65) { + var name_23 = node.name; + if (name_23.kind === 65) { if (!hoistedVars) { hoistedVars = []; } - hoistedVars.push(name_26); + hoistedVars.push(name_23); } else { - ts.forEachChild(name_26, visit); + ts.forEachChild(name_23, visit); } } return; @@ -25832,7 +26195,7 @@ var ts; return false; } return (ts.getCombinedNodeFlags(node) & 12288) === 0 || - ts.getEnclosingBlockScopeContainer(node).kind === 228; + ts.getEnclosingBlockScopeContainer(node).kind === 230; } function isCurrentFileSystemExternalModule() { return compilerOptions.module === 4 && ts.isExternalModule(currentSourceFile); @@ -25849,10 +26212,10 @@ var ts; emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(true); decreaseIndent(); writeLine(); write("}"); + emitTempDeclarations(true); } function emitSetters(exportStarFunction) { write("setters:["); @@ -25867,27 +26230,27 @@ var ts; var parameterName = "_" + importVariableName; write("function (" + parameterName + ") {"); switch (importNode.kind) { - case 210: + case 212: if (!importNode.importClause) { break; } - case 209: + case 211: ts.Debug.assert(importVariableName !== ""); increaseIndent(); writeLine(); write(importVariableName + " = " + parameterName + ";"); writeLine(); - var defaultName = importNode.kind === 210 + var defaultName = importNode.kind === 212 ? importNode.importClause.name : importNode.name; if (defaultName) { emitExportMemberAssignments(defaultName); writeLine(); } - if (importNode.kind === 210 && + if (importNode.kind === 212 && importNode.importClause.namedBindings) { var namedBindings = importNode.importClause.namedBindings; - if (namedBindings.kind === 212) { + if (namedBindings.kind === 214) { emitExportMemberAssignments(namedBindings.name); writeLine(); } @@ -25901,7 +26264,7 @@ var ts; } decreaseIndent(); break; - case 216: + case 218: ts.Debug.assert(importVariableName !== ""); increaseIndent(); if (importNode.exportClause) { @@ -25935,10 +26298,10 @@ var ts; for (var i = startIndex; i < node.statements.length; ++i) { var statement = node.statements[i]; switch (statement.kind) { - case 216: - case 210: - case 209: - case 201: + case 218: + case 212: + case 211: + case 203: continue; } writeLine(); @@ -25952,7 +26315,11 @@ var ts; collectExternalModuleInfo(node); ts.Debug.assert(!exportFunctionForFile); exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); + } + write("["); for (var i = 0; i < externalImports.length; ++i) { var text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -26025,8 +26392,8 @@ var ts; collectExternalModuleInfo(node); writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, true); write(") {"); @@ -26155,7 +26522,7 @@ var ts; } emitLeadingComments(node.endOfFileToken); } - function emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers) { + function emitNodeWithoutSourceMap(node) { if (!node) { return; } @@ -26166,48 +26533,47 @@ var ts; if (emitComments) { emitLeadingComments(node); } - emitJavaScriptWorker(node, allowGeneratedIdentifiers); + emitJavaScriptWorker(node); if (emitComments) { emitTrailingComments(node); } } function shouldEmitLeadingAndTrailingComments(node) { switch (node.kind) { - case 203: - case 201: - case 210: - case 209: - case 204: - case 215: - return false; - case 181: - return shouldEmitLeadingAndTrailingCommentsForVariableStatement(node); - case 206: - return shouldEmitModuleDeclaration(node); case 205: + case 203: + case 212: + case 211: + case 206: + case 217: + return false; + case 183: + return shouldEmitLeadingAndTrailingCommentsForVariableStatement(node); + case 208: + return shouldEmitModuleDeclaration(node); + case 207: return shouldEmitEnumDeclaration(node); } - if (node.kind !== 180 && + if (node.kind !== 182 && node.parent && - node.parent.kind === 164 && + node.parent.kind === 166 && node.parent.body === node && compilerOptions.target <= 1) { return false; } return true; } - function emitJavaScriptWorker(node, allowGeneratedIdentifiers) { - if (allowGeneratedIdentifiers === void 0) { allowGeneratedIdentifiers = true; } + function emitJavaScriptWorker(node) { switch (node.kind) { case 65: - return emitIdentifier(node, allowGeneratedIdentifiers); - case 130: + return emitIdentifier(node); + case 131: return emitParameter(node); + case 136: case 135: - case 134: return emitMethod(node); - case 137: case 138: + case 139: return emitAccessor(node); case 93: return emitThis(node); @@ -26227,131 +26593,131 @@ var ts; case 12: case 13: return emitLiteral(node); - case 172: - return emitTemplateExpression(node); - case 178: - return emitTemplateSpan(node); - case 127: - return emitQualifiedName(node); - case 151: - return emitObjectBindingPattern(node); - case 152: - return emitArrayBindingPattern(node); - case 153: - return emitBindingElement(node); - case 154: - return emitArrayLiteral(node); - case 155: - return emitObjectLiteral(node); - case 225: - return emitPropertyAssignment(node); - case 226: - return emitShorthandPropertyAssignment(node); - case 128: - return emitComputedPropertyName(node); - case 156: - return emitPropertyAccess(node); - case 157: - return emitIndexedAccess(node); - case 158: - return emitCallExpression(node); - case 159: - return emitNewExpression(node); - case 160: - return emitTaggedTemplateExpression(node); - case 161: - return emit(node.expression); - case 162: - return emitParenExpression(node); - case 201: - case 163: - case 164: - return emitFunctionDeclaration(node); - case 165: - return emitDeleteExpression(node); - case 166: - return emitTypeOfExpression(node); - case 167: - return emitVoidExpression(node); - case 168: - return emitPrefixUnaryExpression(node); - case 169: - return emitPostfixUnaryExpression(node); - case 170: - return emitBinaryExpression(node); - case 171: - return emitConditionalExpression(node); case 174: - return emitSpreadElementExpression(node); - case 173: - return emitYieldExpression(node); - case 176: - return; + return emitTemplateExpression(node); case 180: - case 207: - return emitBlock(node); - case 181: - return emitVariableStatement(node); - case 182: - return write(";"); - case 183: - return emitExpressionStatement(node); - case 184: - return emitIfStatement(node); - case 185: - return emitDoStatement(node); - case 186: - return emitWhileStatement(node); - case 187: - return emitForStatement(node); - case 189: - case 188: - return emitForInOrForOfStatement(node); - case 190: - case 191: - return emitBreakOrContinueStatement(node); - case 192: - return emitReturnStatement(node); - case 193: - return emitWithStatement(node); - case 194: - return emitSwitchStatement(node); - case 221: - case 222: - return emitCaseOrDefaultClause(node); - case 195: - return emitLabelledStatement(node); - case 196: - return emitThrowStatement(node); - case 197: - return emitTryStatement(node); - case 224: - return emitCatchClause(node); - case 198: - return emitDebuggerStatement(node); - case 199: - return emitVariableDeclaration(node); - case 175: - return emitClassExpression(node); - case 202: - return emitClassDeclaration(node); - case 203: - return emitInterfaceDeclaration(node); - case 205: - return emitEnumDeclaration(node); + return emitTemplateSpan(node); + case 128: + return emitQualifiedName(node); + case 153: + return emitObjectBindingPattern(node); + case 154: + return emitArrayBindingPattern(node); + case 155: + return emitBindingElement(node); + case 156: + return emitArrayLiteral(node); + case 157: + return emitObjectLiteral(node); case 227: - return emitEnumMember(node); - case 206: - return emitModuleDeclaration(node); - case 210: - return emitImportDeclaration(node); - case 209: - return emitImportEqualsDeclaration(node); - case 216: - return emitExportDeclaration(node); - case 215: - return emitExportAssignment(node); + return emitPropertyAssignment(node); case 228: + return emitShorthandPropertyAssignment(node); + case 129: + return emitComputedPropertyName(node); + case 158: + return emitPropertyAccess(node); + case 159: + return emitIndexedAccess(node); + case 160: + return emitCallExpression(node); + case 161: + return emitNewExpression(node); + case 162: + return emitTaggedTemplateExpression(node); + case 163: + return emit(node.expression); + case 164: + return emitParenExpression(node); + case 203: + case 165: + case 166: + return emitFunctionDeclaration(node); + case 167: + return emitDeleteExpression(node); + case 168: + return emitTypeOfExpression(node); + case 169: + return emitVoidExpression(node); + case 170: + return emitPrefixUnaryExpression(node); + case 171: + return emitPostfixUnaryExpression(node); + case 172: + return emitBinaryExpression(node); + case 173: + return emitConditionalExpression(node); + case 176: + return emitSpreadElementExpression(node); + case 175: + return emitYieldExpression(node); + case 178: + return; + case 182: + case 209: + return emitBlock(node); + case 183: + return emitVariableStatement(node); + case 184: + return write(";"); + case 185: + return emitExpressionStatement(node); + case 186: + return emitIfStatement(node); + case 187: + return emitDoStatement(node); + case 188: + return emitWhileStatement(node); + case 189: + return emitForStatement(node); + case 191: + case 190: + return emitForInOrForOfStatement(node); + case 192: + case 193: + return emitBreakOrContinueStatement(node); + case 194: + return emitReturnStatement(node); + case 195: + return emitWithStatement(node); + case 196: + return emitSwitchStatement(node); + case 223: + case 224: + return emitCaseOrDefaultClause(node); + case 197: + return emitLabelledStatement(node); + case 198: + return emitThrowStatement(node); + case 199: + return emitTryStatement(node); + case 226: + return emitCatchClause(node); + case 200: + return emitDebuggerStatement(node); + case 201: + return emitVariableDeclaration(node); + case 177: + return emitClassExpression(node); + case 204: + return emitClassDeclaration(node); + case 205: + return emitInterfaceDeclaration(node); + case 207: + return emitEnumDeclaration(node); + case 229: + return emitEnumMember(node); + case 208: + return emitModuleDeclaration(node); + case 212: + return emitImportDeclaration(node); + case 211: + return emitImportEqualsDeclaration(node); + case 218: + return emitExportDeclaration(node); + case 217: + return emitExportAssignment(node); + case 230: return emitSourceFileNode(node); } } @@ -26379,7 +26745,7 @@ var ts; } function getLeadingCommentsToEmit(node) { if (node.parent) { - if (node.parent.kind === 228 || node.pos !== node.parent.pos) { + if (node.parent.kind === 230 || node.pos !== node.parent.pos) { if (hasDetachedComments(node.pos)) { return getLeadingCommentsWithoutDetachedComments(); } @@ -26391,7 +26757,7 @@ var ts; } function getTrailingCommentsToEmit(node) { if (node.parent) { - if (node.parent.kind === 228 || node.end !== node.parent.end) { + if (node.parent.kind === 230 || node.end !== node.parent.end) { return ts.getTrailingCommentRanges(currentSourceFile.text, node.end); } } @@ -26569,7 +26935,7 @@ var ts; } ts.createCompilerHost = createCompilerHost; function getPreEmitDiagnostics(program, sourceFile) { - var diagnostics = program.getSyntacticDiagnostics(sourceFile).concat(program.getGlobalDiagnostics()).concat(program.getSemanticDiagnostics(sourceFile)); + var diagnostics = program.getOptionsDiagnostics().concat(program.getSyntacticDiagnostics(sourceFile), program.getGlobalDiagnostics(), program.getSemanticDiagnostics(sourceFile)); if (program.getCompilerOptions().declaration) { diagnostics.concat(program.getDeclarationDiagnostics(sourceFile)); } @@ -26602,16 +26968,17 @@ var ts; function createProgram(rootNames, options, host) { var program; var files = []; - var filesByName = {}; var diagnostics = ts.createDiagnosticCollection(); - var seenNoDefaultLib = options.noLib; var commonSourceDirectory; var diagnosticsProducingTypeChecker; var noDiagnosticsTypeChecker; + var classifiableNames; + var skipDefaultLib = options.noLib; var start = new Date().getTime(); host = host || createCompilerHost(options); + var filesByName = ts.createFileMap(function (fileName) { return host.getCanonicalFileName(fileName); }); ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); - if (!seenNoDefaultLib) { + if (!skipDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); } verifyCompilerOptions(); @@ -26621,11 +26988,12 @@ var ts; getSourceFiles: function () { return files; }, getCompilerOptions: function () { return options; }, getSyntacticDiagnostics: getSyntacticDiagnostics, + getOptionsDiagnostics: getOptionsDiagnostics, getGlobalDiagnostics: getGlobalDiagnostics, getSemanticDiagnostics: getSemanticDiagnostics, getDeclarationDiagnostics: getDeclarationDiagnostics, - getCompilerOptionsDiagnostics: getCompilerOptionsDiagnostics, getTypeChecker: getTypeChecker, + getClassifiableNames: getClassifiableNames, getDiagnosticsProducingTypeChecker: getDiagnosticsProducingTypeChecker, getCommonSourceDirectory: function () { return commonSourceDirectory; }, emit: emit, @@ -26636,6 +27004,17 @@ var ts; getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); } }; return program; + function getClassifiableNames() { + if (!classifiableNames) { + getTypeChecker(); + classifiableNames = {}; + for (var _i = 0; _i < files.length; _i++) { + var sourceFile = files[_i]; + ts.copyMap(sourceFile.classifiableNames, classifiableNames); + } + } + return classifiableNames; + } function getEmitHost(writeFileCallback) { return { getCanonicalFileName: function (fileName) { return host.getCanonicalFileName(fileName); }, @@ -26665,8 +27044,7 @@ var ts; return emitResult; } function getSourceFile(fileName) { - fileName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile, getDiagnostics) { if (sourceFile) { @@ -26705,16 +27083,14 @@ var ts; return ts.getDeclarationDiagnostics(getEmitHost(writeFile), resolver, sourceFile); } } - function getCompilerOptionsDiagnostics() { + function getOptionsDiagnostics() { var allDiagnostics = []; ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); return ts.sortAndDeduplicateDiagnostics(allDiagnostics); } function getGlobalDiagnostics() { - var typeChecker = getDiagnosticsProducingTypeChecker(); var allDiagnostics = []; - ts.addRange(allDiagnostics, typeChecker.getGlobalDiagnostics()); - ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); + ts.addRange(allDiagnostics, getDiagnosticsProducingTypeChecker().getGlobalDiagnostics()); return ts.sortAndDeduplicateDiagnostics(allDiagnostics); } function hasExtension(fileName) { @@ -26748,14 +27124,17 @@ var ts; } } else { - if (options.allowNonTsExtensions && !findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd)) { - diagnostic = ts.Diagnostics.File_0_not_found; - diagnosticArgument = [fileName]; - } - else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, isDefaultLib, refFile, refPos, refEnd); })) { - diagnostic = ts.Diagnostics.File_0_not_found; - fileName += ".ts"; - diagnosticArgument = [fileName]; + var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd); + if (!nonTsFile) { + if (options.allowNonTsExtensions) { + diagnostic = ts.Diagnostics.File_0_not_found; + diagnosticArgument = [fileName]; + } + else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, isDefaultLib, refFile, refPos, refEnd); })) { + diagnostic = ts.Diagnostics.File_0_not_found; + fileName += ".ts"; + diagnosticArgument = [fileName]; + } } } if (diagnostic) { @@ -26769,16 +27148,16 @@ var ts; } function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - if (ts.hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { return getSourceFileFromCache(fileName, canonicalName, false); } else { var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } - var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } @@ -26786,15 +27165,17 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { - seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; - filesByName[canonicalAbsolutePath] = file; + skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); processReferencedFiles(file, basePath); processImportedModules(file, basePath); } if (isDefaultLib) { + file.isDefaultLib = true; files.unshift(file); } else { @@ -26804,7 +27185,7 @@ var ts; return file; } function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { - var file = filesByName[canonicalName]; + var file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { @@ -26822,7 +27203,7 @@ var ts; } function processImportedModules(file, basePath) { ts.forEach(file.statements, function (node) { - if (node.kind === 210 || node.kind === 209 || node.kind === 216) { + if (node.kind === 212 || node.kind === 211 || node.kind === 218) { var moduleNameExpr = ts.getExternalModuleName(node); if (moduleNameExpr && moduleNameExpr.kind === 8) { var moduleNameText = moduleNameExpr.text; @@ -26843,7 +27224,7 @@ var ts; } } } - else if (node.kind === 206 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { + else if (node.kind === 208 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { ts.forEachChild(node.body, function (node) { if (ts.isExternalModuleImportEqualsDeclaration(node) && ts.getExternalModuleImportEqualsDeclarationExpression(node).kind === 8) { @@ -27038,98 +27419,98 @@ var ts; function spanInNode(node) { if (node) { if (ts.isExpression(node)) { - if (node.parent.kind === 185) { + if (node.parent.kind === 187) { return spanInPreviousNode(node); } - if (node.parent.kind === 187) { + if (node.parent.kind === 189) { return textSpan(node); } - if (node.parent.kind === 170 && node.parent.operatorToken.kind === 23) { + if (node.parent.kind === 172 && node.parent.operatorToken.kind === 23) { return textSpan(node); } - if (node.parent.kind == 164 && node.parent.body == node) { + if (node.parent.kind === 166 && node.parent.body === node) { return textSpan(node); } } switch (node.kind) { - case 181: + case 183: return spanInVariableDeclaration(node.declarationList.declarations[0]); - case 199: - case 133: - case 132: - return spanInVariableDeclaration(node); - case 130: - return spanInParameterDeclaration(node); case 201: - case 135: case 134: - case 137: - case 138: + case 133: + return spanInVariableDeclaration(node); + case 131: + return spanInParameterDeclaration(node); + case 203: case 136: - case 163: - case 164: + case 135: + case 138: + case 139: + case 137: + case 165: + case 166: return spanInFunctionDeclaration(node); - case 180: + case 182: if (ts.isFunctionBlock(node)) { return spanInFunctionBlock(node); } - case 207: + case 209: return spanInBlock(node); - case 224: + case 226: return spanInBlock(node.block); - case 183: + case 185: return textSpan(node.expression); - case 192: + case 194: return textSpan(node.getChildAt(0), node.expression); + case 188: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 187: + return spanInNode(node.statement); + case 200: + return textSpan(node.getChildAt(0)); case 186: return textSpan(node, ts.findNextToken(node.expression, node)); - case 185: - return spanInNode(node.statement); - case 198: - return textSpan(node.getChildAt(0)); - case 184: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 195: - return spanInNode(node.statement); - case 191: - case 190: - return textSpan(node.getChildAt(0), node.label); - case 187: - return spanInForStatement(node); - case 188: - case 189: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 194: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 221: - case 222: - return spanInNode(node.statements[0]); case 197: - return spanInBlock(node.tryBlock); + return spanInNode(node.statement); + case 193: + case 192: + return textSpan(node.getChildAt(0), node.label); + case 189: + return spanInForStatement(node); + case 190: + case 191: + return textSpan(node, ts.findNextToken(node.expression, node)); case 196: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 223: + case 224: + return spanInNode(node.statements[0]); + case 199: + return spanInBlock(node.tryBlock); + case 198: return textSpan(node, node.expression); - case 215: + case 217: return textSpan(node, node.expression); - case 209: + case 211: return textSpan(node, node.moduleReference); - case 210: + case 212: return textSpan(node, node.moduleSpecifier); - case 216: + case 218: return textSpan(node, node.moduleSpecifier); - case 206: + case 208: if (ts.getModuleInstanceState(node) !== 1) { return undefined; } - case 202: - case 205: - case 227: - case 158: - case 159: - return textSpan(node); - case 193: - return spanInNode(node.statement); - case 203: case 204: + case 207: + case 229: + case 160: + case 161: + return textSpan(node); + case 195: + return spanInNode(node.statement); + case 205: + case 206: return undefined; case 22: case 1: @@ -27156,10 +27537,10 @@ var ts; case 81: return spanInNextNode(node); default: - if (node.parent.kind === 225 && node.parent.name === node) { + if (node.parent.kind === 227 && node.parent.name === node) { return spanInNode(node.parent.initializer); } - if (node.parent.kind === 161 && node.parent.type === node) { + if (node.parent.kind === 163 && node.parent.type === node) { return spanInNode(node.parent.expression); } if (ts.isFunctionLike(node.parent) && node.parent.type === node) { @@ -27169,12 +27550,12 @@ var ts; } } function spanInVariableDeclaration(variableDeclaration) { - if (variableDeclaration.parent.parent.kind === 188 || - variableDeclaration.parent.parent.kind === 189) { + if (variableDeclaration.parent.parent.kind === 190 || + variableDeclaration.parent.parent.kind === 191) { return spanInNode(variableDeclaration.parent.parent); } - var isParentVariableStatement = variableDeclaration.parent.parent.kind === 181; - var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 187 && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); + var isParentVariableStatement = variableDeclaration.parent.parent.kind === 183; + var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 189 && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); var declarations = isParentVariableStatement ? variableDeclaration.parent.parent.declarationList.declarations : isDeclarationOfForStatement @@ -27220,7 +27601,7 @@ var ts; } function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) { return !!(functionDeclaration.flags & 1) || - (functionDeclaration.parent.kind === 202 && functionDeclaration.kind !== 136); + (functionDeclaration.parent.kind === 204 && functionDeclaration.kind !== 137); } function spanInFunctionDeclaration(functionDeclaration) { if (!functionDeclaration.body) { @@ -27240,23 +27621,23 @@ var ts; } function spanInBlock(block) { switch (block.parent.kind) { - case 206: + case 208: if (ts.getModuleInstanceState(block.parent) !== 1) { return undefined; } - case 186: - case 184: case 188: - case 189: + case 186: + case 190: + case 191: return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); - case 187: + case 189: return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]); } return spanInNode(block.statements[0]); } function spanInForStatement(forStatement) { if (forStatement.initializer) { - if (forStatement.initializer.kind === 200) { + if (forStatement.initializer.kind === 202) { var variableDeclarationList = forStatement.initializer; if (variableDeclarationList.declarations.length > 0) { return spanInNode(variableDeclarationList.declarations[0]); @@ -27275,34 +27656,34 @@ var ts; } function spanInOpenBraceToken(node) { switch (node.parent.kind) { - case 205: + case 207: var enumDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile)); - case 202: + case 204: var classDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile)); - case 208: + case 210: return spanInNodeIfStartsOnSameLine(node.parent.parent, node.parent.clauses[0]); } return spanInNode(node.parent); } function spanInCloseBraceToken(node) { switch (node.parent.kind) { - case 207: + case 209: if (ts.getModuleInstanceState(node.parent.parent) !== 1) { return undefined; } - case 205: - case 202: + case 207: + case 204: return textSpan(node); - case 180: + case 182: if (ts.isFunctionBlock(node.parent)) { return textSpan(node); } - case 224: + case 226: return spanInNode(ts.lastOrUndefined(node.parent.statements)); ; - case 208: + case 210: var caseBlock = node.parent; var lastClause = ts.lastOrUndefined(caseBlock.clauses); if (lastClause) { @@ -27314,24 +27695,24 @@ var ts; } } function spanInOpenParenToken(node) { - if (node.parent.kind === 185) { + if (node.parent.kind === 187) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInCloseParenToken(node) { switch (node.parent.kind) { - case 163: - case 201: - case 164: - case 135: - case 134: - case 137: - case 138: + case 165: + case 203: + case 166: case 136: - case 186: - case 185: + case 135: + case 138: + case 139: + case 137: + case 188: case 187: + case 189: return spanInPreviousNode(node); default: return spanInNode(node.parent); @@ -27339,19 +27720,19 @@ var ts; return spanInNode(node.parent); } function spanInColonToken(node) { - if (ts.isFunctionLike(node.parent) || node.parent.kind === 225) { + if (ts.isFunctionLike(node.parent) || node.parent.kind === 227) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInGreaterThanOrLessThanToken(node) { - if (node.parent.kind === 161) { + if (node.parent.kind === 163) { return spanInNode(node.parent.expression); } return spanInNode(node.parent); } function spanInWhileKeyword(node) { - if (node.parent.kind === 185) { + if (node.parent.kind === 187) { return textSpan(node, ts.findNextToken(node.parent.expression, node.parent)); } return spanInNode(node.parent); @@ -27429,7 +27810,7 @@ var ts; } } function autoCollapse(node) { - return ts.isFunctionBlock(node) && node.parent.kind !== 164; + return ts.isFunctionBlock(node) && node.parent.kind !== 166; } var depth = 0; var maxDepth = 20; @@ -27441,26 +27822,26 @@ var ts; addOutliningForLeadingCommentsForNode(n); } switch (n.kind) { - case 180: + case 182: if (!ts.isFunctionBlock(n)) { - var parent_7 = n.parent; + var parent_8 = n.parent; var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); - if (parent_7.kind === 185 || - parent_7.kind === 188 || - parent_7.kind === 189 || - parent_7.kind === 187 || - parent_7.kind === 184 || - parent_7.kind === 186 || - parent_7.kind === 193 || - parent_7.kind === 224) { - addOutliningSpan(parent_7, openBrace, closeBrace, autoCollapse(n)); + if (parent_8.kind === 187 || + parent_8.kind === 190 || + parent_8.kind === 191 || + parent_8.kind === 189 || + parent_8.kind === 186 || + parent_8.kind === 188 || + parent_8.kind === 195 || + parent_8.kind === 226) { + addOutliningSpan(parent_8, openBrace, closeBrace, autoCollapse(n)); break; } - if (parent_7.kind === 197) { - var tryStatement = parent_7; + if (parent_8.kind === 199) { + var tryStatement = parent_8; if (tryStatement.tryBlock === n) { - addOutliningSpan(parent_7, openBrace, closeBrace, autoCollapse(n)); + addOutliningSpan(parent_8, openBrace, closeBrace, autoCollapse(n)); break; } else if (tryStatement.finallyBlock === n) { @@ -27480,23 +27861,23 @@ var ts; }); break; } - case 207: { + case 209: { var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n)); break; } - case 202: - case 203: + case 204: case 205: - case 155: - case 208: { + case 207: + case 157: + case 210: { var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); addOutliningSpan(n, openBrace, closeBrace, autoCollapse(n)); break; } - case 154: + case 156: var openBracket = ts.findChildOfKind(n, 18, sourceFile); var closeBracket = ts.findChildOfKind(n, 19, sourceFile); addOutliningSpan(n, openBracket, closeBracket, autoCollapse(n)); @@ -27522,10 +27903,10 @@ var ts; ts.forEach(program.getSourceFiles(), function (sourceFile) { cancellationToken.throwIfCancellationRequested(); var nameToDeclarations = sourceFile.getNamedDeclarations(); - for (var name_27 in nameToDeclarations) { - var declarations = ts.getProperty(nameToDeclarations, name_27); + for (var name_24 in nameToDeclarations) { + var declarations = ts.getProperty(nameToDeclarations, name_24); if (declarations) { - var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name_27); + var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name_24); if (!matches) { continue; } @@ -27536,14 +27917,14 @@ var ts; if (!containers) { return undefined; } - matches = patternMatcher.getMatches(containers, name_27); + matches = patternMatcher.getMatches(containers, name_24); if (!matches) { continue; } } var fileName = sourceFile.fileName; var matchKind = bestMatchKind(matches); - rawItems.push({ name: name_27, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); + rawItems.push({ name: name_24, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); } } } @@ -27580,7 +27961,7 @@ var ts; if (text !== undefined) { containers.unshift(text); } - else if (declaration.name.kind === 128) { + else if (declaration.name.kind === 129) { return tryAddComputedPropertyName(declaration.name.expression, containers, true); } else { @@ -27597,7 +27978,7 @@ var ts; } return true; } - if (expression.kind === 156) { + if (expression.kind === 158) { var propertyAccess = expression; if (includeLastPortion) { containers.unshift(propertyAccess.name.text); @@ -27608,7 +27989,7 @@ var ts; } function getContainers(declaration) { var containers = []; - if (declaration.name.kind === 128) { + if (declaration.name.kind === 129) { if (!tryAddComputedPropertyName(declaration.name.expression, containers, false)) { return undefined; } @@ -27672,14 +28053,14 @@ var ts; var current = node.parent; while (current) { switch (current.kind) { - case 206: + case 208: do { current = current.parent; - } while (current.kind === 206); - case 202: + } while (current.kind === 208); + case 204: + case 207: case 205: case 203: - case 201: indent++; } current = current.parent; @@ -27690,26 +28071,26 @@ var ts; var childNodes = []; function visit(node) { switch (node.kind) { - case 181: + case 183: ts.forEach(node.declarationList.declarations, visit); break; - case 151: - case 152: + case 153: + case 154: ts.forEach(node.elements, visit); break; - case 216: + case 218: if (node.exportClause) { ts.forEach(node.exportClause.elements, visit); } break; - case 210: + case 212: var importClause = node.importClause; if (importClause) { if (importClause.name) { childNodes.push(importClause); } if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212) { + if (importClause.namedBindings.kind === 214) { childNodes.push(importClause.namedBindings); } else { @@ -27718,20 +28099,20 @@ var ts; } } break; - case 153: - case 199: + case 155: + case 201: if (ts.isBindingPattern(node.name)) { visit(node.name); break; } - case 202: + case 204: + case 207: case 205: + case 208: case 203: - case 206: - case 201: - case 209: - case 214: - case 218: + case 211: + case 216: + case 220: childNodes.push(node); break; } @@ -27766,17 +28147,17 @@ var ts; for (var _i = 0; _i < nodes.length; _i++) { var node = nodes[_i]; switch (node.kind) { - case 202: + case 204: + case 207: case 205: - case 203: topLevelNodes.push(node); break; - case 206: + case 208: var moduleDeclaration = node; topLevelNodes.push(node); addTopLevelNodes(getInnermostModule(moduleDeclaration).body.statements, topLevelNodes); break; - case 201: + case 203: var functionDeclaration = node; if (isTopLevelFunctionDeclaration(functionDeclaration)) { topLevelNodes.push(node); @@ -27787,9 +28168,9 @@ var ts; } } function isTopLevelFunctionDeclaration(functionDeclaration) { - if (functionDeclaration.kind === 201) { - if (functionDeclaration.body && functionDeclaration.body.kind === 180) { - if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 201 && !isEmpty(s.name.text); })) { + if (functionDeclaration.kind === 203) { + if (functionDeclaration.body && functionDeclaration.body.kind === 182) { + if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 203 && !isEmpty(s.name.text); })) { return true; } if (!ts.isFunctionBlock(functionDeclaration.parent)) { @@ -27842,7 +28223,7 @@ var ts; } function createChildItem(node) { switch (node.kind) { - case 130: + case 131: if (ts.isBindingPattern(node.name)) { break; } @@ -27850,34 +28231,34 @@ var ts; return undefined; } return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 136: case 135: - case 134: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); - case 137: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); case 138: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); - case 141: - return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); - case 227: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); case 139: - return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); - case 140: - return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); - case 133: - case 132: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); + case 142: + return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); + case 229: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 201: + case 140: + return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); + case 141: + return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); + case 134: + case 133: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 203: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.functionElement); - case 199: - case 153: + case 201: + case 155: var variableDeclarationNode; - var name_28; - if (node.kind === 153) { - name_28 = node.name; + var name_25; + if (node.kind === 155) { + name_25 = node.name; variableDeclarationNode = node; - while (variableDeclarationNode && variableDeclarationNode.kind !== 199) { + while (variableDeclarationNode && variableDeclarationNode.kind !== 201) { variableDeclarationNode = variableDeclarationNode.parent; } ts.Debug.assert(variableDeclarationNode !== undefined); @@ -27885,24 +28266,24 @@ var ts; else { ts.Debug.assert(!ts.isBindingPattern(node.name)); variableDeclarationNode = node; - name_28 = node.name; + name_25 = node.name; } if (ts.isConst(variableDeclarationNode)) { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.constElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.constElement); } else if (ts.isLet(variableDeclarationNode)) { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.letElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.letElement); } else { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.variableElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.variableElement); } - case 136: + case 137: return createItem(node, "constructor", ts.ScriptElementKind.constructorImplementationElement); - case 218: - case 214: - case 209: + case 220: + case 216: case 211: - case 212: + case 213: + case 214: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.alias); } return undefined; @@ -27932,17 +28313,17 @@ var ts; } function createTopLevelItem(node) { switch (node.kind) { - case 228: + case 230: return createSourceFileItem(node); - case 202: + case 204: return createClassItem(node); - case 205: + case 207: return createEnumItem(node); - case 203: + case 205: return createIterfaceItem(node); - case 206: + case 208: return createModuleItem(node); - case 201: + case 203: return createFunctionItem(node); } return undefined; @@ -27952,7 +28333,7 @@ var ts; } var result = []; result.push(moduleDeclaration.name.text); - while (moduleDeclaration.body && moduleDeclaration.body.kind === 206) { + while (moduleDeclaration.body && moduleDeclaration.body.kind === 208) { moduleDeclaration = moduleDeclaration.body; result.push(moduleDeclaration.name.text); } @@ -27964,7 +28345,7 @@ var ts; return getNavigationBarItem(moduleName, ts.ScriptElementKind.moduleElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } function createFunctionItem(node) { - if (node.body && node.body.kind === 180) { + if (node.body && node.body.kind === 182) { var childItems = getItemsWorker(sortNodes(node.body.statements), createChildItem); return getNavigationBarItem(!node.name ? "default" : node.name.text, ts.ScriptElementKind.functionElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } @@ -27985,7 +28366,7 @@ var ts; var childItems; if (node.members) { var constructor = ts.forEach(node.members, function (member) { - return member.kind === 136 && member; + return member.kind === 137 && member; }); var nodes = removeDynamicallyNamedProperties(node); if (constructor) { @@ -28006,19 +28387,19 @@ var ts; } } function removeComputedProperties(node) { - return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 128; }); + return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 129; }); } function removeDynamicallyNamedProperties(node) { return ts.filter(node.members, function (member) { return !ts.hasDynamicName(member); }); } function getInnermostModule(node) { - while (node.body.kind === 206) { + while (node.body.kind === 208) { node = node.body; } return node; } function getNodeSpan(node) { - return node.kind === 228 + return node.kind === 230 ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); } @@ -28401,7 +28782,7 @@ var ts; var hasTransitionFromUpperToLower = transitionFromUpperToLower(identifier, word, i, wordStart); if (charIsPunctuation(identifier.charCodeAt(i - 1)) || charIsPunctuation(identifier.charCodeAt(i)) || - lastIsDigit != currentIsDigit || + lastIsDigit !== currentIsDigit || hasTransitionFromLowerToUpper || hasTransitionFromUpperToLower) { if (!isAllPunctuation(identifier, wordStart, i)) { @@ -28455,7 +28836,7 @@ var ts; } function transitionFromUpperToLower(identifier, word, index, wordStart) { if (word) { - if (index != wordStart && + if (index !== wordStart && index + 1 < identifier.length) { var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index)); var nextIsLower = isLowerCaseLetter(identifier.charCodeAt(index + 1)); @@ -28509,14 +28890,14 @@ var ts; } return createSignatureHelpItems(candidates, resolvedSignature, argumentInfo); function createJavaScriptSignatureHelpItems(argumentInfo) { - if (argumentInfo.invocation.kind !== 158) { + if (argumentInfo.invocation.kind !== 160) { return undefined; } var callExpression = argumentInfo.invocation; var expression = callExpression.expression; var name = expression.kind === 65 ? expression - : expression.kind === 156 + : expression.kind === 158 ? expression.name : undefined; if (!name || !name.text) { @@ -28545,7 +28926,7 @@ var ts; } } function getImmediatelyContainingArgumentInfo(node) { - if (node.parent.kind === 158 || node.parent.kind === 159) { + if (node.parent.kind === 160 || node.parent.kind === 161) { var callExpression = node.parent; if (node.kind === 24 || node.kind === 16) { @@ -28576,23 +28957,23 @@ var ts; }; } } - else if (node.kind === 10 && node.parent.kind === 160) { + else if (node.kind === 10 && node.parent.kind === 162) { if (ts.isInsideTemplateLiteral(node, position)) { return getArgumentListInfoForTemplate(node.parent, 0); } } - else if (node.kind === 11 && node.parent.parent.kind === 160) { + else if (node.kind === 11 && node.parent.parent.kind === 162) { var templateExpression = node.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 172); + ts.Debug.assert(templateExpression.kind === 174); var argumentIndex = ts.isInsideTemplateLiteral(node, position) ? 0 : 1; return getArgumentListInfoForTemplate(tagExpression, argumentIndex); } - else if (node.parent.kind === 178 && node.parent.parent.parent.kind === 160) { + else if (node.parent.kind === 180 && node.parent.parent.parent.kind === 162) { var templateSpan = node.parent; var templateExpression = templateSpan.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 172); + ts.Debug.assert(templateExpression.kind === 174); if (node.kind === 13 && !ts.isInsideTemplateLiteral(node, position)) { return undefined; } @@ -28656,7 +29037,7 @@ var ts; var template = taggedTemplate.template; var applicableSpanStart = template.getStart(); var applicableSpanEnd = template.getEnd(); - if (template.kind === 172) { + if (template.kind === 174) { var lastSpan = ts.lastOrUndefined(template.templateSpans); if (lastSpan.literal.getFullWidth() === 0) { applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, false); @@ -28665,7 +29046,7 @@ var ts; return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); } function getContainingArgumentInfo(node) { - for (var n = node; n.kind !== 228; n = n.parent) { + for (var n = node; n.kind !== 230; n = n.parent) { if (ts.isFunctionBlock(n)) { return undefined; } @@ -28846,39 +29227,39 @@ var ts; return false; } switch (n.kind) { - case 202: - case 203: + case 204: case 205: - case 155: - case 151: - case 146: - case 180: case 207: - case 208: + case 157: + case 153: + case 148: + case 182: + case 209: + case 210: return nodeEndsWith(n, 15, sourceFile); - case 224: + case 226: return isCompletedNode(n.block, sourceFile); - case 159: + case 161: if (!n.arguments) { return true; } - case 158: - case 162: - case 150: + case 160: + case 164: + case 152: return nodeEndsWith(n, 17, sourceFile); - case 143: - case 144: + case 145: + case 146: return isCompletedNode(n.type, sourceFile); - case 136: case 137: case 138: - case 201: - case 163: - case 135: - case 134: - case 140: case 139: - case 164: + case 203: + case 165: + case 136: + case 135: + case 141: + case 140: + case 166: if (n.body) { return isCompletedNode(n.body, sourceFile); } @@ -28886,61 +29267,61 @@ var ts; return isCompletedNode(n.type, sourceFile); } return hasChildOfKind(n, 17, sourceFile); - case 206: + case 208: return n.body && isCompletedNode(n.body, sourceFile); - case 184: + case 186: if (n.elseStatement) { return isCompletedNode(n.elseStatement, sourceFile); } return isCompletedNode(n.thenStatement, sourceFile); - case 183: + case 185: return isCompletedNode(n.expression, sourceFile); + case 156: case 154: - case 152: - case 157: - case 128: - case 148: + case 159: + case 129: + case 150: return nodeEndsWith(n, 19, sourceFile); - case 141: + case 142: if (n.type) { return isCompletedNode(n.type, sourceFile); } return hasChildOfKind(n, 19, sourceFile); - case 221: - case 222: + case 223: + case 224: return false; - case 187: - case 188: case 189: - case 186: + case 190: + case 191: + case 188: return isCompletedNode(n.statement, sourceFile); - case 185: + case 187: var hasWhileKeyword = findChildOfKind(n, 100, sourceFile); if (hasWhileKeyword) { return nodeEndsWith(n, 17, sourceFile); } return isCompletedNode(n.statement, sourceFile); - case 145: + case 147: return isCompletedNode(n.exprName, sourceFile); - case 166: - case 165: + case 168: case 167: - case 173: - case 174: + case 169: + case 175: + case 176: var unaryWordExpression = n; return isCompletedNode(unaryWordExpression.expression, sourceFile); - case 160: + case 162: return isCompletedNode(n.template, sourceFile); - case 172: + case 174: var lastSpan = ts.lastOrUndefined(n.templateSpans); return isCompletedNode(lastSpan, sourceFile); - case 178: + case 180: return ts.nodeIsPresent(n.literal); - case 168: - return isCompletedNode(n.operand, sourceFile); case 170: + return isCompletedNode(n.operand, sourceFile); + case 172: return isCompletedNode(n.right, sourceFile); - case 171: + case 173: return isCompletedNode(n.whenFalse, sourceFile); default: return true; @@ -28983,7 +29364,7 @@ var ts; ts.findChildOfKind = findChildOfKind; function findContainingList(node) { var syntaxList = ts.forEach(node.parent.getChildren(), function (c) { - if (c.kind === 251 && c.pos <= node.pos && c.end >= node.end) { + if (c.kind === 253 && c.pos <= node.pos && c.end >= node.end) { return c; } }); @@ -29089,7 +29470,7 @@ var ts; } } } - ts.Debug.assert(startNode !== undefined || n.kind === 228); + ts.Debug.assert(startNode !== undefined || n.kind === 230); if (children.length) { var candidate = findRightmostChildNodeWithTokens(children, children.length); return candidate && findRightmostToken(candidate); @@ -29126,17 +29507,17 @@ var ts; } ts.getNodeModifiers = getNodeModifiers; function getTypeArgumentOrTypeParameterList(node) { - if (node.kind === 142 || node.kind === 158) { + if (node.kind === 144 || node.kind === 160) { return node.typeArguments; } - if (ts.isFunctionLike(node) || node.kind === 202 || node.kind === 203) { + if (ts.isFunctionLike(node) || node.kind === 204 || node.kind === 205) { return node.typeParameters; } return undefined; } ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList; function isToken(n) { - return n.kind >= 0 && n.kind <= 126; + return n.kind >= 0 && n.kind <= 127; } ts.isToken = isToken; function isWord(kind) { @@ -29189,7 +29570,7 @@ var ts; var ts; (function (ts) { function isFirstDeclarationOfSymbolParameter(symbol) { - return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 130; + return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 131; } ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter; var displayPartWriter = getDisplayPartWriter(); @@ -29574,7 +29955,7 @@ var ts; if (this.tokensAreOnSameLine === undefined) { var startLine = this.sourceFile.getLineAndCharacterOfPosition(this.currentTokenSpan.pos).line; var endLine = this.sourceFile.getLineAndCharacterOfPosition(this.nextTokenSpan.pos).line; - this.tokensAreOnSameLine = (startLine == endLine); + this.tokensAreOnSameLine = (startLine === endLine); } return this.tokensAreOnSameLine; }; @@ -29593,7 +29974,7 @@ var ts; FormattingContext.prototype.NodeIsOnOneLine = function (node) { var startLine = this.sourceFile.getLineAndCharacterOfPosition(node.getStart(this.sourceFile)).line; var endLine = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line; - return startLine == endLine; + return startLine === endLine; }; FormattingContext.prototype.BlockIsOnOneLine = function (node) { var openBrace = ts.findChildOfKind(node, 14, this.sourceFile); @@ -29708,7 +30089,7 @@ var ts; this.customContextChecks = funcs; } RuleOperationContext.prototype.IsAny = function () { - return this == RuleOperationContext.Any; + return this === RuleOperationContext.Any; }; RuleOperationContext.prototype.InContext = function (context) { if (this.IsAny()) { @@ -29789,12 +30170,12 @@ var ts; this.NoSpaceBetweenReturnAndSemicolon = new formatting.Rule(formatting.RuleDescriptor.create1(90, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.SpaceBetweenStatements = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([17, 75, 76, 67]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotForContext), 2)); this.SpaceAfterTryFinally = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([96, 81]), 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); - this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116, 121]), 65), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); + this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116, 122]), 65), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); this.SpaceBeforeBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryKeywordOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); this.SpaceAfterBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryKeywordOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); this.NoSpaceAfterConstructor = new formatting.Rule(formatting.RuleDescriptor.create1(114, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); - this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([117, 119]), 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); - this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([69, 115, 77, 78, 79, 116, 102, 85, 103, 117, 118, 106, 108, 121, 109]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([118, 120]), 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([69, 115, 77, 78, 79, 116, 102, 85, 103, 118, 119, 106, 108, 122, 109]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); this.SpaceBeforeCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([79, 102])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); this.SpaceAfterModuleName = new formatting.Rule(formatting.RuleDescriptor.create1(8, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsModuleDeclContext), 2)); this.SpaceAfterArrow = new formatting.Rule(formatting.RuleDescriptor.create3(32, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); @@ -29808,7 +30189,7 @@ var ts; this.NoSpaceBetweenEmptyInterfaceBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(14, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectTypeContext), 8)); this.SpaceBeforeAt = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 52), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); this.NoSpaceAfterAt = new formatting.Rule(formatting.RuleDescriptor.create3(52, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); - this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([65, 78, 73, 69, 109, 108, 106, 107, 116, 121, 18, 35])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2)); + this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([65, 78, 73, 69, 109, 108, 106, 107, 116, 122, 18, 35])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2)); this.NoSpaceBetweenFunctionKeywordAndStar = new formatting.Rule(formatting.RuleDescriptor.create1(83, 35), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), 8)); this.SpaceAfterStarInGeneratorDeclaration = new formatting.Rule(formatting.RuleDescriptor.create3(35, formatting.Shared.TokenRange.FromTokens([65, 16])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), 2)); this.NoSpaceBetweenYieldKeywordAndStar = new formatting.Rule(formatting.RuleDescriptor.create1(110, 35), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), 8)); @@ -29888,37 +30269,38 @@ var ts; } Rules.prototype.getRuleName = function (rule) { var o = this; - for (var name_29 in o) { - if (o[name_29] === rule) { - return name_29; + for (var name_26 in o) { + if (o[name_26] === rule) { + return name_26; } } throw new Error("Unknown rule"); }; Rules.IsForContext = function (context) { - return context.contextNode.kind === 187; + return context.contextNode.kind === 189; }; Rules.IsNotForContext = function (context) { return !Rules.IsForContext(context); }; Rules.IsBinaryOpContext = function (context) { switch (context.contextNode.kind) { - case 170: - case 171: + case 172: + case 173: + case 143: return true; - case 153: - case 204: - case 209: - case 199: - case 130: - case 227: + case 155: + case 206: + case 211: + case 201: + case 131: + case 229: + case 134: case 133: - case 132: return context.currentTokenSpan.kind === 53 || context.nextTokenSpan.kind === 53; - case 188: + case 190: return context.currentTokenSpan.kind === 86 || context.nextTokenSpan.kind === 86; - case 189: - return context.currentTokenSpan.kind === 126 || context.nextTokenSpan.kind === 126; + case 191: + return context.currentTokenSpan.kind === 127 || context.nextTokenSpan.kind === 127; } return false; }; @@ -29926,7 +30308,7 @@ var ts; return !Rules.IsBinaryOpContext(context); }; Rules.IsConditionalOperatorContext = function (context) { - return context.contextNode.kind === 171; + return context.contextNode.kind === 173; }; Rules.IsSameLineTokenOrBeforeMultilineBlockContext = function (context) { //// This check is mainly used inside SpaceBeforeOpenBraceInControl and SpaceBeforeOpenBraceInFunction. @@ -29967,85 +30349,85 @@ var ts; return true; } switch (node.kind) { - case 180: - case 208: - case 155: - case 207: + case 182: + case 210: + case 157: + case 209: return true; } return false; }; Rules.IsFunctionDeclContext = function (context) { switch (context.contextNode.kind) { - case 201: + case 203: + case 136: case 135: - case 134: - case 137: case 138: case 139: - case 163: - case 136: - case 164: - case 203: + case 140: + case 165: + case 137: + case 166: + case 205: return true; } return false; }; Rules.IsFunctionDeclarationOrFunctionExpressionContext = function (context) { - return context.contextNode.kind === 201 || context.contextNode.kind === 163; + return context.contextNode.kind === 203 || context.contextNode.kind === 165; }; Rules.IsTypeScriptDeclWithBlockContext = function (context) { return Rules.NodeIsTypeScriptDeclWithBlockContext(context.contextNode); }; Rules.NodeIsTypeScriptDeclWithBlockContext = function (node) { switch (node.kind) { - case 202: - case 203: + case 204: case 205: - case 146: - case 206: + case 207: + case 148: + case 208: return true; } return false; }; Rules.IsAfterCodeBlockContext = function (context) { switch (context.currentTokenParent.kind) { - case 202: - case 206: - case 205: - case 180: - case 224: + case 204: + case 208: case 207: - case 194: + case 182: + case 226: + case 209: + case 196: return true; } return false; }; Rules.IsControlDeclContext = function (context) { switch (context.contextNode.kind) { - case 184: - case 194: - case 187: - case 188: - case 189: case 186: - case 197: - case 185: - case 193: - case 224: + case 196: + case 189: + case 190: + case 191: + case 188: + case 199: + case 187: + case 195: + case 226: return true; default: return false; } }; Rules.IsObjectContext = function (context) { - return context.contextNode.kind === 155; + return context.contextNode.kind === 157; }; Rules.IsFunctionCallContext = function (context) { - return context.contextNode.kind === 158; + return context.contextNode.kind === 160; }; Rules.IsNewContext = function (context) { - return context.contextNode.kind === 159; + return context.contextNode.kind === 161; }; Rules.IsFunctionCallOrNewContext = function (context) { return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context); @@ -30069,38 +30451,38 @@ var ts; while (ts.isExpression(node)) { node = node.parent; } - return node.kind === 131; + return node.kind === 132; }; Rules.IsStartOfVariableDeclarationList = function (context) { - return context.currentTokenParent.kind === 200 && + return context.currentTokenParent.kind === 202 && context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos; }; Rules.IsNotFormatOnEnter = function (context) { - return context.formattingRequestKind != 2; + return context.formattingRequestKind !== 2; }; Rules.IsModuleDeclContext = function (context) { - return context.contextNode.kind === 206; + return context.contextNode.kind === 208; }; Rules.IsObjectTypeContext = function (context) { - return context.contextNode.kind === 146; + return context.contextNode.kind === 148; }; Rules.IsTypeArgumentOrParameter = function (token, parent) { if (token.kind !== 24 && token.kind !== 25) { return false; } switch (parent.kind) { - case 142: - case 202: + case 144: + case 204: + case 205: case 203: - case 201: - case 163: - case 164: + case 165: + case 166: + case 136: case 135: - case 134: - case 139: case 140: - case 158: - case 159: + case 141: + case 160: + case 161: return true; default: return false; @@ -30111,10 +30493,10 @@ var ts; Rules.IsTypeArgumentOrParameter(context.nextTokenSpan, context.nextTokenParent); }; Rules.IsVoidOpContext = function (context) { - return context.currentTokenSpan.kind === 99 && context.currentTokenParent.kind === 167; + return context.currentTokenSpan.kind === 99 && context.currentTokenParent.kind === 169; }; Rules.IsYieldOrYieldStarWithOperand = function (context) { - return context.contextNode.kind === 173 && context.contextNode.expression !== undefined; + return context.contextNode.kind === 175 && context.contextNode.expression !== undefined; }; return Rules; })(); @@ -30137,7 +30519,7 @@ var ts; return result; }; RulesMap.prototype.Initialize = function (rules) { - this.mapRowLength = 126 + 1; + this.mapRowLength = 127 + 1; this.map = new Array(this.mapRowLength * this.mapRowLength); var rulesBucketConstructionStateList = new Array(this.map.length); this.FillRules(rules, rulesBucketConstructionStateList); @@ -30155,13 +30537,13 @@ var ts; }; RulesMap.prototype.FillRule = function (rule, rulesBucketConstructionStateList) { var _this = this; - var specificRule = rule.Descriptor.LeftTokenRange != formatting.Shared.TokenRange.Any && - rule.Descriptor.RightTokenRange != formatting.Shared.TokenRange.Any; + var specificRule = rule.Descriptor.LeftTokenRange !== formatting.Shared.TokenRange.Any && + rule.Descriptor.RightTokenRange !== formatting.Shared.TokenRange.Any; rule.Descriptor.LeftTokenRange.GetTokens().forEach(function (left) { rule.Descriptor.RightTokenRange.GetTokens().forEach(function (right) { var rulesBucketIndex = _this.GetRuleBucketIndex(left, right); var rulesBucket = _this.map[rulesBucketIndex]; - if (rulesBucket == undefined) { + if (rulesBucket === undefined) { rulesBucket = _this.map[rulesBucketIndex] = new RulesBucket(); } rulesBucket.AddRule(rule, specificRule, rulesBucketConstructionStateList, rulesBucketIndex); @@ -30213,7 +30595,7 @@ var ts; RulesBucketConstructionState.prototype.IncreaseInsertionIndex = function (maskPosition) { var value = (this.rulesInsertionIndexBitmap >> maskPosition) & Mask; value++; - ts.Debug.assert((value & Mask) == value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules."); + ts.Debug.assert((value & Mask) === value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules."); var temp = this.rulesInsertionIndexBitmap & ~(Mask << maskPosition); temp |= value << maskPosition; this.rulesInsertionIndexBitmap = temp; @@ -30230,7 +30612,7 @@ var ts; }; RulesBucket.prototype.AddRule = function (rule, specificTokens, constructionState, rulesBucketIndex) { var position; - if (rule.Operation.Action == 1) { + if (rule.Operation.Action === 1) { position = specificTokens ? RulesPosition.IgnoreRulesSpecific : RulesPosition.IgnoreRulesAny; @@ -30304,7 +30686,7 @@ var ts; return [this.token]; }; TokenSingleValueAccess.prototype.Contains = function (tokenValue) { - return tokenValue == this.token; + return tokenValue === this.token; }; return TokenSingleValueAccess; })(); @@ -30314,7 +30696,7 @@ var ts; } TokenAllAccess.prototype.GetTokens = function () { var result = []; - for (var token = 0; token <= 126; token++) { + for (var token = 0; token <= 127; token++) { result.push(token); } return result; @@ -30356,9 +30738,9 @@ var ts; }; TokenRange.Any = TokenRange.AllTokens(); TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3])); - TokenRange.Keywords = TokenRange.FromRange(66, 126); + TokenRange.Keywords = TokenRange.FromRange(66, 127); TokenRange.BinaryOperators = TokenRange.FromRange(24, 64); - TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([86, 87, 126]); + TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([86, 87, 127, 117]); TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([38, 39, 47, 46]); TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([7, 65, 16, 18, 14, 93, 88]); TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([65, 16, 93, 88]); @@ -30366,7 +30748,7 @@ var ts; TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([65, 16, 93, 88]); TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([65, 17, 19, 88]); TokenRange.Comments = TokenRange.FromTokens([2, 3]); - TokenRange.TypeNames = TokenRange.FromTokens([65, 120, 122, 113, 123, 99, 112]); + TokenRange.TypeNames = TokenRange.FromTokens([65, 121, 123, 113, 124, 99, 112]); return TokenRange; })(); Shared.TokenRange = TokenRange; @@ -30544,17 +30926,17 @@ var ts; } function isListElement(parent, node) { switch (parent.kind) { - case 202: - case 203: + case 204: + case 205: return ts.rangeContainsRange(parent.members, node); - case 206: + case 208: var body = parent.body; - return body && body.kind === 180 && ts.rangeContainsRange(body.statements, node); - case 228: - case 180: - case 207: + return body && body.kind === 182 && ts.rangeContainsRange(body.statements, node); + case 230: + case 182: + case 209: return ts.rangeContainsRange(parent.statements, node); - case 224: + case 226: return ts.rangeContainsRange(parent.block.statements, node); } return false; @@ -30679,9 +31061,9 @@ var ts; if (indentation === -1) { if (isSomeBlock(node.kind)) { if (isSomeBlock(parent.kind) || - parent.kind === 228 || - parent.kind === 221 || - parent.kind === 222) { + parent.kind === 230 || + parent.kind === 223 || + parent.kind === 224) { indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(); } else { @@ -30714,18 +31096,18 @@ var ts; return node.modifiers[0].kind; } switch (node.kind) { - case 202: return 69; - case 203: return 103; - case 201: return 83; - case 205: return 205; - case 137: return 116; - case 138: return 121; - case 135: + case 204: return 69; + case 205: return 103; + case 203: return 83; + case 207: return 207; + case 138: return 116; + case 139: return 122; + case 136: if (node.asteriskToken) { return 35; } - case 133: - case 130: + case 134: + case 131: return node.name.kind; } } @@ -30832,7 +31214,7 @@ var ts; consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation); return inheritedIndentation; } - var effectiveParentStartLine = child.kind === 131 ? childStartLine : undecoratedParentStartLine; + var effectiveParentStartLine = child.kind === 132 ? childStartLine : undecoratedParentStartLine; var childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine); processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta); childContextNode = node; @@ -31122,20 +31504,20 @@ var ts; } function isSomeBlock(kind) { switch (kind) { - case 180: - case 207: + case 182: + case 209: return true; } return false; } function getOpenTokenForList(node, list) { switch (node.kind) { + case 137: + case 203: + case 165: case 136: - case 201: - case 163: case 135: - case 134: - case 164: + case 166: if (node.typeParameters === list) { return 24; } @@ -31143,8 +31525,8 @@ var ts; return 16; } break; - case 158: - case 159: + case 160: + case 161: if (node.typeArguments === list) { return 24; } @@ -31152,7 +31534,7 @@ var ts; return 16; } break; - case 142: + case 144: if (node.typeArguments === list) { return 24; } @@ -31244,7 +31626,7 @@ var ts; return 0; } var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; - if (precedingToken.kind === 23 && precedingToken.parent.kind !== 170) { + if (precedingToken.kind === 23 && precedingToken.parent.kind !== 172) { var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); if (actualIndentation !== -1) { return actualIndentation; @@ -31334,7 +31716,7 @@ var ts; } function getActualIndentationForNode(current, parent, currentLineAndChar, parentAndChildShareLine, sourceFile, options) { var useActualIndentation = (ts.isDeclaration(current) || ts.isStatement(current)) && - (parent.kind === 228 || !parentAndChildShareLine); + (parent.kind === 230 || !parentAndChildShareLine); if (!useActualIndentation) { return -1; } @@ -31358,7 +31740,7 @@ var ts; return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); } function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) { - if (parent.kind === 184 && parent.elseStatement === child) { + if (parent.kind === 186 && parent.elseStatement === child) { var elseKeyword = ts.findChildOfKind(parent, 76, sourceFile); ts.Debug.assert(elseKeyword !== undefined); var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line; @@ -31370,23 +31752,23 @@ var ts; function getContainingList(node, sourceFile) { if (node.parent) { switch (node.parent.kind) { - case 142: + case 144: if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, node.getStart(sourceFile), node.getEnd())) { return node.parent.typeArguments; } break; - case 155: + case 157: return node.parent.properties; - case 154: + case 156: return node.parent.elements; - case 201: - case 163: - case 164: + case 203: + case 165: + case 166: + case 136: case 135: - case 134: - case 139: - case 140: { + case 140: + case 141: { var start = node.getStart(sourceFile); if (node.parent.typeParameters && ts.rangeContainsStartEnd(node.parent.typeParameters, start, node.getEnd())) { @@ -31397,8 +31779,8 @@ var ts; } break; } - case 159: - case 158: { + case 161: + case 160: { var start = node.getStart(sourceFile); if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, start, node.getEnd())) { @@ -31467,28 +31849,28 @@ var ts; SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn; function nodeContentIsAlwaysIndented(kind) { switch (kind) { - case 202: - case 203: + case 204: case 205: - case 154: - case 180: case 207: - case 155: - case 146: + case 156: + case 182: + case 209: + case 157: case 148: - case 208: - case 222: - case 221: - case 162: - case 158: - case 159: - case 181: - case 199: - case 215: - case 192: - case 171: - case 152: - case 151: + case 150: + case 210: + case 224: + case 223: + case 164: + case 160: + case 161: + case 183: + case 201: + case 217: + case 194: + case 173: + case 154: + case 153: return true; } return false; @@ -31498,22 +31880,22 @@ var ts; return true; } switch (parent) { - case 185: - case 186: - case 188: - case 189: case 187: - case 184: - case 201: - case 163: - case 135: - case 134: - case 139: - case 164: + case 188: + case 190: + case 191: + case 189: + case 186: + case 203: + case 165: case 136: + case 135: + case 140: + case 166: case 137: case 138: - return child !== 180; + case 139: + return child !== 182; default: return false; } @@ -31526,8 +31908,7 @@ var ts; var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; /// /// @@ -31593,7 +31974,7 @@ var ts; return this.getEnd() - this.getStart(sourceFile); }; NodeObject.prototype.getFullWidth = function () { - return this.end - this.getFullStart(); + return this.end - this.pos; }; NodeObject.prototype.getLeadingTriviaWidth = function (sourceFile) { return this.getStart(sourceFile) - this.pos; @@ -31615,7 +31996,7 @@ var ts; return pos; }; NodeObject.prototype.createSyntaxList = function (nodes) { - var list = createNode(251, nodes.pos, nodes.end, 1024, this); + var list = createNode(253, nodes.pos, nodes.end, 1024, this); list._children = []; var pos = nodes.pos; for (var _i = 0; _i < nodes.length; _i++) { @@ -31634,7 +32015,7 @@ var ts; NodeObject.prototype.createChildren = function (sourceFile) { var _this = this; var children; - if (this.kind >= 127) { + if (this.kind >= 128) { scanner.setText((sourceFile || this.getSourceFile()).text); children = []; var pos = this.pos; @@ -31679,7 +32060,7 @@ var ts; var children = this.getChildren(); for (var _i = 0; _i < children.length; _i++) { var child = children[_i]; - if (child.kind < 127) { + if (child.kind < 128) { return child; } return child.getFirstToken(sourceFile); @@ -31689,7 +32070,7 @@ var ts; var children = this.getChildren(sourceFile); for (var i = children.length - 1; i >= 0; i--) { var child = children[i]; - if (child.kind < 127) { + if (child.kind < 128) { return child; } return child.getLastToken(sourceFile); @@ -31735,7 +32116,7 @@ var ts; ts.forEach(declarations, function (declaration, indexOfDeclaration) { if (ts.indexOf(declarations, declaration) === indexOfDeclaration) { var sourceFileOfDeclaration = ts.getSourceFileOfNode(declaration); - if (canUseParsedParamTagComments && declaration.kind === 130) { + if (canUseParsedParamTagComments && declaration.kind === 131) { ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedParamJsDocComment) { @@ -31743,13 +32124,13 @@ var ts; } }); } - if (declaration.kind === 206 && declaration.body.kind === 206) { + if (declaration.kind === 208 && declaration.body.kind === 208) { return; } - while (declaration.kind === 206 && declaration.parent.kind === 206) { + while (declaration.kind === 208 && declaration.parent.kind === 208) { declaration = declaration.parent; } - ts.forEach(getJsDocCommentTextRange(declaration.kind === 199 ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { + ts.forEach(getJsDocCommentTextRange(declaration.kind === 201 ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedJsDocComment) { jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment); @@ -32054,9 +32435,9 @@ var ts; if (result_2 !== undefined) { return result_2; } - if (declaration.name.kind === 128) { + if (declaration.name.kind === 129) { var expr = declaration.name.expression; - if (expr.kind === 156) { + if (expr.kind === 158) { return expr.name.text; } return getTextOfIdentifierOrLiteral(expr); @@ -32076,9 +32457,9 @@ var ts; } function visit(node) { switch (node.kind) { - case 201: + case 203: + case 136: case 135: - case 134: var functionDeclaration = node; var declarationName = getDeclarationName(functionDeclaration); if (declarationName) { @@ -32095,62 +32476,62 @@ var ts; ts.forEachChild(node, visit); } break; - case 202: - case 203: case 204: case 205: case 206: - case 209: - case 218: - case 214: - case 209: - case 211: - case 212: - case 137: - case 138: - case 146: - addDeclaration(node); - case 136: - case 181: - case 200: - case 151: - case 152: case 207: + case 208: + case 211: + case 220: + case 216: + case 211: + case 213: + case 214: + case 138: + case 139: + case 148: + addDeclaration(node); + case 137: + case 183: + case 202: + case 153: + case 154: + case 209: ts.forEachChild(node, visit); break; - case 180: + case 182: if (ts.isFunctionBlock(node)) { ts.forEachChild(node, visit); } break; - case 130: + case 131: if (!(node.flags & 112)) { break; } - case 199: - case 153: + case 201: + case 155: if (ts.isBindingPattern(node.name)) { ts.forEachChild(node.name, visit); break; } - case 227: + case 229: + case 134: case 133: - case 132: addDeclaration(node); break; - case 216: + case 218: if (node.exportClause) { ts.forEach(node.exportClause.elements, visit); } break; - case 210: + case 212: var importClause = node.importClause; if (importClause) { if (importClause.name) { addDeclaration(importClause); } if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212) { + if (importClause.namedBindings.kind === 214) { addDeclaration(importClause.namedBindings); } else { @@ -32290,14 +32671,14 @@ var ts; return false; } return ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 163) { + if (declaration.kind === 165) { return true; } - if (declaration.kind !== 199 && declaration.kind !== 201) { + if (declaration.kind !== 201 && declaration.kind !== 203) { return false; } - for (var parent_8 = declaration.parent; !ts.isFunctionBlock(parent_8); parent_8 = parent_8.parent) { - if (parent_8.kind === 228 || parent_8.kind === 207) { + for (var parent_9 = declaration.parent; !ts.isFunctionBlock(parent_9); parent_9 = parent_9.parent) { + if (parent_9.kind === 230 || parent_9.kind === 209) { return false; } } @@ -32336,8 +32717,7 @@ var ts; var HostCache = (function () { function HostCache(host, getCanonicalFileName) { this.host = host; - this.getCanonicalFileName = getCanonicalFileName; - this.fileNameToEntry = {}; + this.fileNameToEntry = ts.createFileMap(getCanonicalFileName); var rootFileNames = host.getScriptFileNames(); for (var _i = 0; _i < rootFileNames.length; _i++) { var fileName = rootFileNames[_i]; @@ -32348,9 +32728,6 @@ var ts; HostCache.prototype.compilationSettings = function () { return this._compilationSettings; }; - HostCache.prototype.normalizeFileName = function (fileName) { - return this.getCanonicalFileName(ts.normalizeSlashes(fileName)); - }; HostCache.prototype.createEntry = function (fileName) { var entry; var scriptSnapshot = this.host.getScriptSnapshot(fileName); @@ -32361,13 +32738,14 @@ var ts; scriptSnapshot: scriptSnapshot }; } - return this.fileNameToEntry[this.normalizeFileName(fileName)] = entry; + this.fileNameToEntry.set(fileName, entry); + return entry; }; HostCache.prototype.getEntry = function (fileName) { - return ts.lookUp(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.get(fileName); }; HostCache.prototype.contains = function (fileName) { - return ts.hasProperty(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.contains(fileName); }; HostCache.prototype.getOrCreateEntry = function (fileName) { if (this.contains(fileName)) { @@ -32376,12 +32754,10 @@ var ts; return this.createEntry(fileName); }; HostCache.prototype.getRootFileNames = function () { - var _this = this; var fileNames = []; - ts.forEachKey(this.fileNameToEntry, function (key) { - var entry = _this.getEntry(key); - if (entry) { - fileNames.push(entry.hostFileName); + this.fileNameToEntry.forEachValue(function (value) { + if (value) { + fileNames.push(value.hostFileName); } }); return fileNames; @@ -32428,7 +32804,7 @@ var ts; sourceFile.version = version; sourceFile.scriptSnapshot = scriptSnapshot; } - function transpile(input, compilerOptions, fileName, diagnostics) { + function transpile(input, compilerOptions, fileName, diagnostics, moduleName) { var options = compilerOptions ? ts.clone(compilerOptions) : getDefaultCompilerOptions(); options.isolatedModules = true; options.allowNonTsExtensions = true; @@ -32436,8 +32812,8 @@ var ts; options.noResolve = true; var inputFileName = fileName || "module.ts"; var sourceFile = ts.createSourceFile(inputFileName, input, options.target); - if (diagnostics && sourceFile.parseDiagnostics) { - diagnostics.push.apply(diagnostics, sourceFile.parseDiagnostics); + if (moduleName) { + sourceFile.moduleName = moduleName; } var newLine = ts.getNewLineCharacter(options); var outputText; @@ -32454,9 +32830,8 @@ var ts; getNewLine: function () { return newLine; } }; var program = ts.createProgram([inputFileName], options, compilerHost); - if (diagnostics) { - diagnostics.push.apply(diagnostics, program.getCompilerOptionsDiagnostics()); - } + ts.addRange(diagnostics, program.getSyntacticDiagnostics(sourceFile)); + ts.addRange(diagnostics, program.getOptionsDiagnostics()); program.emit(); ts.Debug.assert(outputText !== undefined, "Output generation failed"); return outputText; @@ -32503,8 +32878,14 @@ var ts; return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, true); } ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; - function createDocumentRegistry() { + function createGetCanonicalFileName(useCaseSensitivefileNames) { + return useCaseSensitivefileNames + ? (function (fileName) { return fileName; }) + : (function (fileName) { return fileName.toLowerCase(); }); + } + function createDocumentRegistry(useCaseSensitiveFileNames) { var buckets = {}; + var getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames); function getKeyFromCompilationSettings(settings) { return "_" + settings.target; } @@ -32512,7 +32893,7 @@ var ts; var key = getKeyFromCompilationSettings(settings); var bucket = ts.lookUp(buckets, key); if (!bucket && createIfMissing) { - buckets[key] = bucket = {}; + buckets[key] = bucket = ts.createFileMap(getCanonicalFileName); } return bucket; } @@ -32521,7 +32902,7 @@ var ts; var entries = ts.lookUp(buckets, name); var sourceFiles = []; for (var i in entries) { - var entry = entries[i]; + var entry = entries.get(i); sourceFiles.push({ name: i, refCount: entry.languageServiceRefCount, @@ -32544,15 +32925,16 @@ var ts; } function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) { var bucket = getBucketForCompilationSettings(compilationSettings, true); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); if (!entry) { ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?"); var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false); - bucket[fileName] = entry = { + entry = { sourceFile: sourceFile, languageServiceRefCount: 0, owners: [] }; + bucket.set(fileName, entry); } else { if (entry.sourceFile.version !== version) { @@ -32567,11 +32949,11 @@ var ts; function releaseDocument(fileName, compilationSettings) { var bucket = getBucketForCompilationSettings(compilationSettings, false); ts.Debug.assert(bucket !== undefined); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); entry.languageServiceRefCount--; ts.Debug.assert(entry.languageServiceRefCount >= 0); if (entry.languageServiceRefCount === 0) { - delete bucket[fileName]; + bucket.remove(fileName); } } return { @@ -32623,7 +33005,7 @@ var ts; else { if (token === 65) { token = scanner.scan(); - if (token === 125) { + if (token === 126) { token = scanner.scan(); if (token === 8) { recordModuleName(); @@ -32632,7 +33014,7 @@ var ts; } else if (token === 53) { token = scanner.scan(); - if (token === 119) { + if (token === 120) { token = scanner.scan(); if (token === 16) { token = scanner.scan(); @@ -32657,7 +33039,7 @@ var ts; } if (token === 15) { token = scanner.scan(); - if (token === 125) { + if (token === 126) { token = scanner.scan(); if (token === 8) { recordModuleName(); @@ -32671,7 +33053,7 @@ var ts; token = scanner.scan(); if (token === 65) { token = scanner.scan(); - if (token === 125) { + if (token === 126) { token = scanner.scan(); if (token === 8) { recordModuleName(); @@ -32691,7 +33073,7 @@ var ts; } if (token === 15) { token = scanner.scan(); - if (token === 125) { + if (token === 126) { token = scanner.scan(); if (token === 8) { recordModuleName(); @@ -32701,7 +33083,7 @@ var ts; } else if (token === 35) { token = scanner.scan(); - if (token === 125) { + if (token === 126) { token = scanner.scan(); if (token === 8) { recordModuleName(); @@ -32722,7 +33104,7 @@ var ts; ts.preProcessFile = preProcessFile; function getTargetLabel(referenceNode, labelName) { while (referenceNode) { - if (referenceNode.kind === 195 && referenceNode.label.text === labelName) { + if (referenceNode.kind === 197 && referenceNode.label.text === labelName) { return referenceNode.label; } referenceNode = referenceNode.parent; @@ -32731,16 +33113,16 @@ var ts; } function isJumpStatementTarget(node) { return node.kind === 65 && - (node.parent.kind === 191 || node.parent.kind === 190) && + (node.parent.kind === 193 || node.parent.kind === 192) && node.parent.label === node; } function isLabelOfLabeledStatement(node) { return node.kind === 65 && - node.parent.kind === 195 && + node.parent.kind === 197 && node.parent.label === node; } function isLabeledBy(node, labelName) { - for (var owner = node.parent; owner.kind === 195; owner = owner.parent) { + for (var owner = node.parent; owner.kind === 197; owner = owner.parent) { if (owner.label.text === labelName) { return true; } @@ -32751,25 +33133,25 @@ var ts; return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node); } function isRightSideOfQualifiedName(node) { - return node.parent.kind === 127 && node.parent.right === node; + return node.parent.kind === 128 && node.parent.right === node; } function isRightSideOfPropertyAccess(node) { - return node && node.parent && node.parent.kind === 156 && node.parent.name === node; + return node && node.parent && node.parent.kind === 158 && node.parent.name === node; } function isCallExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 158 && node.parent.expression === node; + return node && node.parent && node.parent.kind === 160 && node.parent.expression === node; } function isNewExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 159 && node.parent.expression === node; + return node && node.parent && node.parent.kind === 161 && node.parent.expression === node; } function isNameOfModuleDeclaration(node) { - return node.parent.kind === 206 && node.parent.name === node; + return node.parent.kind === 208 && node.parent.name === node; } function isNameOfFunctionDeclaration(node) { return node.kind === 65 && @@ -32777,22 +33159,22 @@ var ts; } function isNameOfPropertyAssignment(node) { return (node.kind === 65 || node.kind === 8 || node.kind === 7) && - (node.parent.kind === 225 || node.parent.kind === 226) && node.parent.name === node; + (node.parent.kind === 227 || node.parent.kind === 228) && node.parent.name === node; } function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) { if (node.kind === 8 || node.kind === 7) { switch (node.parent.kind) { - case 133: - case 132: - case 225: - case 227: - case 135: case 134: - case 137: + case 133: + case 227: + case 229: + case 136: + case 135: case 138: - case 206: + case 139: + case 208: return node.parent.name === node; - case 157: + case 159: return node.parent.argumentExpression === node; } } @@ -32830,7 +33212,7 @@ var ts; } } var keywordCompletions = []; - for (var i = 66; i <= 126; i++) { + for (var i = 66; i <= 127; i++) { keywordCompletions.push({ name: ts.tokenToString(i), kind: ScriptElementKind.keyword, @@ -32845,17 +33227,17 @@ var ts; return undefined; } switch (node.kind) { - case 228: + case 230: + case 136: case 135: - case 134: - case 201: - case 163: - case 137: - case 138: - case 202: case 203: + case 165: + case 138: + case 139: + case 204: case 205: - case 206: + case 207: + case 208: return node; } } @@ -32863,38 +33245,38 @@ var ts; ts.getContainerNode = getContainerNode; function getNodeKind(node) { switch (node.kind) { - case 206: return ScriptElementKind.moduleElement; - case 202: return ScriptElementKind.classElement; - case 203: return ScriptElementKind.interfaceElement; - case 204: return ScriptElementKind.typeElement; - case 205: return ScriptElementKind.enumElement; - case 199: + case 208: return ScriptElementKind.moduleElement; + case 204: return ScriptElementKind.classElement; + case 205: return ScriptElementKind.interfaceElement; + case 206: return ScriptElementKind.typeElement; + case 207: return ScriptElementKind.enumElement; + case 201: return ts.isConst(node) ? ScriptElementKind.constElement : ts.isLet(node) ? ScriptElementKind.letElement : ScriptElementKind.variableElement; - case 201: return ScriptElementKind.functionElement; - case 137: return ScriptElementKind.memberGetAccessorElement; - case 138: return ScriptElementKind.memberSetAccessorElement; + case 203: return ScriptElementKind.functionElement; + case 138: return ScriptElementKind.memberGetAccessorElement; + case 139: return ScriptElementKind.memberSetAccessorElement; + case 136: case 135: - case 134: return ScriptElementKind.memberFunctionElement; + case 134: case 133: - case 132: return ScriptElementKind.memberVariableElement; - case 141: return ScriptElementKind.indexSignatureElement; - case 140: return ScriptElementKind.constructSignatureElement; - case 139: return ScriptElementKind.callSignatureElement; - case 136: return ScriptElementKind.constructorImplementationElement; - case 129: return ScriptElementKind.typeParameterElement; - case 227: return ScriptElementKind.variableElement; - case 130: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; - case 209: - case 214: + case 142: return ScriptElementKind.indexSignatureElement; + case 141: return ScriptElementKind.constructSignatureElement; + case 140: return ScriptElementKind.callSignatureElement; + case 137: return ScriptElementKind.constructorImplementationElement; + case 130: return ScriptElementKind.typeParameterElement; + case 229: return ScriptElementKind.variableElement; + case 131: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; case 211: - case 218: - case 212: + case 216: + case 213: + case 220: + case 214: return ScriptElementKind.alias; } return ScriptElementKind.unknown; @@ -32916,9 +33298,7 @@ var ts; host.log(message); } } - function getCanonicalFileName(fileName) { - return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); - } + var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames); function getValidSourceFile(fileName) { fileName = ts.normalizeSlashes(fileName); var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); @@ -33048,44 +33428,44 @@ var ts; return false; } switch (node.kind) { - case 209: + case 211: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_a_ts_file)); return true; - case 215: + case 217: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.export_can_only_be_used_in_a_ts_file)); return true; - case 202: + case 204: var classDeclaration = node; if (checkModifiers(classDeclaration.modifiers) || checkTypeParameters(classDeclaration.typeParameters)) { return true; } break; - case 223: + case 225: var heritageClause = node; if (heritageClause.token === 102) { diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file)); return true; } break; - case 203: + case 205: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.interface_declarations_can_only_be_used_in_a_ts_file)); return true; - case 206: + case 208: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.module_declarations_can_only_be_used_in_a_ts_file)); return true; - case 204: + case 206: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.type_aliases_can_only_be_used_in_a_ts_file)); return true; - case 135: - case 134: case 136: + case 135: case 137: case 138: - case 163: - case 201: - case 164: - case 201: + case 139: + case 165: + case 203: + case 166: + case 203: var functionDeclaration = node; if (checkModifiers(functionDeclaration.modifiers) || checkTypeParameters(functionDeclaration.typeParameters) || @@ -33093,20 +33473,20 @@ var ts; return true; } break; - case 181: + case 183: var variableStatement = node; if (checkModifiers(variableStatement.modifiers)) { return true; } break; - case 199: + case 201: var variableDeclaration = node; if (checkTypeAnnotation(variableDeclaration.type)) { return true; } break; - case 158: - case 159: + case 160: + case 161: var expression = node; if (expression.typeArguments && expression.typeArguments.length > 0) { var start = expression.typeArguments.pos; @@ -33114,7 +33494,7 @@ var ts; return true; } break; - case 130: + case 131: var parameter = node; if (parameter.modifiers) { var start = parameter.modifiers.pos; @@ -33130,17 +33510,17 @@ var ts; return true; } break; - case 133: + case 134: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.property_declarations_can_only_be_used_in_a_ts_file)); return true; - case 205: + case 207: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file)); return true; - case 161: + case 163: var typeAssertionExpression = node; diagnostics.push(ts.createDiagnosticForNode(typeAssertionExpression.type, ts.Diagnostics.type_assertion_expressions_can_only_be_used_in_a_ts_file)); return true; - case 131: + case 132: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.decorators_can_only_be_used_in_a_ts_file)); return true; } @@ -33184,7 +33564,7 @@ var ts; } function getCompilerOptionsDiagnostics() { synchronizeHostData(); - return program.getGlobalDiagnostics(); + return program.getOptionsDiagnostics().concat(program.getGlobalDiagnostics()); } function getCompletionEntryDisplayNameForSymbol(symbol, target, performCharacterChecks) { var displayName = symbol.getName(); @@ -33257,11 +33637,11 @@ var ts; } var node = currentToken; var isRightOfDot = false; - if (contextToken && contextToken.kind === 20 && contextToken.parent.kind === 156) { + if (contextToken && contextToken.kind === 20 && contextToken.parent.kind === 158) { node = contextToken.parent.expression; isRightOfDot = true; } - else if (contextToken && contextToken.kind === 20 && contextToken.parent.kind === 127) { + else if (contextToken && contextToken.kind === 20 && contextToken.parent.kind === 128) { node = contextToken.parent.left; isRightOfDot = true; } @@ -33284,7 +33664,7 @@ var ts; function getTypeScriptMemberSymbols() { isMemberCompletion = true; isNewIdentifierLocation = false; - if (node.kind === 65 || node.kind === 127 || node.kind === 156) { + if (node.kind === 65 || node.kind === 128 || node.kind === 158) { var symbol = typeChecker.getSymbolAtLocation(node); if (symbol && symbol.flags & 8388608) { symbol = typeChecker.getAliasedSymbol(symbol); @@ -33332,11 +33712,11 @@ var ts; symbols = filterContextualMembersList(contextualTypeMembers, containingObjectLiteral.properties); } } - else if (ts.getAncestor(contextToken, 211)) { + else if (ts.getAncestor(contextToken, 213)) { isMemberCompletion = true; isNewIdentifierLocation = true; if (showCompletionsInImportsClause(contextToken)) { - var importDeclaration = ts.getAncestor(contextToken, 210); + var importDeclaration = ts.getAncestor(contextToken, 212); ts.Debug.assert(importDeclaration !== undefined); var exports_2; if (importDeclaration.moduleSpecifier) { @@ -33381,7 +33761,7 @@ var ts; function showCompletionsInImportsClause(node) { if (node) { if (node.kind === 14 || node.kind === 23) { - return node.parent.kind === 213; + return node.parent.kind === 215; } } return false; @@ -33391,38 +33771,38 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23: - return containingNodeKind === 158 - || containingNodeKind === 136 - || containingNodeKind === 159 - || containingNodeKind === 154 - || containingNodeKind === 170 - || containingNodeKind === 143; + return containingNodeKind === 160 + || containingNodeKind === 137 + || containingNodeKind === 161 + || containingNodeKind === 156 + || containingNodeKind === 172 + || containingNodeKind === 145; case 16: - return containingNodeKind === 158 - || containingNodeKind === 136 - || containingNodeKind === 159 - || containingNodeKind === 162 - || containingNodeKind === 150; + return containingNodeKind === 160 + || containingNodeKind === 137 + || containingNodeKind === 161 + || containingNodeKind === 164 + || containingNodeKind === 152; case 18: - return containingNodeKind === 154; - case 117: + return containingNodeKind === 156; case 118: + case 119: return true; case 20: - return containingNodeKind === 206; + return containingNodeKind === 208; case 14: - return containingNodeKind === 202; + return containingNodeKind === 204; case 53: - return containingNodeKind === 199 - || containingNodeKind === 170; + return containingNodeKind === 201 + || containingNodeKind === 172; case 11: - return containingNodeKind === 172; + return containingNodeKind === 174; case 12: - return containingNodeKind === 178; + return containingNodeKind === 180; case 108: case 106: case 107: - return containingNodeKind === 133; + return containingNodeKind === 134; } switch (previousToken.getText()) { case "public": @@ -33452,12 +33832,12 @@ var ts; function getContainingObjectLiteralApplicableForCompletion(previousToken) { // The locations in an object literal expression that are applicable for completion are property name definition locations. if (previousToken) { - var parent_9 = previousToken.parent; + var parent_10 = previousToken.parent; switch (previousToken.kind) { case 14: case 23: - if (parent_9 && parent_9.kind === 155) { - return parent_9; + if (parent_10 && parent_10.kind === 157) { + return parent_10; } break; } @@ -33466,16 +33846,16 @@ var ts; } function isFunction(kind) { switch (kind) { - case 163: - case 164: - case 201: + case 165: + case 166: + case 203: + case 136: case 135: - case 134: - case 137: case 138: case 139: case 140: case 141: + case 142: return true; } return false; @@ -33485,63 +33865,63 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23: - return containingNodeKind === 199 || - containingNodeKind === 200 || - containingNodeKind === 181 || - containingNodeKind === 205 || - isFunction(containingNodeKind) || + return containingNodeKind === 201 || containingNodeKind === 202 || - containingNodeKind === 201 || + containingNodeKind === 183 || + containingNodeKind === 207 || + isFunction(containingNodeKind) || + containingNodeKind === 204 || containingNodeKind === 203 || - containingNodeKind === 152 || - containingNodeKind === 151; + containingNodeKind === 205 || + containingNodeKind === 154 || + containingNodeKind === 153; case 20: - return containingNodeKind === 152; + return containingNodeKind === 154; case 51: - return containingNodeKind === 153; + return containingNodeKind === 155; case 18: - return containingNodeKind === 152; + return containingNodeKind === 154; case 16: - return containingNodeKind === 224 || + return containingNodeKind === 226 || isFunction(containingNodeKind); case 14: - return containingNodeKind === 205 || - containingNodeKind === 203 || - containingNodeKind === 146 || - containingNodeKind === 151; + return containingNodeKind === 207 || + containingNodeKind === 205 || + containingNodeKind === 148 || + containingNodeKind === 153; case 22: - return containingNodeKind === 132 && + return containingNodeKind === 133 && previousToken.parent && previousToken.parent.parent && - (previousToken.parent.parent.kind === 203 || - previousToken.parent.parent.kind === 146); + (previousToken.parent.parent.kind === 205 || + previousToken.parent.parent.kind === 148); case 24: - return containingNodeKind === 202 || - containingNodeKind === 201 || + return containingNodeKind === 204 || containingNodeKind === 203 || + containingNodeKind === 205 || isFunction(containingNodeKind); case 109: - return containingNodeKind === 133; + return containingNodeKind === 134; case 21: - return containingNodeKind === 130 || - containingNodeKind === 136 || + return containingNodeKind === 131 || + containingNodeKind === 137 || (previousToken.parent && previousToken.parent.parent && - previousToken.parent.parent.kind === 152); + previousToken.parent.parent.kind === 154); case 108: case 106: case 107: - return containingNodeKind === 130; + return containingNodeKind === 131; case 69: case 77: case 103: case 83: case 98: case 116: - case 121: + case 122: case 85: case 104: case 70: case 110: - case 124: + case 125: return true; } switch (previousToken.getText()) { @@ -33572,7 +33952,7 @@ var ts; return exports; } if (importDeclaration.importClause.namedBindings && - importDeclaration.importClause.namedBindings.kind === 213) { + importDeclaration.importClause.namedBindings.kind === 215) { ts.forEach(importDeclaration.importClause.namedBindings.elements, function (el) { var name = el.propertyName || el.name; exisingImports[name.text] = true; @@ -33589,7 +33969,7 @@ var ts; } var existingMemberNames = {}; ts.forEach(existingMembers, function (m) { - if (m.kind !== 225 && m.kind !== 226) { + if (m.kind !== 227 && m.kind !== 228) { return; } if (m.getStart() <= position && position <= m.getEnd()) { @@ -33635,10 +34015,10 @@ var ts; for (var _i = 0, _a = program.getSourceFiles(); _i < _a.length; _i++) { var sourceFile = _a[_i]; var nameTable = getNameTable(sourceFile); - for (var name_30 in nameTable) { - if (!allNames[name_30]) { - allNames[name_30] = name_30; - var displayName = getCompletionEntryDisplayName(name_30, target, true); + for (var name_27 in nameTable) { + if (!allNames[name_27]) { + allNames[name_27] = name_27; + var displayName = getCompletionEntryDisplayName(name_27, target, true); if (displayName) { var entry = { name: displayName, @@ -33814,14 +34194,14 @@ var ts; var signature; type = typeChecker.getTypeOfSymbolAtLocation(symbol, location); if (type) { - if (location.parent && location.parent.kind === 156) { + if (location.parent && location.parent.kind === 158) { var right = location.parent.name; if (right === location || (right && right.getFullWidth() === 0)) { location = location.parent; } } var callExpression; - if (location.kind === 158 || location.kind === 159) { + if (location.kind === 160 || location.kind === 161) { callExpression = location; } else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) { @@ -33833,7 +34213,7 @@ var ts; if (!signature && candidateSignatures.length) { signature = candidateSignatures[0]; } - var useConstructSignatures = callExpression.kind === 159 || callExpression.expression.kind === 91; + var useConstructSignatures = callExpression.kind === 161 || callExpression.expression.kind === 91; var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures(); if (!ts.contains(allSignatures, signature.target || signature)) { signature = allSignatures.length ? allSignatures[0] : undefined; @@ -33881,21 +34261,21 @@ var ts; } } else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304)) || - (location.kind === 114 && location.parent.kind === 136)) { + (location.kind === 114 && location.parent.kind === 137)) { var functionDeclaration = location.parent; - var allSignatures = functionDeclaration.kind === 136 ? type.getConstructSignatures() : type.getCallSignatures(); + var allSignatures = functionDeclaration.kind === 137 ? type.getConstructSignatures() : type.getCallSignatures(); if (!typeChecker.isImplementationOfOverload(functionDeclaration)) { signature = typeChecker.getSignatureFromDeclaration(functionDeclaration); } else { signature = allSignatures[0]; } - if (functionDeclaration.kind === 136) { + if (functionDeclaration.kind === 137) { symbolKind = ScriptElementKind.constructorImplementationElement; addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); } else { - addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 139 && + addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 140 && !(type.symbol.flags & 2048 || type.symbol.flags & 4096) ? type.symbol : symbol, symbolKind); } addSignatureDisplayParts(signature, allSignatures); @@ -33918,7 +34298,7 @@ var ts; } if (symbolFlags & 524288) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(124)); + displayParts.push(ts.keywordPart(125)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); displayParts.push(ts.spacePart()); @@ -33938,9 +34318,9 @@ var ts; } if (symbolFlags & 1536) { addNewLineIfDisplayPartsExist(); - var declaration = ts.getDeclarationOfKind(symbol, 206); + var declaration = ts.getDeclarationOfKind(symbol, 208); var isNamespace = declaration && declaration.name && declaration.name.kind === 65; - displayParts.push(ts.keywordPart(isNamespace ? 118 : 117)); + displayParts.push(ts.keywordPart(isNamespace ? 119 : 118)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); } @@ -33959,13 +34339,13 @@ var ts; writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration); } else { - var signatureDeclaration = ts.getDeclarationOfKind(symbol, 129).parent; + var signatureDeclaration = ts.getDeclarationOfKind(symbol, 130).parent; var signature = typeChecker.getSignatureFromDeclaration(signatureDeclaration); - if (signatureDeclaration.kind === 140) { + if (signatureDeclaration.kind === 141) { displayParts.push(ts.keywordPart(88)); displayParts.push(ts.spacePart()); } - else if (signatureDeclaration.kind !== 139 && signatureDeclaration.name) { + else if (signatureDeclaration.kind !== 140 && signatureDeclaration.name) { addFullSymbolName(signatureDeclaration.symbol); } displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeChecker, signature, sourceFile, 32)); @@ -33974,7 +34354,7 @@ var ts; if (symbolFlags & 8) { addPrefixForAnyFunctionOrVar(symbol, "enum member"); var declaration = symbol.declarations[0]; - if (declaration.kind === 227) { + if (declaration.kind === 229) { var constantValue = typeChecker.getConstantValue(declaration); if (constantValue !== undefined) { displayParts.push(ts.spacePart()); @@ -33990,13 +34370,13 @@ var ts; displayParts.push(ts.spacePart()); addFullSymbolName(symbol); ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 209) { + if (declaration.kind === 211) { var importEqualsDeclaration = declaration; if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) { displayParts.push(ts.spacePart()); displayParts.push(ts.operatorPart(53)); displayParts.push(ts.spacePart()); - displayParts.push(ts.keywordPart(119)); + displayParts.push(ts.keywordPart(120)); displayParts.push(ts.punctuationPart(16)); displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), SymbolDisplayPartKind.stringLiteral)); displayParts.push(ts.punctuationPart(17)); @@ -34120,8 +34500,8 @@ var ts; if (!symbol) { switch (node.kind) { case 65: - case 156: - case 127: + case 158: + case 128: case 93: case 91: var type = typeChecker.getTypeAtLocation(node); @@ -34175,7 +34555,7 @@ var ts; if (isNewExpressionTarget(location) || location.kind === 114) { if (symbol.flags & 32) { var classDeclaration = symbol.getDeclarations()[0]; - ts.Debug.assert(classDeclaration && classDeclaration.kind === 202); + ts.Debug.assert(classDeclaration && classDeclaration.kind === 204); return tryAddSignature(classDeclaration.members, true, symbolKind, symbolName, containerName, result); } } @@ -34191,8 +34571,8 @@ var ts; var declarations = []; var definition; ts.forEach(signatureDeclarations, function (d) { - if ((selectConstructors && d.kind === 136) || - (!selectConstructors && (d.kind === 201 || d.kind === 135 || d.kind === 134))) { + if ((selectConstructors && d.kind === 137) || + (!selectConstructors && (d.kind === 203 || d.kind === 136 || d.kind === 135))) { declarations.push(d); if (d.body) definition = d; @@ -34247,7 +34627,7 @@ var ts; symbol = typeChecker.getAliasedSymbol(symbol); } } - if (node.parent.kind === 226) { + if (node.parent.kind === 228) { var shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration); if (!shorthandSymbol) { return []; @@ -34280,7 +34660,7 @@ var ts; var result = []; ts.forEach(type.types, function (t) { if (t.symbol) { - result.push.apply(result, getDefinitionFromSymbol(t.symbol, node)); + ts.addRange(result, getDefinitionFromSymbol(t.symbol, node)); } }); return result; @@ -34371,74 +34751,74 @@ var ts; switch (node.kind) { case 84: case 76: - if (hasKind(node.parent, 184)) { + if (hasKind(node.parent, 186)) { return getIfElseOccurrences(node.parent); } break; case 90: - if (hasKind(node.parent, 192)) { + if (hasKind(node.parent, 194)) { return getReturnOccurrences(node.parent); } break; case 94: - if (hasKind(node.parent, 196)) { + if (hasKind(node.parent, 198)) { return getThrowOccurrences(node.parent); } break; case 68: - if (hasKind(parent(parent(node)), 197)) { + if (hasKind(parent(parent(node)), 199)) { return getTryCatchFinallyOccurrences(node.parent.parent); } break; case 96: case 81: - if (hasKind(parent(node), 197)) { + if (hasKind(parent(node), 199)) { return getTryCatchFinallyOccurrences(node.parent); } break; case 92: - if (hasKind(node.parent, 194)) { + if (hasKind(node.parent, 196)) { return getSwitchCaseDefaultOccurrences(node.parent); } break; case 67: case 73: - if (hasKind(parent(parent(parent(node))), 194)) { + if (hasKind(parent(parent(parent(node))), 196)) { return getSwitchCaseDefaultOccurrences(node.parent.parent.parent); } break; case 66: case 71: - if (hasKind(node.parent, 191) || hasKind(node.parent, 190)) { + if (hasKind(node.parent, 193) || hasKind(node.parent, 192)) { return getBreakOrContinueStatementOccurences(node.parent); } break; case 82: - if (hasKind(node.parent, 187) || - hasKind(node.parent, 188) || - hasKind(node.parent, 189)) { + if (hasKind(node.parent, 189) || + hasKind(node.parent, 190) || + hasKind(node.parent, 191)) { return getLoopBreakContinueOccurrences(node.parent); } break; case 100: case 75: - if (hasKind(node.parent, 186) || hasKind(node.parent, 185)) { + if (hasKind(node.parent, 188) || hasKind(node.parent, 187)) { return getLoopBreakContinueOccurrences(node.parent); } break; case 114: - if (hasKind(node.parent, 136)) { + if (hasKind(node.parent, 137)) { return getConstructorOccurrences(node.parent); } break; case 116: - case 121: - if (hasKind(node.parent, 137) || hasKind(node.parent, 138)) { + case 122: + if (hasKind(node.parent, 138) || hasKind(node.parent, 139)) { return getGetAndSetOccurrences(node.parent); } default: if (ts.isModifier(node.kind) && node.parent && - (ts.isDeclaration(node.parent) || node.parent.kind === 181)) { + (ts.isDeclaration(node.parent) || node.parent.kind === 183)) { return getModifierOccurrences(node.kind, node.parent); } } @@ -34450,10 +34830,10 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 196) { + if (node.kind === 198) { statementAccumulator.push(node); } - else if (node.kind === 197) { + else if (node.kind === 199) { var tryStatement = node; if (tryStatement.catchClause) { aggregate(tryStatement.catchClause); @@ -34474,17 +34854,17 @@ var ts; function getThrowStatementOwner(throwStatement) { var child = throwStatement; while (child.parent) { - var parent_10 = child.parent; - if (ts.isFunctionBlock(parent_10) || parent_10.kind === 228) { - return parent_10; + var parent_11 = child.parent; + if (ts.isFunctionBlock(parent_11) || parent_11.kind === 230) { + return parent_11; } - if (parent_10.kind === 197) { - var tryStatement = parent_10; + if (parent_11.kind === 199) { + var tryStatement = parent_11; if (tryStatement.tryBlock === child && tryStatement.catchClause) { return child; } } - child = parent_10; + child = parent_11; } return undefined; } @@ -34493,7 +34873,7 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 191 || node.kind === 190) { + if (node.kind === 193 || node.kind === 192) { statementAccumulator.push(node); } else if (!ts.isFunctionLike(node)) { @@ -34507,23 +34887,23 @@ var ts; return actualOwner && actualOwner === owner; } function getBreakOrContinueOwner(statement) { - for (var node_1 = statement.parent; node_1; node_1 = node_1.parent) { - switch (node_1.kind) { - case 194: - if (statement.kind === 190) { + for (var node_2 = statement.parent; node_2; node_2 = node_2.parent) { + switch (node_2.kind) { + case 196: + if (statement.kind === 192) { continue; } - case 187: - case 188: case 189: - case 186: - case 185: - if (!statement.label || isLabeledBy(node_1, statement.label.text)) { - return node_1; + case 190: + case 191: + case 188: + case 187: + if (!statement.label || isLabeledBy(node_2, statement.label.text)) { + return node_2; } break; default: - if (ts.isFunctionLike(node_1)) { + if (ts.isFunctionLike(node_2)) { return undefined; } break; @@ -34534,18 +34914,18 @@ var ts; function getModifierOccurrences(modifier, declaration) { var container = declaration.parent; if (ts.isAccessibilityModifier(modifier)) { - if (!(container.kind === 202 || - (declaration.kind === 130 && hasKind(container, 136)))) { + if (!(container.kind === 204 || + (declaration.kind === 131 && hasKind(container, 137)))) { return undefined; } } else if (modifier === 109) { - if (container.kind !== 202) { + if (container.kind !== 204) { return undefined; } } else if (modifier === 78 || modifier === 115) { - if (!(container.kind === 207 || container.kind === 228)) { + if (!(container.kind === 209 || container.kind === 230)) { return undefined; } } @@ -34556,18 +34936,18 @@ var ts; var modifierFlag = getFlagFromModifier(modifier); var nodes; switch (container.kind) { - case 207: - case 228: + case 209: + case 230: nodes = container.statements; break; - case 136: + case 137: nodes = container.parameters.concat(container.parent.members); break; - case 202: + case 204: nodes = container.members; if (modifierFlag & 112) { var constructor = ts.forEach(container.members, function (member) { - return member.kind === 136 && member; + return member.kind === 137 && member; }); if (constructor) { nodes = nodes.concat(constructor.parameters); @@ -34615,13 +34995,13 @@ var ts; } function getGetAndSetOccurrences(accessorDeclaration) { var keywords = []; - tryPushAccessorKeyword(accessorDeclaration.symbol, 137); tryPushAccessorKeyword(accessorDeclaration.symbol, 138); + tryPushAccessorKeyword(accessorDeclaration.symbol, 139); return ts.map(keywords, getHighlightSpanForNode); function tryPushAccessorKeyword(accessorSymbol, accessorKind) { var accessor = ts.getDeclarationOfKind(accessorSymbol, accessorKind); if (accessor) { - ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116, 121); }); + ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116, 122); }); } } } @@ -34638,7 +35018,7 @@ var ts; function getLoopBreakContinueOccurrences(loopNode) { var keywords = []; if (pushKeywordIf(keywords, loopNode.getFirstToken(), 82, 100, 75)) { - if (loopNode.kind === 185) { + if (loopNode.kind === 187) { var loopTokens = loopNode.getChildren(); for (var i = loopTokens.length - 1; i >= 0; i--) { if (pushKeywordIf(keywords, loopTokens[i], 100)) { @@ -34659,13 +35039,13 @@ var ts; var owner = getBreakOrContinueOwner(breakOrContinueStatement); if (owner) { switch (owner.kind) { + case 189: + case 190: + case 191: case 187: case 188: - case 189: - case 185: - case 186: return getLoopBreakContinueOccurrences(owner); - case 194: + case 196: return getSwitchCaseDefaultOccurrences(owner); } } @@ -34715,7 +35095,7 @@ var ts; } function getReturnOccurrences(returnStatement) { var func = ts.getContainingFunction(returnStatement); - if (!(func && hasKind(func.body, 180))) { + if (!(func && hasKind(func.body, 182))) { return undefined; } var keywords = []; @@ -34729,7 +35109,7 @@ var ts; } function getIfElseOccurrences(ifStatement) { var keywords = []; - while (hasKind(ifStatement.parent, 184) && ifStatement.parent.elseStatement === ifStatement) { + while (hasKind(ifStatement.parent, 186) && ifStatement.parent.elseStatement === ifStatement) { ifStatement = ifStatement.parent; } while (ifStatement) { @@ -34740,7 +35120,7 @@ var ts; break; } } - if (!hasKind(ifStatement.elseStatement, 184)) { + if (!hasKind(ifStatement.elseStatement, 186)) { break; } ifStatement = ifStatement.elseStatement; @@ -34898,16 +35278,16 @@ var ts; } function isImportOrExportSpecifierName(location) { return location.parent && - (location.parent.kind === 214 || location.parent.kind === 218) && + (location.parent.kind === 216 || location.parent.kind === 220) && location.parent.propertyName === location; } function isImportOrExportSpecifierImportSymbol(symbol) { return (symbol.flags & 8388608) && ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 214 || declaration.kind === 218; + return declaration.kind === 216 || declaration.kind === 220; }); } function getDeclaredName(symbol, location) { - var functionExpression = ts.forEach(symbol.declarations, function (d) { return d.kind === 163 ? d : undefined; }); + var functionExpression = ts.forEach(symbol.declarations, function (d) { return d.kind === 165 ? d : undefined; }); var name; if (functionExpression && functionExpression.name) { name = functionExpression.name.text; @@ -34922,7 +35302,7 @@ var ts; if (isImportOrExportSpecifierName(location)) { return location.getText(); } - var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 163 ? d : undefined; }); + var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 165 ? d : undefined; }); var name = functionExpression && functionExpression.name ? functionExpression.name.text : symbol.name; @@ -34940,7 +35320,7 @@ var ts; if (symbol.flags & (4 | 8192)) { var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32) ? d : undefined; }); if (privateDeclaration) { - return ts.getAncestor(privateDeclaration, 202); + return ts.getAncestor(privateDeclaration, 204); } } if (symbol.flags & 8388608) { @@ -34961,7 +35341,7 @@ var ts; if (scope && scope !== container) { return undefined; } - if (container.kind === 228 && !ts.isExternalModule(container)) { + if (container.kind === 230 && !ts.isExternalModule(container)) { return undefined; } scope = container; @@ -35120,13 +35500,13 @@ var ts; } var staticFlag = 128; switch (searchSpaceNode.kind) { - case 133: - case 132: - case 135: case 134: + case 133: case 136: + case 135: case 137: case 138: + case 139: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; break; @@ -35154,32 +35534,32 @@ var ts; var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, false); var staticFlag = 128; switch (searchSpaceNode.kind) { + case 136: case 135: - case 134: if (ts.isObjectLiteralMethod(searchSpaceNode)) { break; } + case 134: case 133: - case 132: - case 136: case 137: case 138: + case 139: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; break; - case 228: + case 230: if (ts.isExternalModule(searchSpaceNode)) { return undefined; } - case 201: - case 163: + case 203: + case 165: break; default: return undefined; } var references = []; var possiblePositions; - if (searchSpaceNode.kind === 228) { + if (searchSpaceNode.kind === 230) { ts.forEach(sourceFiles, function (sourceFile) { possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd()); getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, references); @@ -35210,25 +35590,25 @@ var ts; } var container = ts.getThisContainer(node, false); switch (searchSpaceNode.kind) { - case 163: - case 201: + case 165: + case 203: if (searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; + case 136: case 135: - case 134: if (ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 202: + case 204: if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128) === staticFlag) { result.push(getReferenceEntryFromNode(node)); } break; - case 228: - if (container.kind === 228 && !ts.isExternalModule(container)) { + case 230: + if (container.kind === 230 && !ts.isExternalModule(container)) { result.push(getReferenceEntryFromNode(node)); } break; @@ -35263,11 +35643,11 @@ var ts; function getPropertySymbolsFromBaseTypes(symbol, propertyName, result) { if (symbol && symbol.flags & (32 | 64)) { ts.forEach(symbol.getDeclarations(), function (declaration) { - if (declaration.kind === 202) { + if (declaration.kind === 204) { getPropertySymbolFromTypeReference(ts.getClassExtendsHeritageClauseElement(declaration)); ts.forEach(ts.getClassImplementsHeritageClauseElements(declaration), getPropertySymbolFromTypeReference); } - else if (declaration.kind === 203) { + else if (declaration.kind === 205) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), getPropertySymbolFromTypeReference); } }); @@ -35317,17 +35697,17 @@ var ts; if (isNameOfPropertyAssignment(node)) { var objectLiteral = node.parent.parent; var contextualType = typeChecker.getContextualType(objectLiteral); - var name_31 = node.text; + var name_28 = node.text; if (contextualType) { if (contextualType.flags & 16384) { - var unionProperty = contextualType.getProperty(name_31); + var unionProperty = contextualType.getProperty(name_28); if (unionProperty) { return [unionProperty]; } else { var result_4 = []; ts.forEach(contextualType.types, function (t) { - var symbol = t.getProperty(name_31); + var symbol = t.getProperty(name_28); if (symbol) { result_4.push(symbol); } @@ -35336,7 +35716,7 @@ var ts; } } else { - var symbol_1 = contextualType.getProperty(name_31); + var symbol_1 = contextualType.getProperty(name_28); if (symbol_1) { return [symbol_1]; } @@ -35381,10 +35761,10 @@ var ts; } var parent = node.parent; if (parent) { - if (parent.kind === 169 || parent.kind === 168) { + if (parent.kind === 171 || parent.kind === 170) { return true; } - else if (parent.kind === 170 && parent.left === node) { + else if (parent.kind === 172 && parent.left === node) { var operator = parent.operatorToken.kind; return 53 <= operator && operator <= 64; } @@ -35417,33 +35797,33 @@ var ts; } function getMeaningFromDeclaration(node) { switch (node.kind) { - case 130: - case 199: - case 153: - case 133: - case 132: - case 225: - case 226: - case 227: - case 135: + case 131: + case 201: + case 155: case 134: + case 133: + case 227: + case 228: + case 229: case 136: + case 135: case 137: case 138: - case 201: - case 163: - case 164: - case 224: - return 1; - case 129: + case 139: case 203: - case 204: - case 146: - return 2; - case 202: + case 165: + case 166: + case 226: + return 1; + case 130: case 205: - return 1 | 2; case 206: + case 148: + return 2; + case 204: + case 207: + return 1 | 2; + case 208: if (node.name.kind === 8) { return 4 | 1; } @@ -35453,14 +35833,14 @@ var ts; else { return 4; } - case 213: - case 214: - case 209: - case 210: case 215: case 216: + case 211: + case 212: + case 217: + case 218: return 1 | 2 | 4; - case 228: + case 230: return 4 | 1; } return 1 | 2 | 4; @@ -35470,7 +35850,8 @@ var ts; if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) { node = node.parent; } - return node.parent.kind === 142 || node.parent.kind === 177; + return node.parent.kind === 144 || + (node.parent.kind === 179 && !ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent)); } function isNamespaceReference(node) { return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node); @@ -35478,47 +35859,47 @@ var ts; function isPropertyAccessNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 156) { - while (root.parent && root.parent.kind === 156) { + if (root.parent.kind === 158) { + while (root.parent && root.parent.kind === 158) { root = root.parent; } isLastClause = root.name === node; } - if (!isLastClause && root.parent.kind === 177 && root.parent.parent.kind === 223) { + if (!isLastClause && root.parent.kind === 179 && root.parent.parent.kind === 225) { var decl = root.parent.parent.parent; - return (decl.kind === 202 && root.parent.parent.token === 102) || - (decl.kind === 203 && root.parent.parent.token === 79); + return (decl.kind === 204 && root.parent.parent.token === 102) || + (decl.kind === 205 && root.parent.parent.token === 79); } return false; } function isQualifiedNameNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 127) { - while (root.parent && root.parent.kind === 127) { + if (root.parent.kind === 128) { + while (root.parent && root.parent.kind === 128) { root = root.parent; } isLastClause = root.right === node; } - return root.parent.kind === 142 && !isLastClause; + return root.parent.kind === 144 && !isLastClause; } function isInRightSideOfImport(node) { - while (node.parent.kind === 127) { + while (node.parent.kind === 128) { node = node.parent; } return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node; } function getMeaningFromRightHandSideOfImportEquals(node) { ts.Debug.assert(node.kind === 65); - if (node.parent.kind === 127 && + if (node.parent.kind === 128 && node.parent.right === node && - node.parent.parent.kind === 209) { + node.parent.parent.kind === 211) { return 1 | 2 | 4; } return 4; } function getMeaningFromLocation(node) { - if (node.parent.kind === 215) { + if (node.parent.kind === 217) { return 1 | 2 | 4; } else if (isInRightSideOfImport(node)) { @@ -35552,8 +35933,8 @@ var ts; return; } switch (node.kind) { - case 156: - case 127: + case 158: + case 128: case 8: case 80: case 95: @@ -35571,7 +35952,7 @@ var ts; nodeForStartPos = nodeForStartPos.parent; } else if (isNameOfModuleDeclaration(nodeForStartPos)) { - if (nodeForStartPos.parent.parent.kind === 206 && + if (nodeForStartPos.parent.parent.kind === 208 && nodeForStartPos.parent.parent.body === nodeForStartPos.parent) { nodeForStartPos = nodeForStartPos.parent.parent.name; } @@ -35601,6 +35982,7 @@ var ts; var sourceFile = getValidSourceFile(fileName); var typeChecker = program.getTypeChecker(); var result = []; + var classifiableNames = program.getClassifiableNames(); processNode(sourceFile); return { spans: result, endOfLineState: 0 }; function pushClassification(start, length, type) { @@ -35610,6 +35992,9 @@ var ts; } function classifySymbol(symbol, meaningAtPosition) { var flags = symbol.getFlags(); + if ((flags & 788448) === 0) { + return; + } if (flags & 32) { return 11; } @@ -35636,18 +36021,22 @@ var ts; return undefined; function hasValueSideModule(symbol) { return ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 206 && ts.getModuleInstanceState(declaration) == 1; + return declaration.kind === 208 && + ts.getModuleInstanceState(declaration) === 1; }); } } function processNode(node) { - if (node && ts.textSpanIntersectsWith(span, node.getStart(), node.getWidth())) { - if (node.kind === 65 && node.getWidth() > 0) { - var symbol = typeChecker.getSymbolAtLocation(node); - if (symbol) { - var type = classifySymbol(symbol, getMeaningFromLocation(node)); - if (type) { - pushClassification(node.getStart(), node.getWidth(), type); + if (node && ts.textSpanIntersectsWith(span, node.getFullStart(), node.getFullWidth())) { + if (node.kind === 65 && !ts.nodeIsMissing(node)) { + var identifier = node; + if (classifiableNames[identifier.text]) { + var symbol = typeChecker.getSymbolAtLocation(node); + if (symbol) { + var type = classifySymbol(symbol, getMeaningFromLocation(node)); + if (type) { + pushClassification(node.getStart(), node.getWidth(), type); + } } } } @@ -35693,6 +36082,8 @@ var ts; } function getEncodedSyntacticClassifications(fileName, span) { var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var spanStart = span.start; + var spanLength = span.length; var triviaScanner = ts.createScanner(2, false, sourceFile.text); var mergeConflictScanner = ts.createScanner(2, false, sourceFile.text); var result = []; @@ -35703,35 +36094,36 @@ var ts; result.push(length); result.push(type); } - function classifyLeadingTrivia(token) { - var tokenStart = ts.skipTrivia(sourceFile.text, token.pos, false); - if (tokenStart === token.pos) { - return; - } + function classifyLeadingTriviaAndGetTokenStart(token) { triviaScanner.setTextPos(token.pos); while (true) { var start = triviaScanner.getTextPos(); + if (!ts.couldStartTrivia(sourceFile.text, start)) { + return start; + } var kind = triviaScanner.scan(); var end = triviaScanner.getTextPos(); var width = end - start; if (!ts.isTrivia(kind)) { - return; + return start; } - if (ts.textSpanIntersectsWith(span, start, width)) { - if (ts.isComment(kind)) { - classifyComment(token, kind, start, width); + if (kind === 4 || kind === 5) { + continue; + } + if (ts.isComment(kind)) { + classifyComment(token, kind, start, width); + triviaScanner.setTextPos(end); + continue; + } + if (kind === 6) { + var text = sourceFile.text; + var ch = text.charCodeAt(start); + if (ch === 60 || ch === 62) { + pushClassification(start, width, 1); continue; } - if (kind === 6) { - var text = sourceFile.text; - var ch = text.charCodeAt(start); - if (ch === 60 || ch === 62) { - pushClassification(start, width, 1); - continue; - } - ts.Debug.assert(ch === 61); - classifyDisabledMergeCode(text, start, end); - } + ts.Debug.assert(ch === 61); + classifyDisabledMergeCode(text, start, end); } } } @@ -35760,16 +36152,16 @@ var ts; pushClassification(tag.tagName.pos, tag.tagName.end - tag.tagName.pos, 18); pos = tag.tagName.end; switch (tag.kind) { - case 247: + case 249: processJSDocParameterTag(tag); break; - case 250: + case 252: processJSDocTemplateTag(tag); break; - case 249: + case 251: processElement(tag.typeExpression); break; - case 248: + case 250: processElement(tag.typeExpression); break; } @@ -35825,11 +36217,13 @@ var ts; } } function classifyToken(token) { - classifyLeadingTrivia(token); - if (token.getWidth() > 0) { + var tokenStart = classifyLeadingTriviaAndGetTokenStart(token); + var tokenWidth = token.end - tokenStart; + ts.Debug.assert(tokenWidth >= 0); + if (tokenWidth > 0) { var type = classifyTokenType(token.kind, token); if (type) { - pushClassification(token.getStart(), token.getWidth(), type); + pushClassification(tokenStart, tokenWidth, type); } } } @@ -35845,16 +36239,16 @@ var ts; if (ts.isPunctuation(tokenKind)) { if (token) { if (tokenKind === 53) { - if (token.parent.kind === 199 || - token.parent.kind === 133 || - token.parent.kind === 130) { + if (token.parent.kind === 201 || + token.parent.kind === 134 || + token.parent.kind === 131) { return 5; } } - if (token.parent.kind === 170 || - token.parent.kind === 168 || - token.parent.kind === 169 || - token.parent.kind === 171) { + if (token.parent.kind === 172 || + token.parent.kind === 170 || + token.parent.kind === 171 || + token.parent.kind === 173) { return 5; } } @@ -35875,32 +36269,32 @@ var ts; else if (tokenKind === 65) { if (token) { switch (token.parent.kind) { - case 202: + case 204: if (token.parent.name === token) { return 11; } return; - case 129: + case 130: if (token.parent.name === token) { return 15; } return; - case 203: + case 205: if (token.parent.name === token) { return 13; } return; - case 205: + case 207: if (token.parent.name === token) { return 12; } return; - case 206: + case 208: if (token.parent.name === token) { return 14; } return; - case 130: + case 131: if (token.parent.name === token) { return 17; } @@ -35914,10 +36308,10 @@ var ts; if (!element) { return; } - if (ts.textSpanIntersectsWith(span, element.getFullStart(), element.getFullWidth())) { + if (ts.decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) { var children = element.getChildren(sourceFile); - for (var _i = 0; _i < children.length; _i++) { - var child = children[_i]; + for (var i = 0, n = children.length; i < n; i++) { + var child = children[i]; if (ts.isToken(child)) { classifyToken(child); } @@ -36169,7 +36563,7 @@ var ts; case 8: case 7: if (ts.isDeclarationName(node) || - node.parent.kind === 220 || + node.parent.kind === 222 || isArgumentOfElementAccessExpression(node)) { nameTable[node.text] = node.text; } @@ -36182,7 +36576,7 @@ var ts; function isArgumentOfElementAccessExpression(node) { return node && node.parent && - node.parent.kind === 157 && + node.parent.kind === 159 && node.parent.argumentExpression === node; } function createClassifier() { @@ -36204,7 +36598,7 @@ var ts; function canFollow(keyword1, keyword2) { if (ts.isAccessibilityModifier(keyword1)) { if (keyword2 === 116 || - keyword2 === 121 || + keyword2 === 122 || keyword2 === 114 || keyword2 === 109) { return true; @@ -36320,10 +36714,10 @@ var ts; angleBracketStack--; } else if (token === 112 || - token === 122 || - token === 120 || + token === 123 || + token === 121 || token === 113 || - token === 123) { + token === 124) { if (angleBracketStack > 0 && !syntacticClassifierAbsent) { token = 65; } @@ -36477,7 +36871,7 @@ var ts; } } function isKeyword(token) { - return token >= 66 && token <= 126; + return token >= 66 && token <= 127; } function classFromKind(token) { if (isKeyword(token)) { @@ -36529,7 +36923,7 @@ var ts; getNodeConstructor: function (kind) { function Node() { } - var proto = kind === 228 ? new SourceFileObject() : new NodeObject(); + var proto = kind === 230 ? new SourceFileObject() : new NodeObject(); proto.kind = kind; proto.pos = 0; proto.end = 0; @@ -36547,7 +36941,6 @@ var ts; })(ts || (ts = {})); /// /// -/// /// /// var ts; @@ -36570,7 +36963,7 @@ var ts; if (a < b) { return -1; } - else if (a == b) { + else if (a === b) { return 0; } else @@ -36582,7 +36975,7 @@ var ts; } else if (a.file == b.file) { var n = compareNumber(a.start.line, b.start.line); - if (n == 0) { + if (n === 0) { return compareNumber(a.start.offset, b.start.offset); } else @@ -36639,9 +37032,11 @@ var ts; Errors.NoProject = new Error("No Project."); })(Errors || (Errors = {})); var Session = (function () { - function Session(host, logger) { + function Session(host, byteLength, hrtime, logger) { var _this = this; this.host = host; + this.byteLength = byteLength; + this.hrtime = hrtime; this.logger = logger; this.pendingOperation = false; this.fileHash = {}; @@ -36656,7 +37051,7 @@ var ts; var _this = this; if (eventName == "context") { this.projectService.log("got context event, updating diagnostics for" + fileName, "Info"); - this.updateErrorCheck([{ fileName: fileName, project: project }], this.changeSeq, function (n) { return n == _this.changeSeq; }, 100); + this.updateErrorCheck([{ fileName: fileName, project: project }], this.changeSeq, function (n) { return n === _this.changeSeq; }, 100); } }; Session.prototype.logError = function (err, cmd) { @@ -36678,7 +37073,7 @@ var ts; if (this.logger.isVerbose()) { this.logger.info(msg.type + ": " + json); } - this.sendLineToClient('Content-Length: ' + (1 + Buffer.byteLength(json, 'utf8')) + + this.sendLineToClient('Content-Length: ' + (1 + this.byteLength(json, 'utf8')) + '\r\n\r\n' + json); }; Session.prototype.event = function (info, eventName) { @@ -37015,7 +37410,7 @@ var ts; var position = compilerService.host.lineOffsetToPosition(file, line, offset); var formatOptions = this.projectService.getFormatCodeOptions(file); var edits = compilerService.languageService.getFormattingEditsAfterKeystroke(file, position, key, formatOptions); - if ((key == "\n") && ((!edits) || (edits.length == 0) || allEditsBeforePos(edits, position))) { + if ((key == "\n") && ((!edits) || (edits.length === 0) || allEditsBeforePos(edits, position))) { var scriptInfo = compilerService.host.getScriptInfo(file); if (scriptInfo) { var lineInfo = scriptInfo.getLineInfo(line); @@ -37081,7 +37476,7 @@ var ts; return undefined; } return completions.entries.reduce(function (result, entry) { - if (completions.isMemberCompletion || (entry.name.toLowerCase().indexOf(prefix.toLowerCase()) == 0)) { + if (completions.isMemberCompletion || (entry.name.toLowerCase().indexOf(prefix.toLowerCase()) === 0)) { result.push(entry); } return result; @@ -37139,7 +37534,7 @@ var ts; return accum; }, []); if (checkList.length > 0) { - this.updateErrorCheck(checkList, this.changeSeq, function (n) { return n == _this.changeSeq; }, delay); + this.updateErrorCheck(checkList, this.changeSeq, function (n) { return n === _this.changeSeq; }, delay); } }; Session.prototype.change = function (line, offset, endLine, endOffset, insertString, fileName) { @@ -37154,7 +37549,7 @@ var ts; compilerService.host.editScript(file, start, end, insertString); this.changeSeq++; } - this.updateProjectStructure(this.changeSeq, function (n) { return n == _this.changeSeq; }); + this.updateProjectStructure(this.changeSeq, function (n) { return n === _this.changeSeq; }); } }; Session.prototype.reload = function (fileName, tempFileName, reqSeq) { @@ -37270,7 +37665,7 @@ var ts; Session.prototype.onMessage = function (message) { if (this.logger.isVerbose()) { this.logger.info("request: " + message); - var start = process.hrtime(); + var start = this.hrtime(); } try { var request = JSON.parse(message); @@ -37409,7 +37804,7 @@ var ts; } } if (this.logger.isVerbose()) { - var elapsed = process.hrtime(start); + var elapsed = this.hrtime(start); var seconds = elapsed[0]; var nanoseconds = elapsed[1]; var elapsedMs = ((1e9 * seconds) + nanoseconds) / 1000000.0; @@ -37442,7 +37837,6 @@ var ts; /// /// /// -/// var ts; (function (ts) { var server; @@ -37466,7 +37860,7 @@ var ts; this.isOpen = isOpen; this.children = []; this.formatCodeOptions = ts.clone(CompilerService.defaultFormatCodeOptions); - this.svc = ScriptVersionCache.fromString(content); + this.svc = ScriptVersionCache.fromString(host, content); } ScriptInfo.prototype.setFormatOptions = function (formatOptions) { if (formatOptions) { @@ -37501,6 +37895,7 @@ var ts; }; return ScriptInfo; })(); + server.ScriptInfo = ScriptInfo; var LSHost = (function () { function LSHost(host, project) { this.host = host; @@ -37631,6 +38026,7 @@ var ts; }; return LSHost; })(); + server.LSHost = LSHost; function getAbsolutePath(filename, directory) { var rootLength = ts.getRootLength(filename); if (rootLength > 0) { @@ -37931,7 +38327,7 @@ var ts; var orphanFiles = []; for (var i = 0, len = this.openFilesReferenced.length; i < len; i++) { var f = this.openFilesReferenced[i]; - if (f.defaultProject == removedProject) { + if (f.defaultProject === removedProject) { f.defaultProject = undefined; orphanFiles.push(f); } @@ -37955,7 +38351,7 @@ var ts; for (var i = 0, len = this.inferredProjects.length; i < len; i++) { var inferredProject = this.inferredProjects[i]; inferredProject.updateGraph(); - if (inferredProject != excludedProject) { + if (inferredProject !== excludedProject) { if (inferredProject.getSourceFile(info)) { info.defaultProject = inferredProject; referencingProjects.push(inferredProject); @@ -37993,7 +38389,7 @@ var ts; var rootFile = this.openFileRoots[i]; var rootedProject = rootFile.defaultProject; var referencingProjects = this.findReferencingProjects(rootFile, rootedProject); - if (referencingProjects.length == 0) { + if (referencingProjects.length === 0) { rootFile.defaultProject = rootedProject; openFileRoots.push(rootFile); } @@ -38167,7 +38563,7 @@ var ts; return rawConfig.error; } else { - var parsedCommandLine = ts.parseConfigFile(rawConfig.config, ts.sys, dirPath); + var parsedCommandLine = ts.parseConfigFile(rawConfig.config, this.host, dirPath); if (parsedCommandLine.errors && (parsedCommandLine.errors.length > 0)) { return { errorMsg: "tsconfig option errors" }; } @@ -38228,7 +38624,7 @@ var ts; CompilerService.defaultFormatCodeOptions = { IndentSize: 4, TabSize: 4, - NewLineCharacter: ts.sys.newLine, + NewLineCharacter: ts.sys ? ts.sys.newLine : '\n', ConvertTabsToSpaces: true, InsertSpaceAfterCommaDelimiter: true, InsertSpaceAfterSemicolonInForStatements: true, @@ -38241,7 +38637,7 @@ var ts; }; return CompilerService; })(); - var CharRangeSection; + server.CompilerService = CompilerService; (function (CharRangeSection) { CharRangeSection[CharRangeSection["PreStart"] = 0] = "PreStart"; CharRangeSection[CharRangeSection["Start"] = 1] = "Start"; @@ -38249,7 +38645,8 @@ var ts; CharRangeSection[CharRangeSection["Mid"] = 3] = "Mid"; CharRangeSection[CharRangeSection["End"] = 4] = "End"; CharRangeSection[CharRangeSection["PostEnd"] = 5] = "PostEnd"; - })(CharRangeSection || (CharRangeSection = {})); + })(server.CharRangeSection || (server.CharRangeSection = {})); + var CharRangeSection = server.CharRangeSection; var BaseLineIndexWalker = (function () { function BaseLineIndexWalker() { this.goSubtree = true; @@ -38294,7 +38691,7 @@ var ts; var lastZeroCount; for (var k = this.endBranch.length - 1; k >= 0; k--) { this.endBranch[k].updateCounts(); - if (this.endBranch[k].charCount() == 0) { + if (this.endBranch[k].charCount() === 0) { lastZeroCount = this.endBranch[k]; if (k > 0) { branchParent = this.endBranch[k - 1]; @@ -38350,7 +38747,7 @@ var ts; return this.lineIndex; }; EditWalker.prototype.post = function (relativeStart, relativeLength, lineCollection, parent, nodeType) { - if (lineCollection == this.lineCollectionAtBranch) { + if (lineCollection === this.lineCollectionAtBranch) { this.state = CharRangeSection.End; } this.stack.length--; @@ -38358,7 +38755,7 @@ var ts; }; EditWalker.prototype.pre = function (relativeStart, relativeLength, lineCollection, parent, nodeType) { var currentNode = this.stack[this.stack.length - 1]; - if ((this.state == CharRangeSection.Entire) && (nodeType == CharRangeSection.Start)) { + if ((this.state === CharRangeSection.Entire) && (nodeType === CharRangeSection.Start)) { this.state = CharRangeSection.Start; this.branchNode = currentNode; this.lineCollectionAtBranch = lineCollection; @@ -38374,12 +38771,12 @@ var ts; switch (nodeType) { case CharRangeSection.PreStart: this.goSubtree = false; - if (this.state != CharRangeSection.End) { + if (this.state !== CharRangeSection.End) { currentNode.add(lineCollection); } break; case CharRangeSection.Start: - if (this.state == CharRangeSection.End) { + if (this.state === CharRangeSection.End) { this.goSubtree = false; } else { @@ -38389,7 +38786,7 @@ var ts; } break; case CharRangeSection.Entire: - if (this.state != CharRangeSection.End) { + if (this.state !== CharRangeSection.End) { child = fresh(lineCollection); currentNode.add(child); this.startPath[this.startPath.length] = child; @@ -38406,7 +38803,7 @@ var ts; this.goSubtree = false; break; case CharRangeSection.End: - if (this.state != CharRangeSection.End) { + if (this.state !== CharRangeSection.End) { this.goSubtree = false; } else { @@ -38419,7 +38816,7 @@ var ts; break; case CharRangeSection.PostEnd: this.goSubtree = false; - if (this.state != CharRangeSection.Start) { + if (this.state !== CharRangeSection.Start) { currentNode.add(lineCollection); } break; @@ -38430,10 +38827,10 @@ var ts; return lineCollection; }; EditWalker.prototype.leaf = function (relativeStart, relativeLength, ll) { - if (this.state == CharRangeSection.Start) { + if (this.state === CharRangeSection.Start) { this.initialText = ll.text.substring(0, relativeStart); } - else if (this.state == CharRangeSection.Entire) { + else if (this.state === CharRangeSection.Entire) { this.initialText = ll.text.substring(0, relativeStart); this.trailingText = ll.text.substring(relativeStart + relativeLength); } @@ -38454,6 +38851,7 @@ var ts; }; return TextChange; })(); + server.TextChange = TextChange; var ScriptVersionCache = (function () { function ScriptVersionCache() { this.changes = []; @@ -38479,7 +38877,7 @@ var ts; return this.currentVersion; }; ScriptVersionCache.prototype.reloadFromFile = function (filename, cb) { - var content = ts.sys.readFile(filename); + var content = this.host.readFile(filename); this.reload(content); if (cb) cb(); @@ -38542,10 +38940,11 @@ var ts; return ts.unchangedTextChangeRange; } }; - ScriptVersionCache.fromString = function (script) { + ScriptVersionCache.fromString = function (host, script) { var svc = new ScriptVersionCache(); var snap = new LineIndexSnapshot(0, svc); svc.versions[svc.currentVersion] = snap; + svc.host = host; snap.index = new LineIndex(); var lm = LineIndex.linesFromText(script); snap.index.load(lm.lines); @@ -38600,6 +38999,7 @@ var ts; }; return LineIndexSnapshot; })(); + server.LineIndexSnapshot = LineIndexSnapshot; var LineIndex = (function () { function LineIndex() { this.checkEdits = false; @@ -38673,7 +39073,7 @@ var ts; if (nt === void 0) { nt = ""; } return source.substring(0, s) + nt + source.substring(s + dl, source.length); } - if (this.root.charCount() == 0) { + if (this.root.charCount() === 0) { if (newText) { this.load(LineIndex.linesFromText(newText).lines); return this; @@ -38699,7 +39099,7 @@ var ts; else if (deleteLength > 0) { var e = pos + deleteLength; var lineInfo = this.charOffsetToLineNumberAndPos(e); - if ((lineInfo && (lineInfo.offset == 0))) { + if ((lineInfo && (lineInfo.offset === 0))) { deleteLength += lineInfo.text.length; if (newText) { newText = newText + lineInfo.text; @@ -38742,7 +39142,7 @@ var ts; interiorNodes[i].totalChars = charCount; interiorNodes[i].totalLines = lineCount; } - if (interiorNodes.length == 1) { + if (interiorNodes.length === 1) { return interiorNodes[0]; } else { @@ -38751,7 +39151,7 @@ var ts; }; LineIndex.linesFromText = function (text) { var lineStarts = ts.computeLineStarts(text); - if (lineStarts.length == 0) { + if (lineStarts.length === 0) { return { lines: [], lineMap: lineStarts }; } var lines = new Array(lineStarts.length); @@ -38972,7 +39372,7 @@ var ts; LineNode.prototype.findChildIndex = function (child) { var childIndex = 0; var clen = this.children.length; - while ((this.children[childIndex] != child) && (childIndex < clen)) + while ((this.children[childIndex] !== child) && (childIndex < clen)) childIndex++; return childIndex; }; @@ -38980,7 +39380,7 @@ var ts; var childIndex = this.findChildIndex(child); var clen = this.children.length; var nodeCount = nodes.length; - if ((clen < lineCollectionCapacity) && (childIndex == (clen - 1)) && (nodeCount == 1)) { + if ((clen < lineCollectionCapacity) && (childIndex === (clen - 1)) && (nodeCount === 1)) { this.add(nodes[0]); this.updateCounts(); return []; @@ -39004,13 +39404,13 @@ var ts; var splitNode = splitNodes[0]; while (nodeIndex < nodeCount) { splitNode.add(nodes[nodeIndex++]); - if (splitNode.children.length == lineCollectionCapacity) { + if (splitNode.children.length === lineCollectionCapacity) { splitNodeIndex++; splitNode = splitNodes[splitNodeIndex]; } } for (i = splitNodes.length - 1; i >= 0; i--) { - if (splitNodes[i].children.length == 0) { + if (splitNodes[i].children.length === 0) { splitNodes.length--; } } @@ -39037,6 +39437,7 @@ var ts; }; return LineNode; })(); + server.LineNode = LineNode; var LineLeaf = (function () { function LineLeaf(text) { this.text = text; @@ -39061,6 +39462,7 @@ var ts; }; return LineLeaf; })(); + server.LineLeaf = LineLeaf; })(server = ts.server || (ts.server = {})); })(ts || (ts = {})); /// @@ -39170,7 +39572,7 @@ var ts; if (err) { watchedFile.callback(watchedFile.fileName); } - else if (watchedFile.mtime.getTime() != stats.mtime.getTime()) { + else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) { watchedFile.mtime = WatchedFileSet.getModifiedTime(watchedFile.fileName); watchedFile.callback(watchedFile.fileName); } @@ -39182,7 +39584,7 @@ var ts; var count = 0; var nextToCheck = _this.nextFileToCheck; var firstCheck = -1; - while ((count < _this.chunkSize) && (nextToCheck != firstCheck)) { + while ((count < _this.chunkSize) && (nextToCheck !== firstCheck)) { _this.poll(nextToCheck); if (firstCheck < 0) { firstCheck = nextToCheck; @@ -39216,7 +39618,7 @@ var ts; var IOSession = (function (_super) { __extends(IOSession, _super); function IOSession(host, logger) { - _super.call(this, host, logger); + _super.call(this, host, Buffer.byteLength, process.hrtime, logger); } IOSession.prototype.exit = function () { this.projectService.log("Exiting...", "Info"); diff --git a/bin/typescript.d.ts b/bin/typescript.d.ts index c8e4ae8bc69..2fd4bb2c2f3 100644 --- a/bin/typescript.d.ts +++ b/bin/typescript.d.ts @@ -17,6 +17,13 @@ declare module "typescript" { interface Map { [index: string]: T; } + interface FileMap { + get(fileName: string): T; + set(fileName: string, value: T): void; + contains(fileName: string): boolean; + remove(fileName: string): void; + forEachValue(f: (v: T) => void): void; + } interface TextRange { pos: number; end: number; @@ -139,156 +146,158 @@ declare module "typescript" { ConstructorKeyword = 114, DeclareKeyword = 115, GetKeyword = 116, - ModuleKeyword = 117, - NamespaceKeyword = 118, - RequireKeyword = 119, - NumberKeyword = 120, - SetKeyword = 121, - StringKeyword = 122, - SymbolKeyword = 123, - TypeKeyword = 124, - FromKeyword = 125, - OfKeyword = 126, - QualifiedName = 127, - ComputedPropertyName = 128, - TypeParameter = 129, - Parameter = 130, - Decorator = 131, - PropertySignature = 132, - PropertyDeclaration = 133, - MethodSignature = 134, - MethodDeclaration = 135, - Constructor = 136, - GetAccessor = 137, - SetAccessor = 138, - CallSignature = 139, - ConstructSignature = 140, - IndexSignature = 141, - TypeReference = 142, - FunctionType = 143, - ConstructorType = 144, - TypeQuery = 145, - TypeLiteral = 146, - ArrayType = 147, - TupleType = 148, - UnionType = 149, - ParenthesizedType = 150, - ObjectBindingPattern = 151, - ArrayBindingPattern = 152, - BindingElement = 153, - ArrayLiteralExpression = 154, - ObjectLiteralExpression = 155, - PropertyAccessExpression = 156, - ElementAccessExpression = 157, - CallExpression = 158, - NewExpression = 159, - TaggedTemplateExpression = 160, - TypeAssertionExpression = 161, - ParenthesizedExpression = 162, - FunctionExpression = 163, - ArrowFunction = 164, - DeleteExpression = 165, - TypeOfExpression = 166, - VoidExpression = 167, - PrefixUnaryExpression = 168, - PostfixUnaryExpression = 169, - BinaryExpression = 170, - ConditionalExpression = 171, - TemplateExpression = 172, - YieldExpression = 173, - SpreadElementExpression = 174, - ClassExpression = 175, - OmittedExpression = 176, - ExpressionWithTypeArguments = 177, - TemplateSpan = 178, - SemicolonClassElement = 179, - Block = 180, - VariableStatement = 181, - EmptyStatement = 182, - ExpressionStatement = 183, - IfStatement = 184, - DoStatement = 185, - WhileStatement = 186, - ForStatement = 187, - ForInStatement = 188, - ForOfStatement = 189, - ContinueStatement = 190, - BreakStatement = 191, - ReturnStatement = 192, - WithStatement = 193, - SwitchStatement = 194, - LabeledStatement = 195, - ThrowStatement = 196, - TryStatement = 197, - DebuggerStatement = 198, - VariableDeclaration = 199, - VariableDeclarationList = 200, - FunctionDeclaration = 201, - ClassDeclaration = 202, - InterfaceDeclaration = 203, - TypeAliasDeclaration = 204, - EnumDeclaration = 205, - ModuleDeclaration = 206, - ModuleBlock = 207, - CaseBlock = 208, - ImportEqualsDeclaration = 209, - ImportDeclaration = 210, - ImportClause = 211, - NamespaceImport = 212, - NamedImports = 213, - ImportSpecifier = 214, - ExportAssignment = 215, - ExportDeclaration = 216, - NamedExports = 217, - ExportSpecifier = 218, - MissingDeclaration = 219, - ExternalModuleReference = 220, - CaseClause = 221, - DefaultClause = 222, - HeritageClause = 223, - CatchClause = 224, - PropertyAssignment = 225, - ShorthandPropertyAssignment = 226, - EnumMember = 227, - SourceFile = 228, - JSDocTypeExpression = 229, - JSDocAllType = 230, - JSDocUnknownType = 231, - JSDocArrayType = 232, - JSDocUnionType = 233, - JSDocTupleType = 234, - JSDocNullableType = 235, - JSDocNonNullableType = 236, - JSDocRecordType = 237, - JSDocRecordMember = 238, - JSDocTypeReference = 239, - JSDocOptionalType = 240, - JSDocFunctionType = 241, - JSDocVariadicType = 242, - JSDocConstructorType = 243, - JSDocThisType = 244, - JSDocComment = 245, - JSDocTag = 246, - JSDocParameterTag = 247, - JSDocReturnTag = 248, - JSDocTypeTag = 249, - JSDocTemplateTag = 250, - SyntaxList = 251, - Count = 252, + IsKeyword = 117, + ModuleKeyword = 118, + NamespaceKeyword = 119, + RequireKeyword = 120, + NumberKeyword = 121, + SetKeyword = 122, + StringKeyword = 123, + SymbolKeyword = 124, + TypeKeyword = 125, + FromKeyword = 126, + OfKeyword = 127, + QualifiedName = 128, + ComputedPropertyName = 129, + TypeParameter = 130, + Parameter = 131, + Decorator = 132, + PropertySignature = 133, + PropertyDeclaration = 134, + MethodSignature = 135, + MethodDeclaration = 136, + Constructor = 137, + GetAccessor = 138, + SetAccessor = 139, + CallSignature = 140, + ConstructSignature = 141, + IndexSignature = 142, + TypePredicate = 143, + TypeReference = 144, + FunctionType = 145, + ConstructorType = 146, + TypeQuery = 147, + TypeLiteral = 148, + ArrayType = 149, + TupleType = 150, + UnionType = 151, + ParenthesizedType = 152, + ObjectBindingPattern = 153, + ArrayBindingPattern = 154, + BindingElement = 155, + ArrayLiteralExpression = 156, + ObjectLiteralExpression = 157, + PropertyAccessExpression = 158, + ElementAccessExpression = 159, + CallExpression = 160, + NewExpression = 161, + TaggedTemplateExpression = 162, + TypeAssertionExpression = 163, + ParenthesizedExpression = 164, + FunctionExpression = 165, + ArrowFunction = 166, + DeleteExpression = 167, + TypeOfExpression = 168, + VoidExpression = 169, + PrefixUnaryExpression = 170, + PostfixUnaryExpression = 171, + BinaryExpression = 172, + ConditionalExpression = 173, + TemplateExpression = 174, + YieldExpression = 175, + SpreadElementExpression = 176, + ClassExpression = 177, + OmittedExpression = 178, + ExpressionWithTypeArguments = 179, + TemplateSpan = 180, + SemicolonClassElement = 181, + Block = 182, + VariableStatement = 183, + EmptyStatement = 184, + ExpressionStatement = 185, + IfStatement = 186, + DoStatement = 187, + WhileStatement = 188, + ForStatement = 189, + ForInStatement = 190, + ForOfStatement = 191, + ContinueStatement = 192, + BreakStatement = 193, + ReturnStatement = 194, + WithStatement = 195, + SwitchStatement = 196, + LabeledStatement = 197, + ThrowStatement = 198, + TryStatement = 199, + DebuggerStatement = 200, + VariableDeclaration = 201, + VariableDeclarationList = 202, + FunctionDeclaration = 203, + ClassDeclaration = 204, + InterfaceDeclaration = 205, + TypeAliasDeclaration = 206, + EnumDeclaration = 207, + ModuleDeclaration = 208, + ModuleBlock = 209, + CaseBlock = 210, + ImportEqualsDeclaration = 211, + ImportDeclaration = 212, + ImportClause = 213, + NamespaceImport = 214, + NamedImports = 215, + ImportSpecifier = 216, + ExportAssignment = 217, + ExportDeclaration = 218, + NamedExports = 219, + ExportSpecifier = 220, + MissingDeclaration = 221, + ExternalModuleReference = 222, + CaseClause = 223, + DefaultClause = 224, + HeritageClause = 225, + CatchClause = 226, + PropertyAssignment = 227, + ShorthandPropertyAssignment = 228, + EnumMember = 229, + SourceFile = 230, + JSDocTypeExpression = 231, + JSDocAllType = 232, + JSDocUnknownType = 233, + JSDocArrayType = 234, + JSDocUnionType = 235, + JSDocTupleType = 236, + JSDocNullableType = 237, + JSDocNonNullableType = 238, + JSDocRecordType = 239, + JSDocRecordMember = 240, + JSDocTypeReference = 241, + JSDocOptionalType = 242, + JSDocFunctionType = 243, + JSDocVariadicType = 244, + JSDocConstructorType = 245, + JSDocThisType = 246, + JSDocComment = 247, + JSDocTag = 248, + JSDocParameterTag = 249, + JSDocReturnTag = 250, + JSDocTypeTag = 251, + JSDocTemplateTag = 252, + SyntaxList = 253, + Count = 254, FirstAssignment = 53, LastAssignment = 64, FirstReservedWord = 66, LastReservedWord = 101, FirstKeyword = 66, - LastKeyword = 126, + LastKeyword = 127, FirstFutureReservedWord = 102, LastFutureReservedWord = 110, - FirstTypeNode = 142, - LastTypeNode = 150, + FirstTypeNode = 144, + LastTypeNode = 152, FirstPunctuation = 14, LastPunctuation = 64, FirstToken = 0, - LastToken = 126, + LastToken = 127, FirstTriviaToken = 2, LastTriviaToken = 6, FirstLiteralToken = 7, @@ -297,7 +306,7 @@ declare module "typescript" { LastTemplateToken = 13, FirstBinaryOperator = 24, LastBinaryOperator = 64, - FirstNode = 127, + FirstNode = 128, } const enum NodeFlags { Export = 1, @@ -458,6 +467,10 @@ declare module "typescript" { typeName: EntityName; typeArguments?: NodeArray; } + interface TypePredicateNode extends TypeNode { + parameterName: Identifier; + type: TypeNode; + } interface TypeQueryNode extends TypeNode { exprName: EntityName; } @@ -592,7 +605,7 @@ declare module "typescript" { type: TypeNode; expression: UnaryExpression; } - interface Statement extends Node, ModuleElement { + interface Statement extends Node { _statementBrand: any; } interface Block extends Statement { @@ -672,9 +685,6 @@ declare module "typescript" { variableDeclaration: VariableDeclaration; block: Block; } - interface ModuleElement extends Node { - _moduleElementBrand: any; - } interface ClassLikeDeclaration extends Declaration { name?: Identifier; typeParameters?: NodeArray; @@ -700,6 +710,7 @@ declare module "typescript" { } interface TypeAliasDeclaration extends Declaration, Statement { name: Identifier; + typeParameters?: NodeArray; type: TypeNode; } interface EnumMember extends Declaration { @@ -710,21 +721,21 @@ declare module "typescript" { name: Identifier; members: NodeArray; } - interface ModuleDeclaration extends Declaration, ModuleElement { + interface ModuleDeclaration extends Declaration, Statement { name: Identifier | LiteralExpression; body: ModuleBlock | ModuleDeclaration; } - interface ModuleBlock extends Node, ModuleElement { - statements: NodeArray; + interface ModuleBlock extends Node, Statement { + statements: NodeArray; } - interface ImportEqualsDeclaration extends Declaration, ModuleElement { + interface ImportEqualsDeclaration extends Declaration, Statement { name: Identifier; moduleReference: EntityName | ExternalModuleReference; } interface ExternalModuleReference extends Node { expression?: Expression; } - interface ImportDeclaration extends ModuleElement { + interface ImportDeclaration extends Statement { importClause?: ImportClause; moduleSpecifier: Expression; } @@ -735,7 +746,7 @@ declare module "typescript" { interface NamespaceImport extends Declaration { name: Identifier; } - interface ExportDeclaration extends Declaration, ModuleElement { + interface ExportDeclaration extends Declaration, Statement { exportClause?: NamedExports; moduleSpecifier?: Expression; } @@ -750,7 +761,7 @@ declare module "typescript" { } type ImportSpecifier = ImportOrExportSpecifier; type ExportSpecifier = ImportOrExportSpecifier; - interface ExportAssignment extends Declaration, ModuleElement { + interface ExportAssignment extends Declaration, Statement { isExportEquals?: boolean; expression: Expression; } @@ -838,7 +849,7 @@ declare module "typescript" { isBracketed: boolean; } interface SourceFile extends Declaration { - statements: NodeArray; + statements: NodeArray; endOfFileToken: Node; fileName: string; text: string; @@ -846,8 +857,16 @@ declare module "typescript" { path: string; name: string; }[]; - amdModuleName: string; + moduleName: string; referencedFiles: FileReference[]; + /** + * lib.d.ts should have a reference comment like + * + * /// + * + * If any other file has this comment, it signals not to include lib.d.ts + * because this containing file is intended to act as a default library. + */ hasNoDefaultLib: boolean; languageVersion: ScriptTarget; } @@ -878,8 +897,9 @@ declare module "typescript" { * will be invoked when writing the JavaScript and declaration files. */ emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback): EmitResult; - getSyntacticDiagnostics(sourceFile?: SourceFile): Diagnostic[]; + getOptionsDiagnostics(): Diagnostic[]; getGlobalDiagnostics(): Diagnostic[]; + getSyntacticDiagnostics(sourceFile?: SourceFile): Diagnostic[]; getSemanticDiagnostics(sourceFile?: SourceFile): Diagnostic[]; getDeclarationDiagnostics(sourceFile?: SourceFile): Diagnostic[]; /** @@ -998,6 +1018,11 @@ declare module "typescript" { WriteTypeParametersOrArguments = 1, UseOnlyExternalAliasing = 2, } + interface TypePredicate { + parameterName: string; + parameterIndex: number; + type: Type; + } const enum SymbolFlags { None = 0, FunctionScopedVariable = 1, @@ -1060,6 +1085,7 @@ declare module "typescript" { ExportHasLocal = 944, HasExports = 1952, HasMembers = 6240, + BlockScoped = 418, PropertyOrAccessor = 98308, Export = 7340032, } @@ -1111,9 +1137,8 @@ declare module "typescript" { typeParameters: TypeParameter[]; outerTypeParameters: TypeParameter[]; localTypeParameters: TypeParameter[]; - } - interface InterfaceTypeWithBaseTypes extends InterfaceType { - baseTypes: ObjectType[]; + resolvedBaseConstructorType?: Type; + resolvedBaseTypes: ObjectType[]; } interface InterfaceTypeWithDeclaredMembers extends InterfaceType { declaredProperties: Symbol[]; @@ -1146,6 +1171,7 @@ declare module "typescript" { declaration: SignatureDeclaration; typeParameters: TypeParameter[]; parameters: Symbol[]; + typePredicate?: TypePredicate; } const enum IndexKind { String = 0, @@ -1323,6 +1349,7 @@ declare module "typescript" { function getLineAndCharacterOfPosition(sourceFile: SourceFile, position: number): LineAndCharacter; function isWhiteSpace(ch: number): boolean; function isLineBreak(ch: number): boolean; + function couldStartTrivia(text: string, pos: number): boolean; function getLeadingCommentRanges(text: string, pos: number): CommentRange[]; function getTrailingCommentRanges(text: string, pos: number): CommentRange[]; function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; @@ -1338,6 +1365,7 @@ declare module "typescript" { function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan; function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan): boolean; function textSpanIntersectsWith(span: TextSpan, start: number, length: number): boolean; + function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): boolean; function textSpanIntersectsWithPosition(span: TextSpan, position: number): boolean; function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan; function createTextSpan(start: number, length: number): TextSpan; @@ -1490,6 +1518,7 @@ declare module "typescript" { log?(s: string): void; trace?(s: string): void; error?(s: string): void; + useCaseSensitiveFileNames?(): boolean; } interface LanguageService { cleanupSemanticCache(): void; @@ -1948,11 +1977,11 @@ declare module "typescript" { isCancellationRequested(): boolean; throwIfCancellationRequested(): void; } - function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string; + function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string; function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile; let disableIncrementalParsing: boolean; function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile; - function createDocumentRegistry(): DocumentRegistry; + function createDocumentRegistry(useCaseSensitiveFileNames?: boolean): DocumentRegistry; function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo; function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService; function createClassifier(): Classifier; diff --git a/bin/typescript.js b/bin/typescript.js index 138a38642c9..2e3a784b298 100644 --- a/bin/typescript.js +++ b/bin/typescript.js @@ -144,176 +144,178 @@ var ts; SyntaxKind[SyntaxKind["ConstructorKeyword"] = 114] = "ConstructorKeyword"; SyntaxKind[SyntaxKind["DeclareKeyword"] = 115] = "DeclareKeyword"; SyntaxKind[SyntaxKind["GetKeyword"] = 116] = "GetKeyword"; - SyntaxKind[SyntaxKind["ModuleKeyword"] = 117] = "ModuleKeyword"; - SyntaxKind[SyntaxKind["NamespaceKeyword"] = 118] = "NamespaceKeyword"; - SyntaxKind[SyntaxKind["RequireKeyword"] = 119] = "RequireKeyword"; - SyntaxKind[SyntaxKind["NumberKeyword"] = 120] = "NumberKeyword"; - SyntaxKind[SyntaxKind["SetKeyword"] = 121] = "SetKeyword"; - SyntaxKind[SyntaxKind["StringKeyword"] = 122] = "StringKeyword"; - SyntaxKind[SyntaxKind["SymbolKeyword"] = 123] = "SymbolKeyword"; - SyntaxKind[SyntaxKind["TypeKeyword"] = 124] = "TypeKeyword"; - SyntaxKind[SyntaxKind["FromKeyword"] = 125] = "FromKeyword"; - SyntaxKind[SyntaxKind["OfKeyword"] = 126] = "OfKeyword"; + SyntaxKind[SyntaxKind["IsKeyword"] = 117] = "IsKeyword"; + SyntaxKind[SyntaxKind["ModuleKeyword"] = 118] = "ModuleKeyword"; + SyntaxKind[SyntaxKind["NamespaceKeyword"] = 119] = "NamespaceKeyword"; + SyntaxKind[SyntaxKind["RequireKeyword"] = 120] = "RequireKeyword"; + SyntaxKind[SyntaxKind["NumberKeyword"] = 121] = "NumberKeyword"; + SyntaxKind[SyntaxKind["SetKeyword"] = 122] = "SetKeyword"; + SyntaxKind[SyntaxKind["StringKeyword"] = 123] = "StringKeyword"; + SyntaxKind[SyntaxKind["SymbolKeyword"] = 124] = "SymbolKeyword"; + SyntaxKind[SyntaxKind["TypeKeyword"] = 125] = "TypeKeyword"; + SyntaxKind[SyntaxKind["FromKeyword"] = 126] = "FromKeyword"; + SyntaxKind[SyntaxKind["OfKeyword"] = 127] = "OfKeyword"; // Parse tree nodes // Names - SyntaxKind[SyntaxKind["QualifiedName"] = 127] = "QualifiedName"; - SyntaxKind[SyntaxKind["ComputedPropertyName"] = 128] = "ComputedPropertyName"; + SyntaxKind[SyntaxKind["QualifiedName"] = 128] = "QualifiedName"; + SyntaxKind[SyntaxKind["ComputedPropertyName"] = 129] = "ComputedPropertyName"; // Signature elements - SyntaxKind[SyntaxKind["TypeParameter"] = 129] = "TypeParameter"; - SyntaxKind[SyntaxKind["Parameter"] = 130] = "Parameter"; - SyntaxKind[SyntaxKind["Decorator"] = 131] = "Decorator"; + SyntaxKind[SyntaxKind["TypeParameter"] = 130] = "TypeParameter"; + SyntaxKind[SyntaxKind["Parameter"] = 131] = "Parameter"; + SyntaxKind[SyntaxKind["Decorator"] = 132] = "Decorator"; // TypeMember - SyntaxKind[SyntaxKind["PropertySignature"] = 132] = "PropertySignature"; - SyntaxKind[SyntaxKind["PropertyDeclaration"] = 133] = "PropertyDeclaration"; - SyntaxKind[SyntaxKind["MethodSignature"] = 134] = "MethodSignature"; - SyntaxKind[SyntaxKind["MethodDeclaration"] = 135] = "MethodDeclaration"; - SyntaxKind[SyntaxKind["Constructor"] = 136] = "Constructor"; - SyntaxKind[SyntaxKind["GetAccessor"] = 137] = "GetAccessor"; - SyntaxKind[SyntaxKind["SetAccessor"] = 138] = "SetAccessor"; - SyntaxKind[SyntaxKind["CallSignature"] = 139] = "CallSignature"; - SyntaxKind[SyntaxKind["ConstructSignature"] = 140] = "ConstructSignature"; - SyntaxKind[SyntaxKind["IndexSignature"] = 141] = "IndexSignature"; + SyntaxKind[SyntaxKind["PropertySignature"] = 133] = "PropertySignature"; + SyntaxKind[SyntaxKind["PropertyDeclaration"] = 134] = "PropertyDeclaration"; + SyntaxKind[SyntaxKind["MethodSignature"] = 135] = "MethodSignature"; + SyntaxKind[SyntaxKind["MethodDeclaration"] = 136] = "MethodDeclaration"; + SyntaxKind[SyntaxKind["Constructor"] = 137] = "Constructor"; + SyntaxKind[SyntaxKind["GetAccessor"] = 138] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 139] = "SetAccessor"; + SyntaxKind[SyntaxKind["CallSignature"] = 140] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 141] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 142] = "IndexSignature"; // Type - SyntaxKind[SyntaxKind["TypeReference"] = 142] = "TypeReference"; - SyntaxKind[SyntaxKind["FunctionType"] = 143] = "FunctionType"; - SyntaxKind[SyntaxKind["ConstructorType"] = 144] = "ConstructorType"; - SyntaxKind[SyntaxKind["TypeQuery"] = 145] = "TypeQuery"; - SyntaxKind[SyntaxKind["TypeLiteral"] = 146] = "TypeLiteral"; - SyntaxKind[SyntaxKind["ArrayType"] = 147] = "ArrayType"; - SyntaxKind[SyntaxKind["TupleType"] = 148] = "TupleType"; - SyntaxKind[SyntaxKind["UnionType"] = 149] = "UnionType"; - SyntaxKind[SyntaxKind["ParenthesizedType"] = 150] = "ParenthesizedType"; + SyntaxKind[SyntaxKind["TypePredicate"] = 143] = "TypePredicate"; + SyntaxKind[SyntaxKind["TypeReference"] = 144] = "TypeReference"; + SyntaxKind[SyntaxKind["FunctionType"] = 145] = "FunctionType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 146] = "ConstructorType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 147] = "TypeQuery"; + SyntaxKind[SyntaxKind["TypeLiteral"] = 148] = "TypeLiteral"; + SyntaxKind[SyntaxKind["ArrayType"] = 149] = "ArrayType"; + SyntaxKind[SyntaxKind["TupleType"] = 150] = "TupleType"; + SyntaxKind[SyntaxKind["UnionType"] = 151] = "UnionType"; + SyntaxKind[SyntaxKind["ParenthesizedType"] = 152] = "ParenthesizedType"; // Binding patterns - SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 151] = "ObjectBindingPattern"; - SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 152] = "ArrayBindingPattern"; - SyntaxKind[SyntaxKind["BindingElement"] = 153] = "BindingElement"; + SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 153] = "ObjectBindingPattern"; + SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 154] = "ArrayBindingPattern"; + SyntaxKind[SyntaxKind["BindingElement"] = 155] = "BindingElement"; // Expression - SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 154] = "ArrayLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 155] = "ObjectLiteralExpression"; - SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 156] = "PropertyAccessExpression"; - SyntaxKind[SyntaxKind["ElementAccessExpression"] = 157] = "ElementAccessExpression"; - SyntaxKind[SyntaxKind["CallExpression"] = 158] = "CallExpression"; - SyntaxKind[SyntaxKind["NewExpression"] = 159] = "NewExpression"; - SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 160] = "TaggedTemplateExpression"; - SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 161] = "TypeAssertionExpression"; - SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 162] = "ParenthesizedExpression"; - SyntaxKind[SyntaxKind["FunctionExpression"] = 163] = "FunctionExpression"; - SyntaxKind[SyntaxKind["ArrowFunction"] = 164] = "ArrowFunction"; - SyntaxKind[SyntaxKind["DeleteExpression"] = 165] = "DeleteExpression"; - SyntaxKind[SyntaxKind["TypeOfExpression"] = 166] = "TypeOfExpression"; - SyntaxKind[SyntaxKind["VoidExpression"] = 167] = "VoidExpression"; - SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 168] = "PrefixUnaryExpression"; - SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 169] = "PostfixUnaryExpression"; - SyntaxKind[SyntaxKind["BinaryExpression"] = 170] = "BinaryExpression"; - SyntaxKind[SyntaxKind["ConditionalExpression"] = 171] = "ConditionalExpression"; - SyntaxKind[SyntaxKind["TemplateExpression"] = 172] = "TemplateExpression"; - SyntaxKind[SyntaxKind["YieldExpression"] = 173] = "YieldExpression"; - SyntaxKind[SyntaxKind["SpreadElementExpression"] = 174] = "SpreadElementExpression"; - SyntaxKind[SyntaxKind["ClassExpression"] = 175] = "ClassExpression"; - SyntaxKind[SyntaxKind["OmittedExpression"] = 176] = "OmittedExpression"; - SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 177] = "ExpressionWithTypeArguments"; + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 156] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 157] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 158] = "PropertyAccessExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 159] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["CallExpression"] = 160] = "CallExpression"; + SyntaxKind[SyntaxKind["NewExpression"] = 161] = "NewExpression"; + SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 162] = "TaggedTemplateExpression"; + SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 163] = "TypeAssertionExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 164] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 165] = "FunctionExpression"; + SyntaxKind[SyntaxKind["ArrowFunction"] = 166] = "ArrowFunction"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 167] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 168] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 169] = "VoidExpression"; + SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 170] = "PrefixUnaryExpression"; + SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 171] = "PostfixUnaryExpression"; + SyntaxKind[SyntaxKind["BinaryExpression"] = 172] = "BinaryExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 173] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["TemplateExpression"] = 174] = "TemplateExpression"; + SyntaxKind[SyntaxKind["YieldExpression"] = 175] = "YieldExpression"; + SyntaxKind[SyntaxKind["SpreadElementExpression"] = 176] = "SpreadElementExpression"; + SyntaxKind[SyntaxKind["ClassExpression"] = 177] = "ClassExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 178] = "OmittedExpression"; + SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 179] = "ExpressionWithTypeArguments"; // Misc - SyntaxKind[SyntaxKind["TemplateSpan"] = 178] = "TemplateSpan"; - SyntaxKind[SyntaxKind["SemicolonClassElement"] = 179] = "SemicolonClassElement"; + SyntaxKind[SyntaxKind["TemplateSpan"] = 180] = "TemplateSpan"; + SyntaxKind[SyntaxKind["SemicolonClassElement"] = 181] = "SemicolonClassElement"; // Element - SyntaxKind[SyntaxKind["Block"] = 180] = "Block"; - SyntaxKind[SyntaxKind["VariableStatement"] = 181] = "VariableStatement"; - SyntaxKind[SyntaxKind["EmptyStatement"] = 182] = "EmptyStatement"; - SyntaxKind[SyntaxKind["ExpressionStatement"] = 183] = "ExpressionStatement"; - SyntaxKind[SyntaxKind["IfStatement"] = 184] = "IfStatement"; - SyntaxKind[SyntaxKind["DoStatement"] = 185] = "DoStatement"; - SyntaxKind[SyntaxKind["WhileStatement"] = 186] = "WhileStatement"; - SyntaxKind[SyntaxKind["ForStatement"] = 187] = "ForStatement"; - SyntaxKind[SyntaxKind["ForInStatement"] = 188] = "ForInStatement"; - SyntaxKind[SyntaxKind["ForOfStatement"] = 189] = "ForOfStatement"; - SyntaxKind[SyntaxKind["ContinueStatement"] = 190] = "ContinueStatement"; - SyntaxKind[SyntaxKind["BreakStatement"] = 191] = "BreakStatement"; - SyntaxKind[SyntaxKind["ReturnStatement"] = 192] = "ReturnStatement"; - SyntaxKind[SyntaxKind["WithStatement"] = 193] = "WithStatement"; - SyntaxKind[SyntaxKind["SwitchStatement"] = 194] = "SwitchStatement"; - SyntaxKind[SyntaxKind["LabeledStatement"] = 195] = "LabeledStatement"; - SyntaxKind[SyntaxKind["ThrowStatement"] = 196] = "ThrowStatement"; - SyntaxKind[SyntaxKind["TryStatement"] = 197] = "TryStatement"; - SyntaxKind[SyntaxKind["DebuggerStatement"] = 198] = "DebuggerStatement"; - SyntaxKind[SyntaxKind["VariableDeclaration"] = 199] = "VariableDeclaration"; - SyntaxKind[SyntaxKind["VariableDeclarationList"] = 200] = "VariableDeclarationList"; - SyntaxKind[SyntaxKind["FunctionDeclaration"] = 201] = "FunctionDeclaration"; - SyntaxKind[SyntaxKind["ClassDeclaration"] = 202] = "ClassDeclaration"; - SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 203] = "InterfaceDeclaration"; - SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 204] = "TypeAliasDeclaration"; - SyntaxKind[SyntaxKind["EnumDeclaration"] = 205] = "EnumDeclaration"; - SyntaxKind[SyntaxKind["ModuleDeclaration"] = 206] = "ModuleDeclaration"; - SyntaxKind[SyntaxKind["ModuleBlock"] = 207] = "ModuleBlock"; - SyntaxKind[SyntaxKind["CaseBlock"] = 208] = "CaseBlock"; - SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 209] = "ImportEqualsDeclaration"; - SyntaxKind[SyntaxKind["ImportDeclaration"] = 210] = "ImportDeclaration"; - SyntaxKind[SyntaxKind["ImportClause"] = 211] = "ImportClause"; - SyntaxKind[SyntaxKind["NamespaceImport"] = 212] = "NamespaceImport"; - SyntaxKind[SyntaxKind["NamedImports"] = 213] = "NamedImports"; - SyntaxKind[SyntaxKind["ImportSpecifier"] = 214] = "ImportSpecifier"; - SyntaxKind[SyntaxKind["ExportAssignment"] = 215] = "ExportAssignment"; - SyntaxKind[SyntaxKind["ExportDeclaration"] = 216] = "ExportDeclaration"; - SyntaxKind[SyntaxKind["NamedExports"] = 217] = "NamedExports"; - SyntaxKind[SyntaxKind["ExportSpecifier"] = 218] = "ExportSpecifier"; - SyntaxKind[SyntaxKind["MissingDeclaration"] = 219] = "MissingDeclaration"; + SyntaxKind[SyntaxKind["Block"] = 182] = "Block"; + SyntaxKind[SyntaxKind["VariableStatement"] = 183] = "VariableStatement"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 184] = "EmptyStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 185] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["IfStatement"] = 186] = "IfStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 187] = "DoStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 188] = "WhileStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 189] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 190] = "ForInStatement"; + SyntaxKind[SyntaxKind["ForOfStatement"] = 191] = "ForOfStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 192] = "ContinueStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 193] = "BreakStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 194] = "ReturnStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 195] = "WithStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 196] = "SwitchStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 197] = "LabeledStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 198] = "ThrowStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 199] = "TryStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 200] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["VariableDeclaration"] = 201] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarationList"] = 202] = "VariableDeclarationList"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 203] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 204] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 205] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 206] = "TypeAliasDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 207] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 208] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ModuleBlock"] = 209] = "ModuleBlock"; + SyntaxKind[SyntaxKind["CaseBlock"] = 210] = "CaseBlock"; + SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 211] = "ImportEqualsDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 212] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ImportClause"] = 213] = "ImportClause"; + SyntaxKind[SyntaxKind["NamespaceImport"] = 214] = "NamespaceImport"; + SyntaxKind[SyntaxKind["NamedImports"] = 215] = "NamedImports"; + SyntaxKind[SyntaxKind["ImportSpecifier"] = 216] = "ImportSpecifier"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 217] = "ExportAssignment"; + SyntaxKind[SyntaxKind["ExportDeclaration"] = 218] = "ExportDeclaration"; + SyntaxKind[SyntaxKind["NamedExports"] = 219] = "NamedExports"; + SyntaxKind[SyntaxKind["ExportSpecifier"] = 220] = "ExportSpecifier"; + SyntaxKind[SyntaxKind["MissingDeclaration"] = 221] = "MissingDeclaration"; // Module references - SyntaxKind[SyntaxKind["ExternalModuleReference"] = 220] = "ExternalModuleReference"; + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 222] = "ExternalModuleReference"; // Clauses - SyntaxKind[SyntaxKind["CaseClause"] = 221] = "CaseClause"; - SyntaxKind[SyntaxKind["DefaultClause"] = 222] = "DefaultClause"; - SyntaxKind[SyntaxKind["HeritageClause"] = 223] = "HeritageClause"; - SyntaxKind[SyntaxKind["CatchClause"] = 224] = "CatchClause"; + SyntaxKind[SyntaxKind["CaseClause"] = 223] = "CaseClause"; + SyntaxKind[SyntaxKind["DefaultClause"] = 224] = "DefaultClause"; + SyntaxKind[SyntaxKind["HeritageClause"] = 225] = "HeritageClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 226] = "CatchClause"; // Property assignments - SyntaxKind[SyntaxKind["PropertyAssignment"] = 225] = "PropertyAssignment"; - SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 226] = "ShorthandPropertyAssignment"; + SyntaxKind[SyntaxKind["PropertyAssignment"] = 227] = "PropertyAssignment"; + SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 228] = "ShorthandPropertyAssignment"; // Enum - SyntaxKind[SyntaxKind["EnumMember"] = 227] = "EnumMember"; + SyntaxKind[SyntaxKind["EnumMember"] = 229] = "EnumMember"; // Top-level nodes - SyntaxKind[SyntaxKind["SourceFile"] = 228] = "SourceFile"; + SyntaxKind[SyntaxKind["SourceFile"] = 230] = "SourceFile"; // JSDoc nodes. - SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 229] = "JSDocTypeExpression"; + SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 231] = "JSDocTypeExpression"; // The * type. - SyntaxKind[SyntaxKind["JSDocAllType"] = 230] = "JSDocAllType"; + SyntaxKind[SyntaxKind["JSDocAllType"] = 232] = "JSDocAllType"; // The ? type. - SyntaxKind[SyntaxKind["JSDocUnknownType"] = 231] = "JSDocUnknownType"; - SyntaxKind[SyntaxKind["JSDocArrayType"] = 232] = "JSDocArrayType"; - SyntaxKind[SyntaxKind["JSDocUnionType"] = 233] = "JSDocUnionType"; - SyntaxKind[SyntaxKind["JSDocTupleType"] = 234] = "JSDocTupleType"; - SyntaxKind[SyntaxKind["JSDocNullableType"] = 235] = "JSDocNullableType"; - SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 236] = "JSDocNonNullableType"; - SyntaxKind[SyntaxKind["JSDocRecordType"] = 237] = "JSDocRecordType"; - SyntaxKind[SyntaxKind["JSDocRecordMember"] = 238] = "JSDocRecordMember"; - SyntaxKind[SyntaxKind["JSDocTypeReference"] = 239] = "JSDocTypeReference"; - SyntaxKind[SyntaxKind["JSDocOptionalType"] = 240] = "JSDocOptionalType"; - SyntaxKind[SyntaxKind["JSDocFunctionType"] = 241] = "JSDocFunctionType"; - SyntaxKind[SyntaxKind["JSDocVariadicType"] = 242] = "JSDocVariadicType"; - SyntaxKind[SyntaxKind["JSDocConstructorType"] = 243] = "JSDocConstructorType"; - SyntaxKind[SyntaxKind["JSDocThisType"] = 244] = "JSDocThisType"; - SyntaxKind[SyntaxKind["JSDocComment"] = 245] = "JSDocComment"; - SyntaxKind[SyntaxKind["JSDocTag"] = 246] = "JSDocTag"; - SyntaxKind[SyntaxKind["JSDocParameterTag"] = 247] = "JSDocParameterTag"; - SyntaxKind[SyntaxKind["JSDocReturnTag"] = 248] = "JSDocReturnTag"; - SyntaxKind[SyntaxKind["JSDocTypeTag"] = 249] = "JSDocTypeTag"; - SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 250] = "JSDocTemplateTag"; + SyntaxKind[SyntaxKind["JSDocUnknownType"] = 233] = "JSDocUnknownType"; + SyntaxKind[SyntaxKind["JSDocArrayType"] = 234] = "JSDocArrayType"; + SyntaxKind[SyntaxKind["JSDocUnionType"] = 235] = "JSDocUnionType"; + SyntaxKind[SyntaxKind["JSDocTupleType"] = 236] = "JSDocTupleType"; + SyntaxKind[SyntaxKind["JSDocNullableType"] = 237] = "JSDocNullableType"; + SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 238] = "JSDocNonNullableType"; + SyntaxKind[SyntaxKind["JSDocRecordType"] = 239] = "JSDocRecordType"; + SyntaxKind[SyntaxKind["JSDocRecordMember"] = 240] = "JSDocRecordMember"; + SyntaxKind[SyntaxKind["JSDocTypeReference"] = 241] = "JSDocTypeReference"; + SyntaxKind[SyntaxKind["JSDocOptionalType"] = 242] = "JSDocOptionalType"; + SyntaxKind[SyntaxKind["JSDocFunctionType"] = 243] = "JSDocFunctionType"; + SyntaxKind[SyntaxKind["JSDocVariadicType"] = 244] = "JSDocVariadicType"; + SyntaxKind[SyntaxKind["JSDocConstructorType"] = 245] = "JSDocConstructorType"; + SyntaxKind[SyntaxKind["JSDocThisType"] = 246] = "JSDocThisType"; + SyntaxKind[SyntaxKind["JSDocComment"] = 247] = "JSDocComment"; + SyntaxKind[SyntaxKind["JSDocTag"] = 248] = "JSDocTag"; + SyntaxKind[SyntaxKind["JSDocParameterTag"] = 249] = "JSDocParameterTag"; + SyntaxKind[SyntaxKind["JSDocReturnTag"] = 250] = "JSDocReturnTag"; + SyntaxKind[SyntaxKind["JSDocTypeTag"] = 251] = "JSDocTypeTag"; + SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 252] = "JSDocTemplateTag"; // Synthesized list - SyntaxKind[SyntaxKind["SyntaxList"] = 251] = "SyntaxList"; + SyntaxKind[SyntaxKind["SyntaxList"] = 253] = "SyntaxList"; // Enum value count - SyntaxKind[SyntaxKind["Count"] = 252] = "Count"; + SyntaxKind[SyntaxKind["Count"] = 254] = "Count"; // Markers SyntaxKind[SyntaxKind["FirstAssignment"] = 53] = "FirstAssignment"; SyntaxKind[SyntaxKind["LastAssignment"] = 64] = "LastAssignment"; SyntaxKind[SyntaxKind["FirstReservedWord"] = 66] = "FirstReservedWord"; SyntaxKind[SyntaxKind["LastReservedWord"] = 101] = "LastReservedWord"; SyntaxKind[SyntaxKind["FirstKeyword"] = 66] = "FirstKeyword"; - SyntaxKind[SyntaxKind["LastKeyword"] = 126] = "LastKeyword"; + SyntaxKind[SyntaxKind["LastKeyword"] = 127] = "LastKeyword"; SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 102] = "FirstFutureReservedWord"; SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 110] = "LastFutureReservedWord"; - SyntaxKind[SyntaxKind["FirstTypeNode"] = 142] = "FirstTypeNode"; - SyntaxKind[SyntaxKind["LastTypeNode"] = 150] = "LastTypeNode"; + SyntaxKind[SyntaxKind["FirstTypeNode"] = 144] = "FirstTypeNode"; + SyntaxKind[SyntaxKind["LastTypeNode"] = 152] = "LastTypeNode"; SyntaxKind[SyntaxKind["FirstPunctuation"] = 14] = "FirstPunctuation"; SyntaxKind[SyntaxKind["LastPunctuation"] = 64] = "LastPunctuation"; SyntaxKind[SyntaxKind["FirstToken"] = 0] = "FirstToken"; - SyntaxKind[SyntaxKind["LastToken"] = 126] = "LastToken"; + SyntaxKind[SyntaxKind["LastToken"] = 127] = "LastToken"; SyntaxKind[SyntaxKind["FirstTriviaToken"] = 2] = "FirstTriviaToken"; SyntaxKind[SyntaxKind["LastTriviaToken"] = 6] = "LastTriviaToken"; SyntaxKind[SyntaxKind["FirstLiteralToken"] = 7] = "FirstLiteralToken"; @@ -322,7 +324,7 @@ var ts; SyntaxKind[SyntaxKind["LastTemplateToken"] = 13] = "LastTemplateToken"; SyntaxKind[SyntaxKind["FirstBinaryOperator"] = 24] = "FirstBinaryOperator"; SyntaxKind[SyntaxKind["LastBinaryOperator"] = 64] = "LastBinaryOperator"; - SyntaxKind[SyntaxKind["FirstNode"] = 127] = "FirstNode"; + SyntaxKind[SyntaxKind["FirstNode"] = 128] = "FirstNode"; })(ts.SyntaxKind || (ts.SyntaxKind = {})); var SyntaxKind = ts.SyntaxKind; (function (NodeFlags) { @@ -349,9 +351,6 @@ var ts; /* @internal */ (function (ParserContextFlags) { ParserContextFlags[ParserContextFlags["None"] = 0] = "None"; - // Set if this node was parsed in strict mode. Used for grammar error checks, as well as - // checking if the node can be reused in incremental settings. - ParserContextFlags[ParserContextFlags["StrictMode"] = 1] = "StrictMode"; // If this node was parsed in a context where 'in-expressions' are not allowed. ParserContextFlags[ParserContextFlags["DisallowIn"] = 2] = "DisallowIn"; // If this node was parsed in the 'yield' context created when parsing a generator. @@ -368,7 +367,7 @@ var ts; // its type can be specified usign a JSDoc comment. ParserContextFlags[ParserContextFlags["JavaScriptFile"] = 64] = "JavaScriptFile"; // Context flags set directly by the parser. - ParserContextFlags[ParserContextFlags["ParserGeneratedFlags"] = 63] = "ParserGeneratedFlags"; + ParserContextFlags[ParserContextFlags["ParserGeneratedFlags"] = 62] = "ParserGeneratedFlags"; // Context flags computed by aggregating child flags upwards. // Used during incremental parsing to determine if this node or any of its children had an // error. Computed only once and then cached. @@ -494,8 +493,13 @@ var ts; SymbolFlags[SymbolFlags["ExportHasLocal"] = 944] = "ExportHasLocal"; SymbolFlags[SymbolFlags["HasExports"] = 1952] = "HasExports"; SymbolFlags[SymbolFlags["HasMembers"] = 6240] = "HasMembers"; + SymbolFlags[SymbolFlags["BlockScoped"] = 418] = "BlockScoped"; SymbolFlags[SymbolFlags["PropertyOrAccessor"] = 98308] = "PropertyOrAccessor"; SymbolFlags[SymbolFlags["Export"] = 7340032] = "Export"; + /* @internal */ + // The set of things we consider semantically classifiable. Used to speed up the LS during + // classification. + SymbolFlags[SymbolFlags["Classifiable"] = 788448] = "Classifiable"; })(ts.SymbolFlags || (ts.SymbolFlags = {})); var SymbolFlags = ts.SymbolFlags; /* @internal */ @@ -735,6 +739,36 @@ var ts; Ternary[Ternary["True"] = -1] = "True"; })(ts.Ternary || (ts.Ternary = {})); var Ternary = ts.Ternary; + function createFileMap(getCanonicalFileName) { + var files = {}; + return { + get: get, + set: set, + contains: contains, + remove: remove, + forEachValue: forEachValueInMap + }; + function set(fileName, value) { + files[normalizeKey(fileName)] = value; + } + function get(fileName) { + return files[normalizeKey(fileName)]; + } + function contains(fileName) { + return hasProperty(files, normalizeKey(fileName)); + } + function remove(fileName) { + var key = normalizeKey(fileName); + delete files[key]; + } + function forEachValueInMap(f) { + forEachValue(files, f); + } + function normalizeKey(key) { + return getCanonicalFileName(normalizeSlashes(key)); + } + } + ts.createFileMap = createFileMap; (function (Comparison) { Comparison[Comparison["LessThan"] = -1] = "LessThan"; Comparison[Comparison["EqualTo"] = 0] = "EqualTo"; @@ -1232,7 +1266,7 @@ var ts; function getNormalizedPathComponents(path, currentDirectory) { path = normalizeSlashes(path); var rootLength = getRootLength(path); - if (rootLength == 0) { + if (rootLength === 0) { // If the path is not rooted it is relative to current directory path = combinePaths(normalizeSlashes(currentDirectory), path); rootLength = getRootLength(path); @@ -1896,14 +1930,26 @@ var ts; A_class_declaration_without_the_default_modifier_must_have_a_name: { code: 1211, category: ts.DiagnosticCategory.Error, key: "A class declaration without the 'default' modifier must have a name" }, Identifier_expected_0_is_a_reserved_word_in_strict_mode: { code: 1212, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode" }, Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1213, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, - Type_expected_0_is_a_reserved_word_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode" }, - Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: ts.DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: { code: 1214, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode." }, + Invalid_use_of_0_Modules_are_automatically_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Invalid use of '{0}'. Modules are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: ts.DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalDecorators_to_remove_this_warning: { code: 1219, category: ts.DiagnosticCategory.Error, key: "Experimental support for decorators is a feature that is subject to change in a future release. Specify '--experimentalDecorators' to remove this warning." }, Generators_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 1220, category: ts.DiagnosticCategory.Error, key: "Generators are only available when targeting ECMAScript 6 or higher." }, Generators_are_not_allowed_in_an_ambient_context: { code: 1221, category: ts.DiagnosticCategory.Error, key: "Generators are not allowed in an ambient context." }, An_overload_signature_cannot_be_declared_as_a_generator: { code: 1222, category: ts.DiagnosticCategory.Error, key: "An overload signature cannot be declared as a generator." }, _0_tag_already_specified: { code: 1223, category: ts.DiagnosticCategory.Error, key: "'{0}' tag already specified." }, + Signature_0_must_have_a_type_predicate: { code: 1224, category: ts.DiagnosticCategory.Error, key: "Signature '{0}' must have a type predicate." }, + Cannot_find_parameter_0: { code: 1225, category: ts.DiagnosticCategory.Error, key: "Cannot find parameter '{0}'." }, + Type_predicate_0_is_not_assignable_to_1: { code: 1226, category: ts.DiagnosticCategory.Error, key: "Type predicate '{0}' is not assignable to '{1}'." }, + Parameter_0_is_not_in_the_same_position_as_parameter_1: { code: 1227, category: ts.DiagnosticCategory.Error, key: "Parameter '{0}' is not in the same position as parameter '{1}'." }, + A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: { code: 1228, category: ts.DiagnosticCategory.Error, key: "A type predicate is only allowed in return type position for functions and methods." }, + A_type_predicate_cannot_reference_a_rest_parameter: { code: 1229, category: ts.DiagnosticCategory.Error, key: "A type predicate cannot reference a rest parameter." }, + A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: { code: 1230, category: ts.DiagnosticCategory.Error, key: "A type predicate cannot reference element '{0}' in a binding pattern." }, + An_export_assignment_can_only_be_used_in_a_module: { code: 1231, category: ts.DiagnosticCategory.Error, key: "An export assignment can only be used in a module." }, + An_import_declaration_can_only_be_used_in_a_namespace_or_module: { code: 1232, category: ts.DiagnosticCategory.Error, key: "An import declaration can only be used in a namespace or module." }, + An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, + An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, + A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.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: ts.DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -2097,6 +2143,11 @@ var ts; Cannot_find_namespace_0: { code: 2503, category: ts.DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, No_best_common_type_exists_among_yield_expressions: { code: 2504, category: ts.DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: ts.DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, + _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: { code: 2506, category: ts.DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own base expression." }, + Type_0_is_not_a_constructor_function_type: { code: 2507, category: ts.DiagnosticCategory.Error, key: "Type '{0}' is not a constructor function type." }, + No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: ts.DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." }, + Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: ts.DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." }, + Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: ts.DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: ts.DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -2306,7 +2357,7 @@ var ts; "false": 80 /* FalseKeyword */, "finally": 81 /* FinallyKeyword */, "for": 82 /* ForKeyword */, - "from": 125 /* FromKeyword */, + "from": 126 /* FromKeyword */, "function": 83 /* FunctionKeyword */, "get": 116 /* GetKeyword */, "if": 84 /* IfKeyword */, @@ -2315,36 +2366,37 @@ var ts; "in": 86 /* InKeyword */, "instanceof": 87 /* InstanceOfKeyword */, "interface": 103 /* InterfaceKeyword */, + "is": 117 /* IsKeyword */, "let": 104 /* LetKeyword */, - "module": 117 /* ModuleKeyword */, - "namespace": 118 /* NamespaceKeyword */, + "module": 118 /* ModuleKeyword */, + "namespace": 119 /* NamespaceKeyword */, "new": 88 /* NewKeyword */, "null": 89 /* NullKeyword */, - "number": 120 /* NumberKeyword */, + "number": 121 /* NumberKeyword */, "package": 105 /* PackageKeyword */, "private": 106 /* PrivateKeyword */, "protected": 107 /* ProtectedKeyword */, "public": 108 /* PublicKeyword */, - "require": 119 /* RequireKeyword */, + "require": 120 /* RequireKeyword */, "return": 90 /* ReturnKeyword */, - "set": 121 /* SetKeyword */, + "set": 122 /* SetKeyword */, "static": 109 /* StaticKeyword */, - "string": 122 /* StringKeyword */, + "string": 123 /* StringKeyword */, "super": 91 /* SuperKeyword */, "switch": 92 /* SwitchKeyword */, - "symbol": 123 /* SymbolKeyword */, + "symbol": 124 /* SymbolKeyword */, "this": 93 /* ThisKeyword */, "throw": 94 /* ThrowKeyword */, "true": 95 /* TrueKeyword */, "try": 96 /* TryKeyword */, - "type": 124 /* TypeKeyword */, + "type": 125 /* TypeKeyword */, "typeof": 97 /* TypeOfKeyword */, "var": 98 /* VarKeyword */, "void": 99 /* VoidKeyword */, "while": 100 /* WhileKeyword */, "with": 101 /* WithKeyword */, "yield": 110 /* YieldKeyword */, - "of": 126 /* OfKeyword */, + "of": 127 /* OfKeyword */, "{": 14 /* OpenBraceToken */, "}": 15 /* CloseBraceToken */, "(": 16 /* OpenParenToken */, @@ -2604,8 +2656,31 @@ var ts; return ch >= 48 /* _0 */ && ch <= 55 /* _7 */; } ts.isOctalDigit = isOctalDigit; + function couldStartTrivia(text, pos) { + // Keep in sync with skipTrivia + var ch = text.charCodeAt(pos); + switch (ch) { + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 32 /* space */: + case 47 /* slash */: + // starts of normal trivia + case 60 /* lessThan */: + case 61 /* equals */: + case 62 /* greaterThan */: + // Starts of conflict marker trivia + return true; + default: + return ch > 127 /* maxAsciiCharacter */; + } + } + ts.couldStartTrivia = couldStartTrivia; /* @internal */ function skipTrivia(text, pos, stopAfterLineBreak) { + // Keep in sync with couldStartTrivia while (true) { var ch = text.charCodeAt(pos); switch (ch) { @@ -3109,7 +3184,7 @@ var ts; error(ts.Diagnostics.Unexpected_end_of_text); isInvalidExtendedEscape = true; } - else if (text.charCodeAt(pos) == 125 /* closeBrace */) { + else if (text.charCodeAt(pos) === 125 /* closeBrace */) { // Only swallow the following character up if it's a '}'. pos++; } @@ -3666,16 +3741,16 @@ var ts; function getModuleInstanceState(node) { // A module is uninstantiated if it contains only // 1. interface declarations, type alias declarations - if (node.kind === 203 /* InterfaceDeclaration */ || node.kind === 204 /* TypeAliasDeclaration */) { + if (node.kind === 205 /* InterfaceDeclaration */ || node.kind === 206 /* TypeAliasDeclaration */) { return 0 /* NonInstantiated */; } else if (ts.isConstEnumDeclaration(node)) { return 2 /* ConstEnumOnly */; } - else if ((node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */) && !(node.flags & 1 /* Export */)) { + else if ((node.kind === 212 /* ImportDeclaration */ || node.kind === 211 /* ImportEqualsDeclaration */) && !(node.flags & 1 /* Export */)) { return 0 /* NonInstantiated */; } - else if (node.kind === 207 /* ModuleBlock */) { + else if (node.kind === 209 /* ModuleBlock */) { var state = 0 /* NonInstantiated */; ts.forEachChild(node, function (n) { switch (getModuleInstanceState(n)) { @@ -3694,7 +3769,7 @@ var ts; }); return state; } - else if (node.kind === 206 /* ModuleDeclaration */) { + else if (node.kind === 208 /* ModuleDeclaration */) { return getModuleInstanceState(node.body); } else { @@ -3734,11 +3809,17 @@ var ts; var container; var blockScopeContainer; var lastContainer; + // If this file is an external module, then it is automatically in strict-mode according to + // ES6. If it is not an external module, then we'll determine if it is in strict mode or + // not depending on if we see "use strict" in certain places (or if we hit a class/namespace). + var inStrictMode = !!file.externalModuleIndicator; var symbolCount = 0; var Symbol = ts.objectAllocator.getSymbolConstructor(); + var classifiableNames = {}; if (!file.locals) { bind(file); file.symbolCount = symbolCount; + file.classifiableNames = classifiableNames; } return; function createSymbol(flags, name) { @@ -3766,10 +3847,10 @@ var ts; // unless it is a well known Symbol. function getDeclarationName(node) { if (node.name) { - if (node.kind === 206 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */) { + if (node.kind === 208 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */) { return '"' + node.name.text + '"'; } - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { var nameExpression = node.name.expression; ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); @@ -3777,22 +3858,22 @@ var ts; return node.name.text; } switch (node.kind) { - case 136 /* Constructor */: + case 137 /* Constructor */: return "__constructor"; - case 143 /* FunctionType */: - case 139 /* CallSignature */: + case 145 /* FunctionType */: + case 140 /* CallSignature */: return "__call"; - case 144 /* ConstructorType */: - case 140 /* ConstructSignature */: + case 146 /* ConstructorType */: + case 141 /* ConstructSignature */: return "__new"; - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: return "__index"; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return "__export"; - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return node.isExportEquals ? "export=" : "default"; - case 201 /* FunctionDeclaration */: - case 202 /* ClassDeclaration */: + case 203 /* FunctionDeclaration */: + case 204 /* ClassDeclaration */: return node.flags & 256 /* Default */ ? "default" : undefined; } } @@ -3826,6 +3907,9 @@ var ts; symbol = ts.hasProperty(symbolTable, name) ? symbolTable[name] : (symbolTable[name] = createSymbol(0 /* None */, name)); + if (name && (includes & 788448 /* Classifiable */)) { + classifiableNames[name] = name; + } if (symbol.flags & excludes) { if (node.name) { node.name.parent = node; @@ -3852,7 +3936,7 @@ var ts; function declareModuleMember(node, symbolFlags, symbolExcludes) { var hasExportModifier = ts.getCombinedNodeFlags(node) & 1 /* Export */; if (symbolFlags & 8388608 /* Alias */) { - if (node.kind === 218 /* ExportSpecifier */ || (node.kind === 209 /* ImportEqualsDeclaration */ && hasExportModifier)) { + if (node.kind === 220 /* ExportSpecifier */ || (node.kind === 211 /* ImportEqualsDeclaration */ && hasExportModifier)) { return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); } else { @@ -3933,36 +4017,37 @@ var ts; } function getContainerFlags(node) { switch (node.kind) { - case 175 /* ClassExpression */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 146 /* TypeLiteral */: - case 155 /* ObjectLiteralExpression */: + case 177 /* ClassExpression */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 148 /* TypeLiteral */: + case 157 /* ObjectLiteralExpression */: return 1 /* IsContainer */; - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 201 /* FunctionDeclaration */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 206 /* ModuleDeclaration */: - case 228 /* SourceFile */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 203 /* FunctionDeclaration */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 208 /* ModuleDeclaration */: + case 230 /* SourceFile */: + case 206 /* TypeAliasDeclaration */: return 5 /* IsContainerWithLocals */; - case 224 /* CatchClause */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 208 /* CaseBlock */: + case 226 /* CatchClause */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 210 /* CaseBlock */: return 2 /* IsBlockScopedContainer */; - case 180 /* Block */: + case 182 /* Block */: // do not treat blocks directly inside a function as a block-scoped-container. // Locals that reside in this block should go to the function locals. Othewise 'x' // would not appear to be a redeclaration of a block scoped local in the following @@ -3995,45 +4080,47 @@ var ts; } function declareSymbolAndAddToSymbolTableWorker(node, symbolFlags, symbolExcludes) { switch (container.kind) { - // Modules, source files, and classes need specialized handling for how their + // Modules, source files, and classes need specialized handling for how their // members are declared (for example, a member of a class will go into a specific - // symbol table depending on if it is static or not). As such, we defer to - // specialized handlers to take care of declaring these child members. - case 206 /* ModuleDeclaration */: + // symbol table depending on if it is static or not). We defer to specialized + // handlers to take care of declaring these child members. + case 208 /* ModuleDeclaration */: return declareModuleMember(node, symbolFlags, symbolExcludes); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return declareSourceFileMember(node, symbolFlags, symbolExcludes); - case 175 /* ClassExpression */: - case 202 /* ClassDeclaration */: + case 177 /* ClassExpression */: + case 204 /* ClassDeclaration */: return declareClassMember(node, symbolFlags, symbolExcludes); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); - case 146 /* TypeLiteral */: - case 155 /* ObjectLiteralExpression */: - case 203 /* InterfaceDeclaration */: + case 148 /* TypeLiteral */: + case 157 /* ObjectLiteralExpression */: + case 205 /* InterfaceDeclaration */: // Interface/Object-types always have their children added to the 'members' of - // their container. They are only accessible through an instance of their - // container, and are never in scope otherwise (even inside the body of the - // object / type / interface declaring them). + // their container. They are only accessible through an instance of their + // container, and are never in scope otherwise (even inside the body of the + // object / type / interface declaring them). An exception is type parameters, + // which are in scope without qualification (similar to 'locals'). return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 206 /* TypeAliasDeclaration */: // All the children of these container types are never visible through another - // symbol (i.e. through another symbol's 'exports' or 'members'). Instead, - // they're only accessed 'lexically' (i.e. from code that exists underneath + // symbol (i.e. through another symbol's 'exports' or 'members'). Instead, + // they're only accessed 'lexically' (i.e. from code that exists underneath // their container in the tree. To accomplish this, we simply add their declared - // symbol to the 'locals' of the container. These symbols can then be found as + // symbol to the 'locals' of the container. These symbols can then be found as // the type checker walks up the containers, checking them for matching names. return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes); } @@ -4058,11 +4145,11 @@ var ts; return false; } function hasExportDeclarations(node) { - var body = node.kind === 228 /* SourceFile */ ? node : node.body; - if (body.kind === 228 /* SourceFile */ || body.kind === 207 /* ModuleBlock */) { + var body = node.kind === 230 /* SourceFile */ ? node : node.body; + if (body.kind === 230 /* SourceFile */ || body.kind === 209 /* ModuleBlock */) { for (var _i = 0, _a = body.statements; _i < _a.length; _i++) { var stat = _a[_i]; - if (stat.kind === 216 /* ExportDeclaration */ || stat.kind === 215 /* ExportAssignment */) { + if (stat.kind === 218 /* ExportDeclaration */ || stat.kind === 217 /* ExportAssignment */) { return true; } } @@ -4117,16 +4204,54 @@ var ts; typeLiteralSymbol.members = (_a = {}, _a[symbol.name] = symbol, _a); var _a; } + function bindObjectLiteralExpression(node) { + var ElementKind; + (function (ElementKind) { + ElementKind[ElementKind["Property"] = 1] = "Property"; + ElementKind[ElementKind["Accessor"] = 2] = "Accessor"; + })(ElementKind || (ElementKind = {})); + if (inStrictMode) { + var seen = {}; + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var prop = _a[_i]; + if (prop.name.kind !== 65 /* Identifier */) { + continue; + } + var identifier = prop.name; + // ECMA-262 11.1.5 Object Initialiser + // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true + // a.This production is contained in strict code and IsDataDescriptor(previous) is true and + // IsDataDescriptor(propId.descriptor) is true. + // b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true. + // c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true. + // d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true + // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields + var currentKind = prop.kind === 227 /* PropertyAssignment */ || prop.kind === 228 /* ShorthandPropertyAssignment */ || prop.kind === 136 /* MethodDeclaration */ + ? 1 /* Property */ + : 2 /* Accessor */; + var existingKind = seen[identifier.text]; + if (!existingKind) { + seen[identifier.text] = currentKind; + continue; + } + if (currentKind === 1 /* Property */ && existingKind === 1 /* Property */) { + var span = ts.getErrorSpanForNode(file, identifier); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode)); + } + } + } + return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object"); + } function bindAnonymousDeclaration(node, symbolFlags, name) { var symbol = createSymbol(symbolFlags, name); addDeclarationToSymbol(symbol, node, symbolFlags); } function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) { switch (blockScopeContainer.kind) { - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: declareModuleMember(node, symbolFlags, symbolExcludes); break; - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolFlags, symbolExcludes); break; @@ -4143,11 +4268,126 @@ var ts; function bindBlockScopedVariableDeclaration(node) { bindBlockScopedDeclaration(node, 2 /* BlockScopedVariable */, 107455 /* BlockScopedVariableExcludes */); } + // The binder visits every node in the syntax tree so it is a convenient place to perform a single localized + // check for reserved words used as identifiers in strict mode code. + function checkStrictModeIdentifier(node) { + if (inStrictMode && + node.originalKeywordKind >= 102 /* FirstFutureReservedWord */ && + node.originalKeywordKind <= 110 /* LastFutureReservedWord */ && + !ts.isIdentifierName(node)) { + // Report error only if there are no parse errors in file + if (!file.parseDiagnostics.length) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node))); + } + } + } + function getStrictModeIdentifierMessage(node) { + // Provide specialized messages to help the user understand why we think they're in + // strict mode. + if (ts.getAncestor(node, 204 /* ClassDeclaration */) || ts.getAncestor(node, 177 /* ClassExpression */)) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode; + } + function checkStrictModeBinaryExpression(node) { + if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { + // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an + // Assignment operator(11.13) or of a PostfixExpression(11.3) + checkStrictModeEvalOrArguments(node, node.left); + } + } + function checkStrictModeCatchClause(node) { + // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the + // Catch production is eval or arguments + if (inStrictMode && node.variableDeclaration) { + checkStrictModeEvalOrArguments(node, node.variableDeclaration.name); + } + } + function checkStrictModeDeleteExpression(node) { + // Grammar checking + if (inStrictMode && node.expression.kind === 65 /* 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 + var span = ts.getErrorSpanForNode(file, node.expression); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode)); + } + } + function isEvalOrArgumentsIdentifier(node) { + return node.kind === 65 /* Identifier */ && + (node.text === "eval" || node.text === "arguments"); + } + function checkStrictModeEvalOrArguments(contextNode, name) { + if (name && name.kind === 65 /* Identifier */) { + var identifier = name; + if (isEvalOrArgumentsIdentifier(identifier)) { + // We check first if the name is inside class declaration or class expression; if so give explicit message + // otherwise report generic error message. + var span = ts.getErrorSpanForNode(file, name); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), identifier.text)); + } + } + } + function getStrictModeEvalOrArgumentsMessage(node) { + // Provide specialized messages to help the user understand why we think they're in + // strict mode. + if (ts.getAncestor(node, 204 /* ClassDeclaration */) || ts.getAncestor(node, 177 /* ClassExpression */)) { + return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Invalid_use_of_0_in_strict_mode; + } + function checkStrictModeFunctionName(node) { + if (inStrictMode) { + // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1)) + checkStrictModeEvalOrArguments(node, node.name); + } + } + function checkStrictModeNumericLiteral(node) { + if (inStrictMode && node.flags & 16384 /* OctalLiteral */) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode)); + } + } + function checkStrictModePostfixUnaryExpression(node) { + // Grammar checking + // 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 (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + function checkStrictModePrefixUnaryExpression(node) { + // Grammar checking + if (inStrictMode) { + if (node.operator === 38 /* PlusPlusToken */ || node.operator === 39 /* MinusMinusToken */) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + } + function checkStrictModeWithStatement(node) { + // Grammar checking for withStatement + if (inStrictMode) { + grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); + } + } + function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) { + var span = ts.getSpanOfTokenAtPosition(file, node.pos); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2)); + } function getDestructuringParameterName(node) { return "__" + ts.indexOf(node.parent.parameters, node); } function bind(node) { node.parent = parent; + var savedInStrictMode = inStrictMode; + if (!savedInStrictMode) { + updateStrictMode(node); + } // First we bind declaration nodes to a symbol if possible. We'll both create a symbol // and then potentially add the symbol to an appropriate symbol table. Possible // destination symbol tables are: @@ -4164,76 +4404,132 @@ var ts; // the current 'container' node when it changes. This helps us know which symbol table // a local should go into for example. bindChildren(node); + inStrictMode = savedInStrictMode; + } + function updateStrictMode(node) { + switch (node.kind) { + case 230 /* SourceFile */: + case 209 /* ModuleBlock */: + updateStrictModeStatementList(node.statements); + return; + case 182 /* Block */: + if (ts.isFunctionLike(node.parent)) { + updateStrictModeStatementList(node.statements); + } + return; + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + // All classes are automatically in strict mode in ES6. + inStrictMode = true; + return; + } + } + function updateStrictModeStatementList(statements) { + for (var _i = 0; _i < statements.length; _i++) { + var statement = statements[_i]; + if (!ts.isPrologueDirective(statement)) { + return; + } + if (isUseStrictPrologueDirective(statement)) { + inStrictMode = true; + return; + } + } + } + /// Should be called only on prologue directives (isPrologueDirective(node) should be true) + function isUseStrictPrologueDirective(node) { + var nodeText = ts.getTextOfNodeFromSourceText(file.text, node.expression); + // Note: the node text must be exactly "use strict" or 'use strict'. It is not ok for the + // string to contain unicode escapes (as per ES5). + return nodeText === '"use strict"' || nodeText === "'use strict'"; } function bindWorker(node) { switch (node.kind) { - case 129 /* TypeParameter */: + case 65 /* Identifier */: + return checkStrictModeIdentifier(node); + case 172 /* BinaryExpression */: + return checkStrictModeBinaryExpression(node); + case 226 /* CatchClause */: + return checkStrictModeCatchClause(node); + case 167 /* DeleteExpression */: + return checkStrictModeDeleteExpression(node); + case 7 /* NumericLiteral */: + return checkStrictModeNumericLiteral(node); + case 171 /* PostfixUnaryExpression */: + return checkStrictModePostfixUnaryExpression(node); + case 170 /* PrefixUnaryExpression */: + return checkStrictModePrefixUnaryExpression(node); + case 195 /* WithStatement */: + return checkStrictModeWithStatement(node); + case 130 /* TypeParameter */: return declareSymbolAndAddToSymbolTable(node, 262144 /* TypeParameter */, 530912 /* TypeParameterExcludes */); - case 130 /* Parameter */: + case 131 /* Parameter */: return bindParameter(node); - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: return bindVariableDeclarationOrBindingElement(node); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return bindPropertyOrMethodOrAccessor(node, 4 /* Property */ | (node.questionToken ? 536870912 /* Optional */ : 0 /* None */), 107455 /* PropertyExcludes */); - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: + case 227 /* PropertyAssignment */: + case 228 /* ShorthandPropertyAssignment */: return bindPropertyOrMethodOrAccessor(node, 4 /* Property */, 107455 /* PropertyExcludes */); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return bindPropertyOrMethodOrAccessor(node, 8 /* EnumMember */, 107455 /* EnumMemberExcludes */); - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: return declareSymbolAndAddToSymbolTable(node, 131072 /* Signature */, 0 /* None */); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: // If this is an ObjectLiteralExpression method, then it sits in the same space // as other properties in the object literal. So we use SymbolFlags.PropertyExcludes // so that it will conflict with any other object literal members with the same // name. return bindPropertyOrMethodOrAccessor(node, 8192 /* Method */ | (node.questionToken ? 536870912 /* Optional */ : 0 /* None */), ts.isObjectLiteralMethod(node) ? 107455 /* PropertyExcludes */ : 99263 /* MethodExcludes */); - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: + checkStrictModeFunctionName(node); return declareSymbolAndAddToSymbolTable(node, 16 /* Function */, 106927 /* FunctionExcludes */); - case 136 /* Constructor */: + case 137 /* Constructor */: return declareSymbolAndAddToSymbolTable(node, 16384 /* Constructor */, 0 /* None */); - case 137 /* GetAccessor */: + case 138 /* GetAccessor */: return bindPropertyOrMethodOrAccessor(node, 32768 /* GetAccessor */, 41919 /* GetAccessorExcludes */); - case 138 /* SetAccessor */: + case 139 /* SetAccessor */: return bindPropertyOrMethodOrAccessor(node, 65536 /* SetAccessor */, 74687 /* SetAccessorExcludes */); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return bindFunctionOrConstructorType(node); - case 146 /* TypeLiteral */: + case 148 /* TypeLiteral */: return bindAnonymousDeclaration(node, 2048 /* TypeLiteral */, "__type"); - case 155 /* ObjectLiteralExpression */: - return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object"); - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 157 /* ObjectLiteralExpression */: + return bindObjectLiteralExpression(node); + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + checkStrictModeFunctionName(node); return bindAnonymousDeclaration(node, 16 /* Function */, "__function"); - case 175 /* ClassExpression */: - case 202 /* ClassDeclaration */: + case 177 /* ClassExpression */: + case 204 /* ClassDeclaration */: return bindClassLikeDeclaration(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return bindBlockScopedDeclaration(node, 64 /* Interface */, 792992 /* InterfaceExcludes */); - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: return bindBlockScopedDeclaration(node, 524288 /* TypeAlias */, 793056 /* TypeAliasExcludes */); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return bindEnumDeclaration(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return bindModuleDeclaration(node); - case 209 /* ImportEqualsDeclaration */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 214 /* NamespaceImport */: + case 216 /* ImportSpecifier */: + case 220 /* ExportSpecifier */: return declareSymbolAndAddToSymbolTable(node, 8388608 /* Alias */, 8388608 /* AliasExcludes */); - case 211 /* ImportClause */: + case 213 /* ImportClause */: return bindImportClause(node); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return bindExportDeclaration(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return bindExportAssignment(node); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return bindSourceFileIfExternalModule(); } } @@ -4244,7 +4540,11 @@ var ts; } } function bindExportAssignment(node) { - if (node.expression.kind === 65 /* Identifier */) { + if (!container.symbol || !container.symbol.exports) { + // Export assignment in some sort of block construct + bindAnonymousDeclaration(node, 8388608 /* Alias */, getDeclarationName(node)); + } + else if (node.expression.kind === 65 /* Identifier */) { // An export default clause with an identifier exports all meanings of that identifier declareSymbol(container.symbol.exports, container.symbol, node, 8388608 /* Alias */, 107455 /* PropertyExcludes */ | 8388608 /* AliasExcludes */); } @@ -4254,7 +4554,11 @@ var ts; } } function bindExportDeclaration(node) { - if (!node.exportClause) { + if (!container.symbol || !container.symbol.exports) { + // Export * in some sort of block construct + bindAnonymousDeclaration(node, 1073741824 /* ExportStar */, getDeclarationName(node)); + } + else if (!node.exportClause) { // All export * declarations are collected in an __export symbol declareSymbol(container.symbol.exports, container.symbol, node, 1073741824 /* ExportStar */, 0 /* None */); } @@ -4265,7 +4569,7 @@ var ts; } } function bindClassLikeDeclaration(node) { - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { bindBlockScopedDeclaration(node, 32 /* Class */, 899583 /* ClassExcludes */); } else { @@ -4297,6 +4601,9 @@ var ts; : bindBlockScopedDeclaration(node, 256 /* RegularEnum */, 899327 /* RegularEnumExcludes */); } function bindVariableDeclarationOrBindingElement(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } if (!ts.isBindingPattern(node.name)) { if (ts.isBlockOrCatchScoped(node)) { bindBlockScopedVariableDeclaration(node); @@ -4319,6 +4626,11 @@ var ts; } } function bindParameter(node) { + if (inStrictMode) { + // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a + // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) + checkStrictModeEvalOrArguments(node, node.name); + } if (ts.isBindingPattern(node.name)) { bindAnonymousDeclaration(node, 1 /* FunctionScopedVariable */, getDestructuringParameterName(node)); } @@ -4328,8 +4640,8 @@ var ts; // If this is a property-parameter, then also declare the property symbol into the // containing class. if (node.flags & 112 /* AccessibilityModifier */ && - node.parent.kind === 136 /* Constructor */ && - (node.parent.parent.kind === 202 /* ClassDeclaration */ || node.parent.parent.kind === 175 /* ClassExpression */)) { + node.parent.kind === 137 /* Constructor */ && + (node.parent.parent.kind === 204 /* ClassDeclaration */ || node.parent.parent.kind === 177 /* ClassExpression */)) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* Property */, 107455 /* PropertyExcludes */); } @@ -4359,7 +4671,7 @@ var ts; // Pool writers to avoid needing to allocate them for every symbol we write. var stringWriters = []; function getSingleLineStringWriter() { - if (stringWriters.length == 0) { + if (stringWriters.length === 0) { var str = ""; var writeText = function (text) { return str += text; }; return { @@ -4416,7 +4728,7 @@ var ts; } } function getSourceFileOfNode(node) { - while (node && node.kind !== 228 /* SourceFile */) { + while (node && node.kind !== 230 /* SourceFile */) { node = node.parent; } return node; @@ -4526,15 +4838,15 @@ var ts; return current; } switch (current.kind) { - case 228 /* SourceFile */: - case 208 /* CaseBlock */: - case 224 /* CatchClause */: - case 206 /* ModuleDeclaration */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 230 /* SourceFile */: + case 210 /* CaseBlock */: + case 226 /* CatchClause */: + case 208 /* ModuleDeclaration */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: return current; - case 180 /* Block */: + case 182 /* Block */: // function block is not considered block-scope container // see comment in binder.ts: bind(...), case for SyntaxKind.Block if (!isFunctionLike(current.parent)) { @@ -4547,9 +4859,9 @@ var ts; ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer; function isCatchClauseVariableDeclaration(declaration) { return declaration && - declaration.kind === 199 /* VariableDeclaration */ && + declaration.kind === 201 /* VariableDeclaration */ && declaration.parent && - declaration.parent.kind === 224 /* CatchClause */; + declaration.parent.kind === 226 /* CatchClause */; } ts.isCatchClauseVariableDeclaration = isCatchClauseVariableDeclaration; // Return display name of an identifier @@ -4588,7 +4900,7 @@ var ts; function getErrorSpanForNode(sourceFile, node) { var errorNode = node; switch (node.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: var pos_1 = ts.skipTrivia(sourceFile.text, 0, false); if (pos_1 === sourceFile.text.length) { // file is empty - return span for the beginning of the file @@ -4597,16 +4909,16 @@ var ts; return getSpanOfTokenAtPosition(sourceFile, pos_1); // This list is a work in progress. Add missing node kinds to improve their error // spans. - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + case 205 /* InterfaceDeclaration */: + case 208 /* ModuleDeclaration */: + case 207 /* EnumDeclaration */: + case 229 /* EnumMember */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: errorNode = node.name; break; } @@ -4630,11 +4942,11 @@ var ts; } ts.isDeclarationFile = isDeclarationFile; function isConstEnumDeclaration(node) { - return node.kind === 205 /* EnumDeclaration */ && isConst(node); + return node.kind === 207 /* EnumDeclaration */ && isConst(node); } ts.isConstEnumDeclaration = isConstEnumDeclaration; function walkUpBindingElementsAndPatterns(node) { - while (node && (node.kind === 153 /* BindingElement */ || isBindingPattern(node))) { + while (node && (node.kind === 155 /* BindingElement */ || isBindingPattern(node))) { node = node.parent; } return node; @@ -4649,14 +4961,14 @@ var ts; function getCombinedNodeFlags(node) { node = walkUpBindingElementsAndPatterns(node); var flags = node.flags; - if (node.kind === 199 /* VariableDeclaration */) { + if (node.kind === 201 /* VariableDeclaration */) { node = node.parent; } - if (node && node.kind === 200 /* VariableDeclarationList */) { + if (node && node.kind === 202 /* VariableDeclarationList */) { flags |= node.flags; node = node.parent; } - if (node && node.kind === 181 /* VariableStatement */) { + if (node && node.kind === 183 /* VariableStatement */) { flags |= node.flags; } return flags; @@ -4671,12 +4983,12 @@ var ts; } ts.isLet = isLet; function isPrologueDirective(node) { - return node.kind === 183 /* ExpressionStatement */ && node.expression.kind === 8 /* StringLiteral */; + return node.kind === 185 /* ExpressionStatement */ && node.expression.kind === 8 /* StringLiteral */; } ts.isPrologueDirective = isPrologueDirective; function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { // If parameter/type parameter, the prev token trailing comments are part of this node too - if (node.kind === 130 /* Parameter */ || node.kind === 129 /* TypeParameter */) { + if (node.kind === 131 /* Parameter */ || node.kind === 130 /* TypeParameter */) { // e.g. (/** blah */ a, /** blah */ b); // e.g.: ( // /** blah */ a, @@ -4700,40 +5012,40 @@ var ts; ts.getJsDocComments = getJsDocComments; ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/; function isTypeNode(node) { - if (142 /* FirstTypeNode */ <= node.kind && node.kind <= 150 /* LastTypeNode */) { + if (144 /* FirstTypeNode */ <= node.kind && node.kind <= 152 /* LastTypeNode */) { return true; } switch (node.kind) { case 112 /* AnyKeyword */: - case 120 /* NumberKeyword */: - case 122 /* StringKeyword */: + case 121 /* NumberKeyword */: + case 123 /* StringKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: return true; case 99 /* VoidKeyword */: - return node.parent.kind !== 167 /* VoidExpression */; + return node.parent.kind !== 169 /* VoidExpression */; case 8 /* StringLiteral */: // Specialized signatures can have string literals as their parameters' type names - return node.parent.kind === 130 /* Parameter */; - case 177 /* ExpressionWithTypeArguments */: - return true; + return node.parent.kind === 131 /* Parameter */; + case 179 /* ExpressionWithTypeArguments */: + return !isExpressionWithTypeArgumentsInClassExtendsClause(node); // Identifiers and qualified names may be type nodes, depending on their context. Climb // above them to find the lowest container case 65 /* Identifier */: // If the identifier is the RHS of a qualified name, then it's a type iff its parent is. - if (node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node) { + if (node.parent.kind === 128 /* QualifiedName */ && node.parent.right === node) { node = node.parent; } - else if (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node) { + else if (node.parent.kind === 158 /* PropertyAccessExpression */ && node.parent.name === node) { node = node.parent; } // fall through - case 127 /* QualifiedName */: - case 156 /* PropertyAccessExpression */: + case 128 /* QualifiedName */: + case 158 /* PropertyAccessExpression */: // At this point, node is either a qualified name or an identifier - ts.Debug.assert(node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */ || node.kind === 156 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); + ts.Debug.assert(node.kind === 65 /* Identifier */ || node.kind === 128 /* QualifiedName */ || node.kind === 158 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); var parent_1 = node.parent; - if (parent_1.kind === 145 /* TypeQuery */) { + if (parent_1.kind === 147 /* TypeQuery */) { return false; } // Do not recursively call isTypeNode on the parent. In the example: @@ -4742,38 +5054,38 @@ var ts; // // Calling isTypeNode would consider the qualified name A.B a type node. Only C or // A.B.C is a type node. - if (142 /* FirstTypeNode */ <= parent_1.kind && parent_1.kind <= 150 /* LastTypeNode */) { + if (144 /* FirstTypeNode */ <= parent_1.kind && parent_1.kind <= 152 /* LastTypeNode */) { return true; } switch (parent_1.kind) { - case 177 /* ExpressionWithTypeArguments */: - return true; - case 129 /* TypeParameter */: + case 179 /* ExpressionWithTypeArguments */: + return !isExpressionWithTypeArgumentsInClassExtendsClause(parent_1); + case 130 /* TypeParameter */: return node === parent_1.constraint; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 131 /* Parameter */: + case 201 /* VariableDeclaration */: return node === parent_1.type; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 136 /* Constructor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 137 /* Constructor */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return node === parent_1.type; - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: return node === parent_1.type; - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return node === parent_1.type; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return parent_1.typeArguments && ts.indexOf(parent_1.typeArguments, node) >= 0; - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: // TODO (drosen): TaggedTemplateExpressions may eventually support type arguments. return false; } @@ -4787,23 +5099,23 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: return visitor(node); - case 208 /* CaseBlock */: - case 180 /* Block */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: + case 210 /* CaseBlock */: + case 182 /* Block */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 195 /* WithStatement */: + case 196 /* SwitchStatement */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: + case 197 /* LabeledStatement */: + case 199 /* TryStatement */: + case 226 /* CatchClause */: return ts.forEachChild(node, traverse); } } @@ -4813,17 +5125,17 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: visitor(node); var operand = node.expression; if (operand) { traverse(operand); } - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 202 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 205 /* InterfaceDeclaration */: + case 208 /* ModuleDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 204 /* ClassDeclaration */: // These are not allowed inside a generator now, but eventually they may be allowed // as local types. Regardless, any yield statements contained within them should be // skipped in this traversal. @@ -4831,7 +5143,7 @@ var ts; default: if (isFunctionLike(node)) { var name_4 = node.name; - if (name_4 && name_4.kind === 128 /* ComputedPropertyName */) { + if (name_4 && name_4.kind === 129 /* ComputedPropertyName */) { // Note that we will not include methods/accessors of a class because they would require // first descending into the class. This is by design. traverse(name_4.expression); @@ -4850,14 +5162,14 @@ var ts; function isVariableLike(node) { if (node) { switch (node.kind) { - case 153 /* BindingElement */: - case 227 /* EnumMember */: - case 130 /* Parameter */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 226 /* ShorthandPropertyAssignment */: - case 199 /* VariableDeclaration */: + case 155 /* BindingElement */: + case 229 /* EnumMember */: + case 131 /* Parameter */: + case 227 /* PropertyAssignment */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 228 /* ShorthandPropertyAssignment */: + case 201 /* VariableDeclaration */: return true; } } @@ -4867,8 +5179,8 @@ var ts; function isAccessor(node) { if (node) { switch (node.kind) { - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return true; } } @@ -4877,26 +5189,26 @@ var ts; ts.isAccessor = isAccessor; function isClassLike(node) { if (node) { - return node.kind === 202 /* ClassDeclaration */ || node.kind === 175 /* ClassExpression */; + return node.kind === 204 /* ClassDeclaration */ || node.kind === 177 /* ClassExpression */; } } ts.isClassLike = isClassLike; function isFunctionLike(node) { if (node) { switch (node.kind) { - case 136 /* Constructor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 137 /* Constructor */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return true; } } @@ -4904,11 +5216,11 @@ var ts; } ts.isFunctionLike = isFunctionLike; function isFunctionBlock(node) { - return node && node.kind === 180 /* Block */ && isFunctionLike(node.parent); + return node && node.kind === 182 /* Block */ && isFunctionLike(node.parent); } ts.isFunctionBlock = isFunctionBlock; function isObjectLiteralMethod(node) { - return node && node.kind === 135 /* MethodDeclaration */ && node.parent.kind === 155 /* ObjectLiteralExpression */; + return node && node.kind === 136 /* MethodDeclaration */ && node.parent.kind === 157 /* ObjectLiteralExpression */; } ts.isObjectLiteralMethod = isObjectLiteralMethod; function getContainingFunction(node) { @@ -4927,12 +5239,12 @@ var ts; return undefined; } switch (node.kind) { - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: // If the grandparent node is an object literal (as opposed to a class), // then the computed property is not a 'this' container. // A computed property name in a class needs to be a this container // so that we can error on it. - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.parent.kind === 204 /* ClassDeclaration */) { return node; } // If this is a computed property, then the parent should not @@ -4942,9 +5254,9 @@ var ts; // the *body* of the container. node = node.parent; break; - case 131 /* Decorator */: + case 132 /* Decorator */: // Decorators are always applied outside of the body of a class or method. - if (node.parent.kind === 130 /* Parameter */ && isClassElement(node.parent.parent)) { + if (node.parent.kind === 131 /* Parameter */ && isClassElement(node.parent.parent)) { // If the decorator's parent is a Parameter, we resolve the this container from // the grandparent class declaration. node = node.parent.parent; @@ -4955,23 +5267,23 @@ var ts; node = node.parent; } break; - case 164 /* ArrowFunction */: + case 166 /* ArrowFunction */: if (!includeArrowFunctions) { continue; } // Fall through - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 206 /* ModuleDeclaration */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 205 /* EnumDeclaration */: - case 228 /* SourceFile */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 208 /* ModuleDeclaration */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 207 /* EnumDeclaration */: + case 230 /* SourceFile */: return node; } } @@ -4983,12 +5295,12 @@ var ts; if (!node) return node; switch (node.kind) { - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: // If the grandparent node is an object literal (as opposed to a class), // then the computed property is not a 'super' container. // A computed property name in a class needs to be a super container // so that we can error on it. - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.parent.kind === 204 /* ClassDeclaration */) { return node; } // If this is a computed property, then the parent should not @@ -4998,9 +5310,9 @@ var ts; // the *body* of the container. node = node.parent; break; - case 131 /* Decorator */: + case 132 /* Decorator */: // Decorators are always applied outside of the body of a class or method. - if (node.parent.kind === 130 /* Parameter */ && isClassElement(node.parent.parent)) { + if (node.parent.kind === 131 /* Parameter */ && isClassElement(node.parent.parent)) { // If the decorator's parent is a Parameter, we resolve the this container from // the grandparent class declaration. node = node.parent.parent; @@ -5011,26 +5323,26 @@ var ts; node = node.parent; } break; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: if (!includeFunctions) { continue; } - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return node; } } } ts.getSuperContainer = getSuperContainer; function getInvokedExpression(node) { - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 162 /* TaggedTemplateExpression */) { return node.tag; } // Will either be a CallExpression or NewExpression. @@ -5039,44 +5351,44 @@ var ts; ts.getInvokedExpression = getInvokedExpression; function nodeCanBeDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: // classes are valid targets return true; - case 133 /* PropertyDeclaration */: + case 134 /* PropertyDeclaration */: // property declarations are valid if their parent is a class declaration. - return node.parent.kind === 202 /* ClassDeclaration */; - case 130 /* Parameter */: + return node.parent.kind === 204 /* ClassDeclaration */; + case 131 /* Parameter */: // if the parameter's parent has a body and its grandparent is a class declaration, this is a valid target; - return node.parent.body && node.parent.parent.kind === 202 /* ClassDeclaration */; - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 135 /* MethodDeclaration */: + return node.parent.body && node.parent.parent.kind === 204 /* ClassDeclaration */; + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 136 /* MethodDeclaration */: // if this method has a body and its parent is a class declaration, this is a valid target. - return node.body && node.parent.kind === 202 /* ClassDeclaration */; + return node.body && node.parent.kind === 204 /* ClassDeclaration */; } return false; } ts.nodeCanBeDecorated = nodeCanBeDecorated; function nodeIsDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: if (node.decorators) { return true; } return false; - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 131 /* Parameter */: if (node.decorators) { return true; } return false; - case 137 /* GetAccessor */: + case 138 /* GetAccessor */: if (node.body && node.decorators) { return true; } return false; - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 136 /* MethodDeclaration */: + case 139 /* SetAccessor */: if (node.body && node.decorators) { return true; } @@ -5087,10 +5399,10 @@ var ts; ts.nodeIsDecorated = nodeIsDecorated; function childIsDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return ts.forEach(node.members, nodeOrChildIsDecorated); - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 136 /* MethodDeclaration */: + case 139 /* SetAccessor */: return ts.forEach(node.parameters, nodeIsDecorated); } return false; @@ -5108,38 +5420,38 @@ var ts; case 95 /* TrueKeyword */: case 80 /* FalseKeyword */: case 9 /* RegularExpressionLiteral */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 160 /* TaggedTemplateExpression */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 163 /* FunctionExpression */: - case 175 /* ClassExpression */: - case 164 /* ArrowFunction */: - case 167 /* VoidExpression */: - case 165 /* DeleteExpression */: - case 166 /* TypeOfExpression */: - case 168 /* PrefixUnaryExpression */: - case 169 /* PostfixUnaryExpression */: - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 172 /* TemplateExpression */: + case 156 /* ArrayLiteralExpression */: + case 157 /* ObjectLiteralExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 162 /* TaggedTemplateExpression */: + case 163 /* TypeAssertionExpression */: + case 164 /* ParenthesizedExpression */: + case 165 /* FunctionExpression */: + case 177 /* ClassExpression */: + case 166 /* ArrowFunction */: + case 169 /* VoidExpression */: + case 167 /* DeleteExpression */: + case 168 /* TypeOfExpression */: + case 170 /* PrefixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: + case 172 /* BinaryExpression */: + case 173 /* ConditionalExpression */: + case 176 /* SpreadElementExpression */: + case 174 /* TemplateExpression */: case 10 /* NoSubstitutionTemplateLiteral */: - case 176 /* OmittedExpression */: - case 173 /* YieldExpression */: + case 178 /* OmittedExpression */: + case 175 /* YieldExpression */: return true; - case 127 /* QualifiedName */: - while (node.parent.kind === 127 /* QualifiedName */) { + case 128 /* QualifiedName */: + while (node.parent.kind === 128 /* QualifiedName */) { node = node.parent; } - return node.parent.kind === 145 /* TypeQuery */; + return node.parent.kind === 147 /* TypeQuery */; case 65 /* Identifier */: - if (node.parent.kind === 145 /* TypeQuery */) { + if (node.parent.kind === 147 /* TypeQuery */) { return true; } // fall through @@ -5147,43 +5459,45 @@ var ts; case 8 /* StringLiteral */: var parent_2 = node.parent; switch (parent_2.kind) { - case 199 /* VariableDeclaration */: - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 227 /* EnumMember */: - case 225 /* PropertyAssignment */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 131 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 229 /* EnumMember */: + case 227 /* PropertyAssignment */: + case 155 /* BindingElement */: return parent_2.initializer === node; - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 192 /* ReturnStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 196 /* ThrowStatement */: - case 194 /* SwitchStatement */: + case 185 /* ExpressionStatement */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 194 /* ReturnStatement */: + case 195 /* WithStatement */: + case 196 /* SwitchStatement */: + case 223 /* CaseClause */: + case 198 /* ThrowStatement */: + case 196 /* SwitchStatement */: return parent_2.expression === node; - case 187 /* ForStatement */: + case 189 /* ForStatement */: var forStatement = parent_2; - return (forStatement.initializer === node && forStatement.initializer.kind !== 200 /* VariableDeclarationList */) || + return (forStatement.initializer === node && forStatement.initializer.kind !== 202 /* VariableDeclarationList */) || forStatement.condition === node || forStatement.incrementor === node; - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: var forInStatement = parent_2; - return (forInStatement.initializer === node && forInStatement.initializer.kind !== 200 /* VariableDeclarationList */) || + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 202 /* VariableDeclarationList */) || forInStatement.expression === node; - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return node === parent_2.expression; - case 178 /* TemplateSpan */: + case 180 /* TemplateSpan */: return node === parent_2.expression; - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: return node === parent_2.expression; - case 131 /* Decorator */: + case 132 /* Decorator */: return true; + case 179 /* ExpressionWithTypeArguments */: + return parent_2.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent_2); default: if (isExpression(parent_2)) { return true; @@ -5200,7 +5514,7 @@ var ts; } ts.isInstantiatedModule = isInstantiatedModule; function isExternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 220 /* ExternalModuleReference */; + return node.kind === 211 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 222 /* ExternalModuleReference */; } ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; function getExternalModuleImportEqualsDeclarationExpression(node) { @@ -5209,20 +5523,20 @@ var ts; } ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; function isInternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 220 /* ExternalModuleReference */; + return node.kind === 211 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 222 /* ExternalModuleReference */; } ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; function getExternalModuleName(node) { - if (node.kind === 210 /* ImportDeclaration */) { + if (node.kind === 212 /* ImportDeclaration */) { return node.moduleSpecifier; } - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 211 /* ImportEqualsDeclaration */) { var reference = node.moduleReference; - if (reference.kind === 220 /* ExternalModuleReference */) { + if (reference.kind === 222 /* ExternalModuleReference */) { return reference.expression; } } - if (node.kind === 216 /* ExportDeclaration */) { + if (node.kind === 218 /* ExportDeclaration */) { return node.moduleSpecifier; } } @@ -5230,15 +5544,15 @@ var ts; function hasQuestionToken(node) { if (node) { switch (node.kind) { - case 130 /* Parameter */: + case 131 /* Parameter */: return node.questionToken !== undefined; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return node.questionToken !== undefined; - case 226 /* ShorthandPropertyAssignment */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 228 /* ShorthandPropertyAssignment */: + case 227 /* PropertyAssignment */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return node.questionToken !== undefined; } } @@ -5246,9 +5560,9 @@ var ts; } ts.hasQuestionToken = hasQuestionToken; function isJSDocConstructSignature(node) { - return node.kind === 241 /* JSDocFunctionType */ && + return node.kind === 243 /* JSDocFunctionType */ && node.parameters.length > 0 && - node.parameters[0].type.kind === 243 /* JSDocConstructorType */; + node.parameters[0].type.kind === 245 /* JSDocConstructorType */; } ts.isJSDocConstructSignature = isJSDocConstructSignature; function getJSDocTag(node, kind) { @@ -5262,15 +5576,15 @@ var ts; } } function getJSDocTypeTag(node) { - return getJSDocTag(node, 249 /* JSDocTypeTag */); + return getJSDocTag(node, 251 /* JSDocTypeTag */); } ts.getJSDocTypeTag = getJSDocTypeTag; function getJSDocReturnTag(node) { - return getJSDocTag(node, 248 /* JSDocReturnTag */); + return getJSDocTag(node, 250 /* JSDocReturnTag */); } ts.getJSDocReturnTag = getJSDocReturnTag; function getJSDocTemplateTag(node) { - return getJSDocTag(node, 250 /* JSDocTemplateTag */); + return getJSDocTag(node, 252 /* JSDocTemplateTag */); } ts.getJSDocTemplateTag = getJSDocTemplateTag; function getCorrespondingJSDocParameterTag(parameter) { @@ -5281,7 +5595,7 @@ var ts; var docComment = parameter.parent.jsDocComment; if (docComment) { return ts.forEach(docComment.tags, function (t) { - if (t.kind === 247 /* JSDocParameterTag */) { + if (t.kind === 249 /* JSDocParameterTag */) { var parameterTag = t; var name_5 = parameterTag.preParameterName || parameterTag.postParameterName; if (name_5.text === parameterName) { @@ -5300,12 +5614,12 @@ var ts; function isRestParameter(node) { if (node) { if (node.parserContextFlags & 64 /* JavaScriptFile */) { - if (node.type && node.type.kind === 242 /* JSDocVariadicType */) { + if (node.type && node.type.kind === 244 /* JSDocVariadicType */) { return true; } var paramTag = getCorrespondingJSDocParameterTag(node); if (paramTag && paramTag.typeExpression) { - return paramTag.typeExpression.type.kind === 242 /* JSDocVariadicType */; + return paramTag.typeExpression.type.kind === 244 /* JSDocVariadicType */; } } return node.dotDotDotToken !== undefined; @@ -5326,7 +5640,7 @@ var ts; } ts.isTemplateLiteralKind = isTemplateLiteralKind; function isBindingPattern(node) { - return !!node && (node.kind === 152 /* ArrayBindingPattern */ || node.kind === 151 /* ObjectBindingPattern */); + return !!node && (node.kind === 154 /* ArrayBindingPattern */ || node.kind === 153 /* ObjectBindingPattern */); } ts.isBindingPattern = isBindingPattern; function isInAmbientContext(node) { @@ -5341,33 +5655,33 @@ var ts; ts.isInAmbientContext = isInAmbientContext; function isDeclaration(node) { switch (node.kind) { - case 164 /* ArrowFunction */: - case 153 /* BindingElement */: - case 202 /* ClassDeclaration */: - case 136 /* Constructor */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 218 /* ExportSpecifier */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 137 /* GetAccessor */: - case 211 /* ImportClause */: - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 203 /* InterfaceDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 206 /* ModuleDeclaration */: - case 212 /* NamespaceImport */: - case 130 /* Parameter */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 138 /* SetAccessor */: - case 226 /* ShorthandPropertyAssignment */: - case 204 /* TypeAliasDeclaration */: - case 129 /* TypeParameter */: - case 199 /* VariableDeclaration */: + case 166 /* ArrowFunction */: + case 155 /* BindingElement */: + case 204 /* ClassDeclaration */: + case 137 /* Constructor */: + case 207 /* EnumDeclaration */: + case 229 /* EnumMember */: + case 220 /* ExportSpecifier */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 138 /* GetAccessor */: + case 213 /* ImportClause */: + case 211 /* ImportEqualsDeclaration */: + case 216 /* ImportSpecifier */: + case 205 /* InterfaceDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 208 /* ModuleDeclaration */: + case 214 /* NamespaceImport */: + case 131 /* Parameter */: + case 227 /* PropertyAssignment */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 139 /* SetAccessor */: + case 228 /* ShorthandPropertyAssignment */: + case 206 /* TypeAliasDeclaration */: + case 130 /* TypeParameter */: + case 201 /* VariableDeclaration */: return true; } return false; @@ -5375,25 +5689,25 @@ var ts; ts.isDeclaration = isDeclaration; function isStatement(n) { switch (n.kind) { - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 198 /* DebuggerStatement */: - case 185 /* DoStatement */: - case 183 /* ExpressionStatement */: - case 182 /* EmptyStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 184 /* IfStatement */: - case 195 /* LabeledStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: + case 193 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 200 /* DebuggerStatement */: + case 187 /* DoStatement */: + case 185 /* ExpressionStatement */: + case 184 /* EmptyStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 189 /* ForStatement */: + case 186 /* IfStatement */: + case 197 /* LabeledStatement */: + case 194 /* ReturnStatement */: + case 196 /* SwitchStatement */: case 94 /* ThrowKeyword */: - case 197 /* TryStatement */: - case 181 /* VariableStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 215 /* ExportAssignment */: + case 199 /* TryStatement */: + case 183 /* VariableStatement */: + case 188 /* WhileStatement */: + case 195 /* WithStatement */: + case 217 /* ExportAssignment */: return true; default: return false; @@ -5402,13 +5716,13 @@ var ts; ts.isStatement = isStatement; function isClassElement(n) { switch (n.kind) { - case 136 /* Constructor */: - case 133 /* PropertyDeclaration */: - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: + case 137 /* Constructor */: + case 134 /* PropertyDeclaration */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 135 /* MethodSignature */: + case 142 /* IndexSignature */: return true; default: return false; @@ -5421,7 +5735,7 @@ var ts; return false; } var parent = name.parent; - if (parent.kind === 214 /* ImportSpecifier */ || parent.kind === 218 /* ExportSpecifier */) { + if (parent.kind === 216 /* ImportSpecifier */ || parent.kind === 220 /* ExportSpecifier */) { if (parent.propertyName) { return true; } @@ -5432,6 +5746,41 @@ var ts; return false; } ts.isDeclarationName = isDeclarationName; + // Return true if the given identifier is classified as an IdentifierName + function isIdentifierName(node) { + var parent = node.parent; + switch (parent.kind) { + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 229 /* EnumMember */: + case 227 /* PropertyAssignment */: + case 158 /* PropertyAccessExpression */: + // Name in member declaration or property name in property access + return parent.name === node; + case 128 /* QualifiedName */: + // Name on right hand side of dot in a type query + if (parent.right === node) { + while (parent.kind === 128 /* QualifiedName */) { + parent = parent.parent; + } + return parent.kind === 147 /* TypeQuery */; + } + return false; + case 155 /* BindingElement */: + case 216 /* ImportSpecifier */: + // Property name in binding element or import specifier + return parent.propertyName === node; + case 220 /* ExportSpecifier */: + // Any name in an export specifier + return true; + } + return false; + } + ts.isIdentifierName = isIdentifierName; // An alias symbol is created by one of the following declarations: // import = ... // import from ... @@ -5441,12 +5790,12 @@ var ts; // export = ... // export default ... function isAliasSymbolDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ || - node.kind === 211 /* ImportClause */ && !!node.name || - node.kind === 212 /* NamespaceImport */ || - node.kind === 214 /* ImportSpecifier */ || - node.kind === 218 /* ExportSpecifier */ || - node.kind === 215 /* ExportAssignment */ && node.expression.kind === 65 /* Identifier */; + return node.kind === 211 /* ImportEqualsDeclaration */ || + node.kind === 213 /* ImportClause */ && !!node.name || + node.kind === 214 /* NamespaceImport */ || + node.kind === 216 /* ImportSpecifier */ || + node.kind === 220 /* ExportSpecifier */ || + node.kind === 217 /* ExportAssignment */ && node.expression.kind === 65 /* Identifier */; } ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration; function getClassExtendsHeritageClauseElement(node) { @@ -5529,7 +5878,7 @@ var ts; } ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; function isKeyword(token) { - return 66 /* FirstKeyword */ <= token && token <= 126 /* LastKeyword */; + return 66 /* FirstKeyword */ <= token && token <= 127 /* LastKeyword */; } ts.isKeyword = isKeyword; function isTrivia(token) { @@ -5545,7 +5894,7 @@ var ts; */ function hasDynamicName(declaration) { return declaration.name && - declaration.name.kind === 128 /* ComputedPropertyName */ && + declaration.name.kind === 129 /* ComputedPropertyName */ && !isWellKnownSymbolSyntactically(declaration.name.expression); } ts.hasDynamicName = hasDynamicName; @@ -5555,14 +5904,14 @@ var ts; * where Symbol is literally the word "Symbol", and name is any identifierName */ function isWellKnownSymbolSyntactically(node) { - return node.kind === 156 /* PropertyAccessExpression */ && isESSymbolIdentifier(node.expression); + return node.kind === 158 /* PropertyAccessExpression */ && isESSymbolIdentifier(node.expression); } ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; function getPropertyNameForPropertyNameNode(name) { if (name.kind === 65 /* Identifier */ || name.kind === 8 /* StringLiteral */ || name.kind === 7 /* NumericLiteral */) { return name.text; } - if (name.kind === 128 /* ComputedPropertyName */) { + if (name.kind === 129 /* ComputedPropertyName */) { var nameExpression = name.expression; if (isWellKnownSymbolSyntactically(nameExpression)) { var rightHandSideName = nameExpression.name.text; @@ -5600,18 +5949,18 @@ var ts; ts.isModifier = isModifier; function isParameterDeclaration(node) { var root = getRootDeclaration(node); - return root.kind === 130 /* Parameter */; + return root.kind === 131 /* Parameter */; } ts.isParameterDeclaration = isParameterDeclaration; function getRootDeclaration(node) { - while (node.kind === 153 /* BindingElement */) { + while (node.kind === 155 /* BindingElement */) { node = node.parent.parent; } return node; } ts.getRootDeclaration = getRootDeclaration; function nodeStartsNewLexicalEnvironment(n) { - return isFunctionLike(n) || n.kind === 206 /* ModuleDeclaration */ || n.kind === 228 /* SourceFile */; + return isFunctionLike(n) || n.kind === 208 /* ModuleDeclaration */ || n.kind === 230 /* SourceFile */; } ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment; function nodeIsSynthesized(node) { @@ -5847,7 +6196,7 @@ var ts; ts.getLineOfLocalPosition = getLineOfLocalPosition; function getFirstConstructorWithBody(node) { return ts.forEach(node.members, function (member) { - if (member.kind === 136 /* Constructor */ && nodeIsPresent(member.body)) { + if (member.kind === 137 /* Constructor */ && nodeIsPresent(member.body)) { return member; } }); @@ -5872,10 +6221,10 @@ var ts; var setAccessor; if (hasDynamicName(accessor)) { firstAccessor = accessor; - if (accessor.kind === 137 /* GetAccessor */) { + if (accessor.kind === 138 /* GetAccessor */) { getAccessor = accessor; } - else if (accessor.kind === 138 /* SetAccessor */) { + else if (accessor.kind === 139 /* SetAccessor */) { setAccessor = accessor; } else { @@ -5884,7 +6233,7 @@ var ts; } else { ts.forEach(declarations, function (member) { - if ((member.kind === 137 /* GetAccessor */ || member.kind === 138 /* SetAccessor */) + if ((member.kind === 138 /* GetAccessor */ || member.kind === 139 /* SetAccessor */) && (member.flags & 128 /* Static */) === (accessor.flags & 128 /* Static */)) { var memberName = getPropertyNameForPropertyNameNode(member.name); var accessorName = getPropertyNameForPropertyNameNode(accessor.name); @@ -5895,10 +6244,10 @@ var ts; else if (!secondAccessor) { secondAccessor = member; } - if (member.kind === 137 /* GetAccessor */ && !getAccessor) { + if (member.kind === 138 /* GetAccessor */ && !getAccessor) { getAccessor = member; } - if (member.kind === 138 /* SetAccessor */ && !setAccessor) { + if (member.kind === 139 /* SetAccessor */ && !setAccessor) { setAccessor = member; } } @@ -6046,22 +6395,22 @@ var ts; function isLeftHandSideExpression(expr) { if (expr) { switch (expr.kind) { - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 159 /* NewExpression */: - case 158 /* CallExpression */: - case 160 /* TaggedTemplateExpression */: - case 154 /* ArrayLiteralExpression */: - case 162 /* ParenthesizedExpression */: - case 155 /* ObjectLiteralExpression */: - case 175 /* ClassExpression */: - case 163 /* FunctionExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 161 /* NewExpression */: + case 160 /* CallExpression */: + case 162 /* TaggedTemplateExpression */: + case 156 /* ArrayLiteralExpression */: + case 164 /* ParenthesizedExpression */: + case 157 /* ObjectLiteralExpression */: + case 177 /* ClassExpression */: + case 165 /* FunctionExpression */: case 65 /* Identifier */: case 9 /* RegularExpressionLiteral */: case 7 /* NumericLiteral */: case 8 /* StringLiteral */: case 10 /* NoSubstitutionTemplateLiteral */: - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: case 80 /* FalseKeyword */: case 89 /* NullKeyword */: case 93 /* ThisKeyword */: @@ -6077,6 +6426,12 @@ var ts; return token >= 53 /* FirstAssignment */ && token <= 64 /* LastAssignment */; } ts.isAssignmentOperator = isAssignmentOperator; + function isExpressionWithTypeArgumentsInClassExtendsClause(node) { + return node.kind === 179 /* ExpressionWithTypeArguments */ && + node.parent.token === 79 /* ExtendsKeyword */ && + node.parent.parent.kind === 204 /* ClassDeclaration */; + } + ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; // Returns false if this heritage clause element's expression contains something unsupported // (i.e. not a name or dotted name). function isSupportedExpressionWithTypeArguments(node) { @@ -6087,7 +6442,7 @@ var ts; if (node.kind === 65 /* Identifier */) { return true; } - else if (node.kind === 156 /* PropertyAccessExpression */) { + else if (node.kind === 158 /* PropertyAccessExpression */) { return isSupportedExpressionWithTypeArgumentsRest(node.expression); } else { @@ -6095,8 +6450,8 @@ var ts; } } function isRightSideOfQualifiedNameOrPropertyAccess(node) { - return (node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node) || - (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node); + return (node.parent.kind === 128 /* QualifiedName */ && node.parent.right === node) || + (node.parent.kind === 158 /* PropertyAccessExpression */ && node.parent.name === node); } ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess; function getLocalSymbolForExportDefault(symbol) { @@ -6237,6 +6592,12 @@ var ts; return start <= textSpanEnd(span) && end >= span.start; } ts.textSpanIntersectsWith = textSpanIntersectsWith; + function decodedTextSpanIntersectsWith(start1, length1, start2, length2) { + var end1 = start1 + length1; + var end2 = start2 + length2; + return start2 <= end1 && end2 >= start1; + } + ts.decodedTextSpanIntersectsWith = decodedTextSpanIntersectsWith; function textSpanIntersectsWithPosition(span, position) { return position <= textSpanEnd(span) && position >= span.start; } @@ -6396,9 +6757,9 @@ var ts; } ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions; function getTypeParameterOwner(d) { - if (d && d.kind === 129 /* TypeParameter */) { + if (d && d.kind === 130 /* TypeParameter */) { for (var current = d; current; current = current.parent) { - if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 203 /* InterfaceDeclaration */) { + if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 205 /* InterfaceDeclaration */) { return current; } } @@ -6410,7 +6771,7 @@ var ts; /// var ts; (function (ts) { - var nodeConstructors = new Array(252 /* Count */); + var nodeConstructors = new Array(254 /* Count */); /* @internal */ ts.parseTime = 0; function getNodeConstructor(kind) { return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); @@ -6455,20 +6816,20 @@ var ts; var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; var cbNodes = cbNodeArray || cbNode; switch (node.kind) { - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); - case 129 /* TypeParameter */: + case 130 /* TypeParameter */: return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 131 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 227 /* PropertyAssignment */: + case 228 /* ShorthandPropertyAssignment */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || @@ -6477,24 +6838,24 @@ var ts; visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || @@ -6505,263 +6866,267 @@ var ts; visitNode(cbNode, node.type) || visitNode(cbNode, node.equalsGreaterThanToken) || visitNode(cbNode, node.body); - case 142 /* TypeReference */: + case 144 /* TypeReference */: return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); - case 145 /* TypeQuery */: + case 143 /* TypePredicate */: + return visitNode(cbNode, node.parameterName) || + visitNode(cbNode, node.type); + case 147 /* TypeQuery */: return visitNode(cbNode, node.exprName); - case 146 /* TypeLiteral */: + case 148 /* TypeLiteral */: return visitNodes(cbNodes, node.members); - case 147 /* ArrayType */: + case 149 /* ArrayType */: return visitNode(cbNode, node.elementType); - case 148 /* TupleType */: + case 150 /* TupleType */: return visitNodes(cbNodes, node.elementTypes); - case 149 /* UnionType */: + case 151 /* UnionType */: return visitNodes(cbNodes, node.types); - case 150 /* ParenthesizedType */: + case 152 /* ParenthesizedType */: return visitNode(cbNode, node.type); - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: return visitNodes(cbNodes, node.elements); - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return visitNodes(cbNodes, node.elements); - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return visitNodes(cbNodes, node.properties); - case 156 /* PropertyAccessExpression */: + case 158 /* PropertyAccessExpression */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.dotToken) || visitNode(cbNode, node.name); - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return visitNode(cbNode, node.expression); - case 165 /* DeleteExpression */: + case 167 /* DeleteExpression */: return visitNode(cbNode, node.expression); - case 166 /* TypeOfExpression */: + case 168 /* TypeOfExpression */: return visitNode(cbNode, node.expression); - case 167 /* VoidExpression */: + case 169 /* VoidExpression */: return visitNode(cbNode, node.expression); - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: return visitNode(cbNode, node.operand); - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); - case 169 /* PostfixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: return visitNode(cbNode, node.operand); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return visitNode(cbNode, node.condition) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.colonToken) || visitNode(cbNode, node.whenFalse); - case 174 /* SpreadElementExpression */: + case 176 /* SpreadElementExpression */: return visitNode(cbNode, node.expression); - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return visitNodes(cbNodes, node.statements); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); - case 200 /* VariableDeclarationList */: + case 202 /* VariableDeclarationList */: return visitNodes(cbNodes, node.declarations); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: return visitNode(cbNode, node.expression); - case 184 /* IfStatement */: + case 186 /* IfStatement */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); - case 185 /* DoStatement */: + case 187 /* DoStatement */: return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); - case 186 /* WhileStatement */: + case 188 /* WhileStatement */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 187 /* ForStatement */: + case 189 /* ForStatement */: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.incrementor) || visitNode(cbNode, node.statement); - case 188 /* ForInStatement */: + case 190 /* ForInStatement */: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 189 /* ForOfStatement */: + case 191 /* ForOfStatement */: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 193 /* BreakStatement */: return visitNode(cbNode, node.label); - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: return visitNode(cbNode, node.expression); - case 193 /* WithStatement */: + case 195 /* WithStatement */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.caseBlock); - case 208 /* CaseBlock */: + case 210 /* CaseBlock */: return visitNodes(cbNodes, node.clauses); - case 221 /* CaseClause */: + case 223 /* CaseClause */: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.statements); - case 222 /* DefaultClause */: + case 224 /* DefaultClause */: return visitNodes(cbNodes, node.statements); - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return visitNode(cbNode, node.label) || visitNode(cbNode, node.statement); - case 196 /* ThrowStatement */: + case 198 /* ThrowStatement */: return visitNode(cbNode, node.expression); - case 197 /* TryStatement */: + case 199 /* TryStatement */: return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return visitNode(cbNode, node.variableDeclaration) || visitNode(cbNode, node.block); - case 131 /* Decorator */: + case 132 /* Decorator */: return visitNode(cbNode, node.expression); - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || visitNode(cbNode, node.type); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.members); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.body); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.importClause) || visitNode(cbNode, node.moduleSpecifier); - case 211 /* ImportClause */: + case 213 /* ImportClause */: return visitNode(cbNode, node.name) || visitNode(cbNode, node.namedBindings); - case 212 /* NamespaceImport */: + case 214 /* NamespaceImport */: return visitNode(cbNode, node.name); - case 213 /* NamedImports */: - case 217 /* NamedExports */: + case 215 /* NamedImports */: + case 219 /* NamedExports */: return visitNodes(cbNodes, node.elements); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportClause) || visitNode(cbNode, node.moduleSpecifier); - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 216 /* ImportSpecifier */: + case 220 /* ExportSpecifier */: return visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.name); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.expression); - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); - case 178 /* TemplateSpan */: + case 180 /* TemplateSpan */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: return visitNode(cbNode, node.expression); - case 223 /* HeritageClause */: + case 225 /* HeritageClause */: return visitNodes(cbNodes, node.types); - case 177 /* ExpressionWithTypeArguments */: + case 179 /* ExpressionWithTypeArguments */: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments); - case 220 /* ExternalModuleReference */: + case 222 /* ExternalModuleReference */: return visitNode(cbNode, node.expression); - case 219 /* MissingDeclaration */: + case 221 /* MissingDeclaration */: return visitNodes(cbNodes, node.decorators); - case 229 /* JSDocTypeExpression */: + case 231 /* JSDocTypeExpression */: return visitNode(cbNode, node.type); - case 233 /* JSDocUnionType */: + case 235 /* JSDocUnionType */: return visitNodes(cbNodes, node.types); - case 234 /* JSDocTupleType */: + case 236 /* JSDocTupleType */: return visitNodes(cbNodes, node.types); - case 232 /* JSDocArrayType */: + case 234 /* JSDocArrayType */: return visitNode(cbNode, node.elementType); - case 236 /* JSDocNonNullableType */: + case 238 /* JSDocNonNullableType */: return visitNode(cbNode, node.type); - case 235 /* JSDocNullableType */: + case 237 /* JSDocNullableType */: return visitNode(cbNode, node.type); - case 237 /* JSDocRecordType */: + case 239 /* JSDocRecordType */: return visitNodes(cbNodes, node.members); - case 239 /* JSDocTypeReference */: + case 241 /* JSDocTypeReference */: return visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeArguments); - case 240 /* JSDocOptionalType */: + case 242 /* JSDocOptionalType */: return visitNode(cbNode, node.type); - case 241 /* JSDocFunctionType */: + case 243 /* JSDocFunctionType */: return visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 242 /* JSDocVariadicType */: + case 244 /* JSDocVariadicType */: return visitNode(cbNode, node.type); - case 243 /* JSDocConstructorType */: + case 245 /* JSDocConstructorType */: return visitNode(cbNode, node.type); - case 244 /* JSDocThisType */: + case 246 /* JSDocThisType */: return visitNode(cbNode, node.type); - case 238 /* JSDocRecordMember */: + case 240 /* JSDocRecordMember */: return visitNode(cbNode, node.name) || visitNode(cbNode, node.type); - case 245 /* JSDocComment */: + case 247 /* JSDocComment */: return visitNodes(cbNodes, node.tags); - case 247 /* JSDocParameterTag */: + case 249 /* JSDocParameterTag */: return visitNode(cbNode, node.preParameterName) || visitNode(cbNode, node.typeExpression) || visitNode(cbNode, node.postParameterName); - case 248 /* JSDocReturnTag */: + case 250 /* JSDocReturnTag */: return visitNode(cbNode, node.typeExpression); - case 249 /* JSDocTypeTag */: + case 251 /* JSDocTypeTag */: return visitNode(cbNode, node.typeExpression); - case 250 /* JSDocTemplateTag */: + case 252 /* JSDocTemplateTag */: return visitNodes(cbNodes, node.typeParameters); } } @@ -6891,13 +7256,6 @@ var ts; // Note: any errors at the end of the file that do not precede a regular node, should get // attached to the EOF token. var parseErrorBeforeNextFinishedNode = false; - (function (StatementFlags) { - StatementFlags[StatementFlags["None"] = 0] = "None"; - StatementFlags[StatementFlags["Statement"] = 1] = "Statement"; - StatementFlags[StatementFlags["ModuleElement"] = 2] = "ModuleElement"; - StatementFlags[StatementFlags["StatementOrModuleElement"] = 3] = "StatementOrModuleElement"; - })(Parser.StatementFlags || (Parser.StatementFlags = {})); - var StatementFlags = Parser.StatementFlags; function parseSourceFile(fileName, _sourceText, languageVersion, _syntaxCursor, setParentNodes) { initializeState(fileName, _sourceText, languageVersion, _syntaxCursor); var result = parseSourceFileWorker(fileName, languageVersion, setParentNodes); @@ -6936,7 +7294,7 @@ var ts; // Prime the scanner. token = nextToken(); processReferenceComments(sourceFile); - sourceFile.statements = parseList(0 /* SourceElements */, true, parseSourceElement); + sourceFile.statements = parseList(0 /* SourceElements */, parseStatement); ts.Debug.assert(token === 1 /* EndOfFileToken */); sourceFile.endOfFileToken = parseTokenNode(); setExternalModuleIndicator(sourceFile); @@ -6962,9 +7320,9 @@ var ts; // Add additional cases as necessary depending on how we see JSDoc comments used // in the wild. switch (node.kind) { - case 181 /* VariableStatement */: - case 201 /* FunctionDeclaration */: - case 130 /* Parameter */: + case 183 /* VariableStatement */: + case 203 /* FunctionDeclaration */: + case 131 /* Parameter */: addJSDocComment(node); } forEachChild(node, visit); @@ -7005,7 +7363,7 @@ var ts; } Parser.fixupParentReferences = fixupParentReferences; function createSourceFile(fileName, languageVersion) { - var sourceFile = createNode(228 /* SourceFile */, 0); + var sourceFile = createNode(230 /* SourceFile */, 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; sourceFile.text = sourceText; @@ -7023,9 +7381,6 @@ var ts; contextFlags &= ~flag; } } - function setStrictModeContext(val) { - setContextFlag(val, 1 /* StrictMode */); - } function setDisallowInContext(val) { setContextFlag(val, 2 /* DisallowIn */); } @@ -7102,9 +7457,6 @@ var ts; function inYieldContext() { return (contextFlags & 4 /* Yield */) !== 0; } - function inStrictModeContext() { - return (contextFlags & 1 /* StrictMode */) !== 0; - } function inGeneratorParameterContext() { return (contextFlags & 8 /* GeneratorParameter */) !== 0; } @@ -7356,7 +7708,7 @@ var ts; // ComputedPropertyName[Yield] : // [ AssignmentExpression[In, ?Yield] ] // - var node = createNode(128 /* ComputedPropertyName */); + var node = createNode(129 /* ComputedPropertyName */); parseExpected(18 /* OpenBracketToken */); // We parse any expression (including a comma expression). But the grammar // says that only an assignment expression is allowed, so the grammar checker @@ -7414,37 +7766,34 @@ var ts; } switch (parsingContext) { case 0 /* SourceElements */: - case 1 /* ModuleElements */: + case 1 /* BlockStatements */: + case 3 /* SwitchClauseStatements */: // If we're in error recovery, then we don't want to treat ';' as an empty statement. // The problem is that ';' can show up in far too many contexts, and if we see one // and assume it's a statement, then we may bail out inappropriately from whatever // we're parsing. For example, if we have a semicolon in the middle of a class, then // we really don't want to assume the class is over and we're on a statement in the // outer module. We just want to consume and move on. - return !(token === 22 /* SemicolonToken */ && inErrorRecovery) && isStartOfModuleElement(); - case 2 /* BlockStatements */: - case 4 /* SwitchClauseStatements */: - // During error recovery we don't treat empty statements as statements return !(token === 22 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement(); - case 3 /* SwitchClauses */: + case 2 /* SwitchClauses */: return token === 67 /* CaseKeyword */ || token === 73 /* DefaultKeyword */; - case 5 /* TypeMembers */: + case 4 /* TypeMembers */: return isStartOfTypeMember(); - case 6 /* ClassMembers */: + case 5 /* ClassMembers */: // We allow semicolons as class elements (as specified by ES6) as long as we're // not in error recovery. If we're in error recovery, we don't want an errant // semicolon to be treated as a class member (since they're almost always used // for statements. return lookAhead(isClassMemberStart) || (token === 22 /* SemicolonToken */ && !inErrorRecovery); - case 7 /* EnumMembers */: + case 6 /* EnumMembers */: // Include open bracket computed properties. This technically also lets in indexers, // which would be a candidate for improved error reporting. return token === 18 /* OpenBracketToken */ || isLiteralPropertyName(); - case 13 /* ObjectLiteralMembers */: + case 12 /* ObjectLiteralMembers */: return token === 18 /* OpenBracketToken */ || token === 35 /* AsteriskToken */ || isLiteralPropertyName(); - case 10 /* ObjectBindingElements */: + case 9 /* ObjectBindingElements */: return isLiteralPropertyName(); - case 8 /* HeritageClauseElement */: + case 7 /* HeritageClauseElement */: // If we see { } then only consume it as an expression if it is followed by , or { // That way we won't consume the body of a class in its heritage clause. if (token === 14 /* OpenBraceToken */) { @@ -7459,29 +7808,29 @@ var ts; // element during recovery. return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword(); } - case 9 /* VariableDeclarations */: + case 8 /* VariableDeclarations */: return isIdentifierOrPattern(); - case 11 /* ArrayBindingElements */: + case 10 /* ArrayBindingElements */: return token === 23 /* CommaToken */ || token === 21 /* DotDotDotToken */ || isIdentifierOrPattern(); - case 16 /* TypeParameters */: + case 15 /* TypeParameters */: return isIdentifier(); - case 12 /* ArgumentExpressions */: - case 14 /* ArrayLiteralMembers */: + case 11 /* ArgumentExpressions */: + case 13 /* ArrayLiteralMembers */: return token === 23 /* CommaToken */ || token === 21 /* DotDotDotToken */ || isStartOfExpression(); - case 15 /* Parameters */: + case 14 /* Parameters */: return isStartOfParameter(); - case 17 /* TypeArguments */: - case 18 /* TupleElementTypes */: + case 16 /* TypeArguments */: + case 17 /* TupleElementTypes */: return token === 23 /* CommaToken */ || isStartOfType(); - case 19 /* HeritageClauses */: + case 18 /* HeritageClauses */: return isHeritageClause(); - case 20 /* ImportOrExportSpecifiers */: + case 19 /* ImportOrExportSpecifiers */: return isIdentifierOrKeyword(); - case 21 /* JSDocFunctionParameters */: - case 22 /* JSDocTypeArguments */: - case 24 /* JSDocTupleTypes */: + case 20 /* JSDocFunctionParameters */: + case 21 /* JSDocTypeArguments */: + case 23 /* JSDocTupleTypes */: return JSDocParser.isJSDocType(); - case 23 /* JSDocRecordMembers */: + case 22 /* JSDocRecordMembers */: return isSimplePropertyName(); } ts.Debug.fail("Non-exhaustive case in 'isListElement'."); @@ -7523,47 +7872,46 @@ var ts; return true; } switch (kind) { - case 1 /* ModuleElements */: - case 2 /* BlockStatements */: - case 3 /* SwitchClauses */: - case 5 /* TypeMembers */: - case 6 /* ClassMembers */: - case 7 /* EnumMembers */: - case 13 /* ObjectLiteralMembers */: - case 10 /* ObjectBindingElements */: - case 20 /* ImportOrExportSpecifiers */: + case 1 /* BlockStatements */: + case 2 /* SwitchClauses */: + case 4 /* TypeMembers */: + case 5 /* ClassMembers */: + case 6 /* EnumMembers */: + case 12 /* ObjectLiteralMembers */: + case 9 /* ObjectBindingElements */: + case 19 /* ImportOrExportSpecifiers */: return token === 15 /* CloseBraceToken */; - case 4 /* SwitchClauseStatements */: + case 3 /* SwitchClauseStatements */: return token === 15 /* CloseBraceToken */ || token === 67 /* CaseKeyword */ || token === 73 /* DefaultKeyword */; - case 8 /* HeritageClauseElement */: + case 7 /* HeritageClauseElement */: return token === 14 /* OpenBraceToken */ || token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; - case 9 /* VariableDeclarations */: + case 8 /* VariableDeclarations */: return isVariableDeclaratorListTerminator(); - case 16 /* TypeParameters */: + case 15 /* TypeParameters */: // Tokens other than '>' are here for better error recovery return token === 25 /* GreaterThanToken */ || token === 16 /* OpenParenToken */ || token === 14 /* OpenBraceToken */ || token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; - case 12 /* ArgumentExpressions */: + case 11 /* ArgumentExpressions */: // Tokens other than ')' are here for better error recovery return token === 17 /* CloseParenToken */ || token === 22 /* SemicolonToken */; - case 14 /* ArrayLiteralMembers */: - case 18 /* TupleElementTypes */: - case 11 /* ArrayBindingElements */: + case 13 /* ArrayLiteralMembers */: + case 17 /* TupleElementTypes */: + case 10 /* ArrayBindingElements */: return token === 19 /* CloseBracketToken */; - case 15 /* Parameters */: + case 14 /* Parameters */: // Tokens other than ')' and ']' (the latter for index signatures) are here for better error recovery return token === 17 /* CloseParenToken */ || token === 19 /* CloseBracketToken */ /*|| token === SyntaxKind.OpenBraceToken*/; - case 17 /* TypeArguments */: + case 16 /* TypeArguments */: // Tokens other than '>' are here for better error recovery return token === 25 /* GreaterThanToken */ || token === 16 /* OpenParenToken */; - case 19 /* HeritageClauses */: + case 18 /* HeritageClauses */: return token === 14 /* OpenBraceToken */ || token === 15 /* CloseBraceToken */; - case 21 /* JSDocFunctionParameters */: + case 20 /* JSDocFunctionParameters */: return token === 17 /* CloseParenToken */ || token === 51 /* ColonToken */ || token === 15 /* CloseBraceToken */; - case 22 /* JSDocTypeArguments */: + case 21 /* JSDocTypeArguments */: return token === 25 /* GreaterThanToken */ || token === 15 /* CloseBraceToken */; - case 24 /* JSDocTupleTypes */: + case 23 /* JSDocTupleTypes */: return token === 19 /* CloseBracketToken */ || token === 15 /* CloseBraceToken */; - case 23 /* JSDocRecordMembers */: + case 22 /* JSDocRecordMembers */: return token === 15 /* CloseBraceToken */; } } @@ -7590,7 +7938,7 @@ var ts; } // True if positioned at element or terminator of the current list or any enclosing list function isInSomeParsingContext() { - for (var kind = 0; kind < 25 /* Count */; kind++) { + for (var kind = 0; kind < 24 /* Count */; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, true) || isListTerminator(kind)) { return true; @@ -7600,47 +7948,25 @@ var ts; return false; } // Parses a list of elements - function parseList(kind, checkForStrictMode, parseElement) { + function parseList(kind, parseElement) { var saveParsingContext = parsingContext; parsingContext |= 1 << kind; var result = []; result.pos = getNodePos(); - var savedStrictModeContext = inStrictModeContext(); while (!isListTerminator(kind)) { if (isListElement(kind, false)) { var element = parseListElement(kind, parseElement); result.push(element); - // test elements only if we are not already in strict mode - if (checkForStrictMode && !inStrictModeContext()) { - if (ts.isPrologueDirective(element)) { - if (isUseStrictPrologueDirective(element)) { - setStrictModeContext(true); - checkForStrictMode = false; - } - } - else { - checkForStrictMode = false; - } - } continue; } if (abortParsingListOrMoveToNextToken(kind)) { break; } } - setStrictModeContext(savedStrictModeContext); result.end = getNodeEnd(); parsingContext = saveParsingContext; return result; } - /// Should be called only on prologue directives (isPrologueDirective(node) should be true) - function isUseStrictPrologueDirective(node) { - ts.Debug.assert(ts.isPrologueDirective(node)); - var nodeText = ts.getTextOfNodeFromSourceText(sourceText, node.expression); - // Note: the node text must be exactly "use strict" or 'use strict'. It is not ok for the - // string to contain unicode escapes (as per ES5). - return nodeText === '"use strict"' || nodeText === "'use strict'"; - } function parseListElement(parsingContext, parseElement) { var node = currentNode(parsingContext); if (node) { @@ -7688,7 +8014,7 @@ var ts; // differently depending on what mode it is in. // // This also applies to all our other context flags as well. - var nodeContextFlags = node.parserContextFlags & 63 /* ParserGeneratedFlags */; + var nodeContextFlags = node.parserContextFlags & 62 /* ParserGeneratedFlags */; if (nodeContextFlags !== contextFlags) { return undefined; } @@ -7707,37 +8033,36 @@ var ts; } function canReuseNode(node, parsingContext) { switch (parsingContext) { - case 1 /* ModuleElements */: - return isReusableModuleElement(node); - case 6 /* ClassMembers */: + case 5 /* ClassMembers */: return isReusableClassMember(node); - case 3 /* SwitchClauses */: + case 2 /* SwitchClauses */: return isReusableSwitchClause(node); - case 2 /* BlockStatements */: - case 4 /* SwitchClauseStatements */: + case 0 /* SourceElements */: + case 1 /* BlockStatements */: + case 3 /* SwitchClauseStatements */: return isReusableStatement(node); - case 7 /* EnumMembers */: + case 6 /* EnumMembers */: return isReusableEnumMember(node); - case 5 /* TypeMembers */: + case 4 /* TypeMembers */: return isReusableTypeMember(node); - case 9 /* VariableDeclarations */: + case 8 /* VariableDeclarations */: return isReusableVariableDeclaration(node); - case 15 /* Parameters */: + case 14 /* Parameters */: return isReusableParameter(node); // Any other lists we do not care about reusing nodes in. But feel free to add if // you can do so safely. Danger areas involve nodes that may involve speculative // parsing. If speculative parsing is involved with the node, then the range the // parser reached while looking ahead might be in the edited range (see the example // in canReuseVariableDeclaratorNode for a good case of this). - case 19 /* HeritageClauses */: + case 18 /* HeritageClauses */: // This would probably be safe to reuse. There is no speculative parsing with // heritage clauses. - case 16 /* TypeParameters */: + case 15 /* TypeParameters */: // This would probably be safe to reuse. There is no speculative parsing with // type parameters. Note that that's because type *parameters* only occur in // unambiguous *type* contexts. While type *arguments* occur in very ambiguous // *expression* contexts. - case 18 /* TupleElementTypes */: + case 17 /* TupleElementTypes */: // This would probably be safe to reuse. There is no speculative parsing with // tuple types. // Technically, type argument list types are probably safe to reuse. While @@ -7745,51 +8070,41 @@ var ts; // produced from speculative parsing a < as a type argument list), we only have // the types because speculative parsing succeeded. Thus, the lookahead never // went past the end of the list and rewound. - case 17 /* TypeArguments */: + case 16 /* TypeArguments */: // Note: these are almost certainly not safe to ever reuse. Expressions commonly // need a large amount of lookahead, and we should not reuse them as they may // have actually intersected the edit. - case 12 /* ArgumentExpressions */: + case 11 /* ArgumentExpressions */: // This is not safe to reuse for the same reason as the 'AssignmentExpression' // cases. i.e. a property assignment may end with an expression, and thus might // have lookahead far beyond it's old node. - case 13 /* ObjectLiteralMembers */: + case 12 /* ObjectLiteralMembers */: // This is probably not safe to reuse. There can be speculative parsing with // type names in a heritage clause. There can be generic names in the type // name list, and there can be left hand side expressions (which can have type // arguments.) - case 8 /* HeritageClauseElement */: - } - return false; - } - function isReusableModuleElement(node) { - if (node) { - switch (node.kind) { - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 216 /* ExportDeclaration */: - case 215 /* ExportAssignment */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - return true; - } - return isReusableStatement(node); + case 7 /* HeritageClauseElement */: } return false; } function isReusableClassMember(node) { if (node) { switch (node.kind) { - case 136 /* Constructor */: - case 141 /* IndexSignature */: - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 133 /* PropertyDeclaration */: - case 179 /* SemicolonClassElement */: + case 137 /* Constructor */: + case 142 /* IndexSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 134 /* PropertyDeclaration */: + case 181 /* SemicolonClassElement */: return true; + case 136 /* MethodDeclaration */: + // Method declarations are not necessarily reusable. An object-literal + // may have a method calls "constructor(...)" and we must reparse that + // into an actual .ConstructorDeclaration. + var methodDeclaration = node; + var nameIsConstructor = methodDeclaration.name.kind === 65 /* Identifier */ && + methodDeclaration.name.originalKeywordKind === 114 /* ConstructorKeyword */; + return !nameIsConstructor; } } return false; @@ -7797,8 +8112,8 @@ var ts; function isReusableSwitchClause(node) { if (node) { switch (node.kind) { - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: return true; } } @@ -7807,49 +8122,58 @@ var ts; function isReusableStatement(node) { if (node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 181 /* VariableStatement */: - case 180 /* Block */: - case 184 /* IfStatement */: - case 183 /* ExpressionStatement */: - case 196 /* ThrowStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 182 /* EmptyStatement */: - case 197 /* TryStatement */: - case 195 /* LabeledStatement */: - case 185 /* DoStatement */: - case 198 /* DebuggerStatement */: + case 203 /* FunctionDeclaration */: + case 183 /* VariableStatement */: + case 182 /* Block */: + case 186 /* IfStatement */: + case 185 /* ExpressionStatement */: + case 198 /* ThrowStatement */: + case 194 /* ReturnStatement */: + case 196 /* SwitchStatement */: + case 193 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 189 /* ForStatement */: + case 188 /* WhileStatement */: + case 195 /* WithStatement */: + case 184 /* EmptyStatement */: + case 199 /* TryStatement */: + case 197 /* LabeledStatement */: + case 187 /* DoStatement */: + case 200 /* DebuggerStatement */: + case 212 /* ImportDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 218 /* ExportDeclaration */: + case 217 /* ExportAssignment */: + case 208 /* ModuleDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 206 /* TypeAliasDeclaration */: return true; } } return false; } function isReusableEnumMember(node) { - return node.kind === 227 /* EnumMember */; + return node.kind === 229 /* EnumMember */; } function isReusableTypeMember(node) { if (node) { switch (node.kind) { - case 140 /* ConstructSignature */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: - case 132 /* PropertySignature */: - case 139 /* CallSignature */: + case 141 /* ConstructSignature */: + case 135 /* MethodSignature */: + case 142 /* IndexSignature */: + case 133 /* PropertySignature */: + case 140 /* CallSignature */: return true; } } return false; } function isReusableVariableDeclaration(node) { - if (node.kind !== 199 /* VariableDeclaration */) { + if (node.kind !== 201 /* VariableDeclaration */) { return false; } // Very subtle incremental parsing bug. Consider the following code: @@ -7870,7 +8194,7 @@ var ts; return variableDeclarator.initializer === undefined; } function isReusableParameter(node) { - if (node.kind !== 130 /* Parameter */) { + if (node.kind !== 131 /* Parameter */) { return false; } // See the comment in isReusableVariableDeclaration for why we do this. @@ -7889,30 +8213,29 @@ var ts; function parsingContextErrors(context) { switch (context) { case 0 /* SourceElements */: return ts.Diagnostics.Declaration_or_statement_expected; - case 1 /* ModuleElements */: return ts.Diagnostics.Declaration_or_statement_expected; - case 2 /* BlockStatements */: return ts.Diagnostics.Statement_expected; - case 3 /* SwitchClauses */: return ts.Diagnostics.case_or_default_expected; - case 4 /* SwitchClauseStatements */: return ts.Diagnostics.Statement_expected; - case 5 /* TypeMembers */: return ts.Diagnostics.Property_or_signature_expected; - case 6 /* ClassMembers */: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; - case 7 /* EnumMembers */: return ts.Diagnostics.Enum_member_expected; - case 8 /* HeritageClauseElement */: return ts.Diagnostics.Expression_expected; - case 9 /* VariableDeclarations */: return ts.Diagnostics.Variable_declaration_expected; - case 10 /* ObjectBindingElements */: return ts.Diagnostics.Property_destructuring_pattern_expected; - case 11 /* ArrayBindingElements */: return ts.Diagnostics.Array_element_destructuring_pattern_expected; - case 12 /* ArgumentExpressions */: return ts.Diagnostics.Argument_expression_expected; - case 13 /* ObjectLiteralMembers */: return ts.Diagnostics.Property_assignment_expected; - case 14 /* ArrayLiteralMembers */: return ts.Diagnostics.Expression_or_comma_expected; - case 15 /* Parameters */: return ts.Diagnostics.Parameter_declaration_expected; - case 16 /* TypeParameters */: return ts.Diagnostics.Type_parameter_declaration_expected; - case 17 /* TypeArguments */: return ts.Diagnostics.Type_argument_expected; - case 18 /* TupleElementTypes */: return ts.Diagnostics.Type_expected; - case 19 /* HeritageClauses */: return ts.Diagnostics.Unexpected_token_expected; - case 20 /* ImportOrExportSpecifiers */: return ts.Diagnostics.Identifier_expected; - case 21 /* JSDocFunctionParameters */: return ts.Diagnostics.Parameter_declaration_expected; - case 22 /* JSDocTypeArguments */: return ts.Diagnostics.Type_argument_expected; - case 24 /* JSDocTupleTypes */: return ts.Diagnostics.Type_expected; - case 23 /* JSDocRecordMembers */: return ts.Diagnostics.Property_assignment_expected; + case 1 /* BlockStatements */: return ts.Diagnostics.Declaration_or_statement_expected; + case 2 /* SwitchClauses */: return ts.Diagnostics.case_or_default_expected; + case 3 /* SwitchClauseStatements */: return ts.Diagnostics.Statement_expected; + case 4 /* TypeMembers */: return ts.Diagnostics.Property_or_signature_expected; + case 5 /* ClassMembers */: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; + case 6 /* EnumMembers */: return ts.Diagnostics.Enum_member_expected; + case 7 /* HeritageClauseElement */: return ts.Diagnostics.Expression_expected; + case 8 /* VariableDeclarations */: return ts.Diagnostics.Variable_declaration_expected; + case 9 /* ObjectBindingElements */: return ts.Diagnostics.Property_destructuring_pattern_expected; + case 10 /* ArrayBindingElements */: return ts.Diagnostics.Array_element_destructuring_pattern_expected; + case 11 /* ArgumentExpressions */: return ts.Diagnostics.Argument_expression_expected; + case 12 /* ObjectLiteralMembers */: return ts.Diagnostics.Property_assignment_expected; + case 13 /* ArrayLiteralMembers */: return ts.Diagnostics.Expression_or_comma_expected; + case 14 /* Parameters */: return ts.Diagnostics.Parameter_declaration_expected; + case 15 /* TypeParameters */: return ts.Diagnostics.Type_parameter_declaration_expected; + case 16 /* TypeArguments */: return ts.Diagnostics.Type_argument_expected; + case 17 /* TupleElementTypes */: return ts.Diagnostics.Type_expected; + case 18 /* HeritageClauses */: return ts.Diagnostics.Unexpected_token_expected; + case 19 /* ImportOrExportSpecifiers */: return ts.Diagnostics.Identifier_expected; + case 20 /* JSDocFunctionParameters */: return ts.Diagnostics.Parameter_declaration_expected; + case 21 /* JSDocTypeArguments */: return ts.Diagnostics.Type_argument_expected; + case 23 /* JSDocTupleTypes */: return ts.Diagnostics.Type_expected; + case 22 /* JSDocRecordMembers */: return ts.Diagnostics.Property_assignment_expected; } } ; @@ -7986,7 +8309,7 @@ var ts; function parseEntityName(allowReservedWords, diagnosticMessage) { var entity = parseIdentifier(diagnosticMessage); while (parseOptional(20 /* DotToken */)) { - var node = createNode(127 /* QualifiedName */, entity.pos); + var node = createNode(128 /* QualifiedName */, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -7994,38 +8317,38 @@ var ts; return entity; } function parseRightSideOfDot(allowIdentifierNames) { - // Technically a keyword is valid here as all keywords are identifier names. - // However, often we'll encounter this in error situations when the keyword + // Technically a keyword is valid here as all identifiers and keywords are identifier names. + // However, often we'll encounter this in error situations when the identifier or keyword // is actually starting another valid construct. // // So, we check for the following specific case: // // name. - // keyword identifierNameOrKeyword + // identifierOrKeyword identifierNameOrKeyword // // Note: the newlines are important here. For example, if that above code // were rewritten into: // - // name.keyword + // name.identifierOrKeyword // identifierNameOrKeyword // // Then we would consider it valid. That's because ASI would take effect and - // the code would be implicitly: "name.keyword; identifierNameOrKeyword". + // the code would be implicitly: "name.identifierOrKeyword; identifierNameOrKeyword". // In the first case though, ASI will not take effect because there is not a - // line terminator after the keyword. - if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord()) { + // line terminator after the identifier or keyword. + if (scanner.hasPrecedingLineBreak() && isIdentifierOrKeyword()) { var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); if (matchesPattern) { // Report that we need an identifier. However, report it right after the dot, // and not on the next token. This is because the next token might actually - // be an identifier and the error woudl be quite confusing. + // be an identifier and the error would be quite confusing. return createMissingNode(65 /* Identifier */, true, ts.Diagnostics.Identifier_expected); } } return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); } function parseTemplateExpression() { - var template = createNode(172 /* TemplateExpression */); + var template = createNode(174 /* TemplateExpression */); template.head = parseLiteralNode(); ts.Debug.assert(template.head.kind === 11 /* TemplateHead */, "Template head has wrong token kind"); var templateSpans = []; @@ -8038,7 +8361,7 @@ var ts; return finishNode(template); } function parseTemplateSpan() { - var span = createNode(178 /* TemplateSpan */); + var span = createNode(180 /* TemplateSpan */); span.expression = allowInAnd(parseExpression); var literal; if (token === 15 /* CloseBraceToken */) { @@ -8078,22 +8401,30 @@ var ts; return node; } // TYPES - function parseTypeReference() { - var node = createNode(142 /* TypeReference */); - node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + function parseTypeReferenceOrTypePredicate() { + var typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + if (typeName.kind === 65 /* Identifier */ && token === 117 /* IsKeyword */ && !scanner.hasPrecedingLineBreak()) { + nextToken(); + var node_1 = createNode(143 /* TypePredicate */, typeName.pos); + node_1.parameterName = typeName; + node_1.type = parseType(); + return finishNode(node_1); + } + var node = createNode(144 /* TypeReference */, typeName.pos); + node.typeName = typeName; if (!scanner.hasPrecedingLineBreak() && token === 24 /* LessThanToken */) { - node.typeArguments = parseBracketedList(17 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + node.typeArguments = parseBracketedList(16 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); } return finishNode(node); } function parseTypeQuery() { - var node = createNode(145 /* TypeQuery */); + var node = createNode(147 /* TypeQuery */); parseExpected(97 /* TypeOfKeyword */); node.exprName = parseEntityName(true); return finishNode(node); } function parseTypeParameter() { - var node = createNode(129 /* TypeParameter */); + var node = createNode(130 /* TypeParameter */); node.name = parseIdentifier(); if (parseOptional(79 /* ExtendsKeyword */)) { // It's not uncommon for people to write improper constraints to a generic. If the @@ -8118,7 +8449,7 @@ var ts; } function parseTypeParameters() { if (token === 24 /* LessThanToken */) { - return parseBracketedList(16 /* TypeParameters */, parseTypeParameter, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + return parseBracketedList(15 /* TypeParameters */, parseTypeParameter, 24 /* LessThanToken */, 25 /* GreaterThanToken */); } } function parseParameterType() { @@ -8139,7 +8470,7 @@ var ts; } } function parseParameter() { - var node = createNode(130 /* Parameter */); + var node = createNode(131 /* Parameter */); node.decorators = parseDecorators(); setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(21 /* DotDotDotToken */); @@ -8210,7 +8541,7 @@ var ts; var savedGeneratorParameterContext = inGeneratorParameterContext(); setYieldContext(yieldAndGeneratorParameterContext); setGeneratorParameterContext(yieldAndGeneratorParameterContext); - var result = parseDelimitedList(15 /* Parameters */, parseParameter); + var result = parseDelimitedList(14 /* Parameters */, parseParameter); setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); if (!parseExpected(17 /* CloseParenToken */) && requireCompleteParameterList) { @@ -8236,7 +8567,7 @@ var ts; } function parseSignatureMember(kind) { var node = createNode(kind); - if (kind === 140 /* ConstructSignature */) { + if (kind === 141 /* ConstructSignature */) { parseExpected(88 /* NewKeyword */); } fillSignature(51 /* ColonToken */, false, false, node); @@ -8300,10 +8631,10 @@ var ts; return token === 51 /* ColonToken */ || token === 23 /* CommaToken */ || token === 19 /* CloseBracketToken */; } function parseIndexSignatureDeclaration(fullStart, decorators, modifiers) { - var node = createNode(141 /* IndexSignature */, fullStart); + var node = createNode(142 /* IndexSignature */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - node.parameters = parseBracketedList(15 /* Parameters */, parseParameter, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); + node.parameters = parseBracketedList(14 /* Parameters */, parseParameter, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); node.type = parseTypeAnnotation(); parseTypeMemberSemicolon(); return finishNode(node); @@ -8313,7 +8644,7 @@ var ts; var name = parsePropertyName(); var questionToken = parseOptionalToken(50 /* QuestionToken */); if (token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */) { - var method = createNode(134 /* MethodSignature */, fullStart); + var method = createNode(135 /* MethodSignature */, fullStart); method.name = name; method.questionToken = questionToken; // Method signatues don't exist in expression contexts. So they have neither @@ -8323,7 +8654,7 @@ var ts; return finishNode(method); } else { - var property = createNode(132 /* PropertySignature */, fullStart); + var property = createNode(133 /* PropertySignature */, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -8365,7 +8696,7 @@ var ts; switch (token) { case 16 /* OpenParenToken */: case 24 /* LessThanToken */: - return parseSignatureMember(139 /* CallSignature */); + return parseSignatureMember(140 /* CallSignature */); case 18 /* OpenBracketToken */: // Indexer or computed property return isIndexSignature() @@ -8373,7 +8704,7 @@ var ts; : parsePropertyOrMethodSignature(); case 88 /* NewKeyword */: if (lookAhead(isStartOfConstructSignature)) { - return parseSignatureMember(140 /* ConstructSignature */); + return parseSignatureMember(141 /* ConstructSignature */); } // fall through. case 8 /* StringLiteral */: @@ -8410,14 +8741,14 @@ var ts; return token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */; } function parseTypeLiteral() { - var node = createNode(146 /* TypeLiteral */); + var node = createNode(148 /* TypeLiteral */); node.members = parseObjectTypeMembers(); return finishNode(node); } function parseObjectTypeMembers() { var members; if (parseExpected(14 /* OpenBraceToken */)) { - members = parseList(5 /* TypeMembers */, false, parseTypeMember); + members = parseList(4 /* TypeMembers */, parseTypeMember); parseExpected(15 /* CloseBraceToken */); } else { @@ -8426,12 +8757,12 @@ var ts; return members; } function parseTupleType() { - var node = createNode(148 /* TupleType */); - node.elementTypes = parseBracketedList(18 /* TupleElementTypes */, parseType, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); + var node = createNode(150 /* TupleType */); + node.elementTypes = parseBracketedList(17 /* TupleElementTypes */, parseType, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); return finishNode(node); } function parseParenthesizedType() { - var node = createNode(150 /* ParenthesizedType */); + var node = createNode(152 /* ParenthesizedType */); parseExpected(16 /* OpenParenToken */); node.type = parseType(); parseExpected(17 /* CloseParenToken */); @@ -8439,7 +8770,7 @@ var ts; } function parseFunctionOrConstructorType(kind) { var node = createNode(kind); - if (kind === 144 /* ConstructorType */) { + if (kind === 146 /* ConstructorType */) { parseExpected(88 /* NewKeyword */); } fillSignature(32 /* EqualsGreaterThanToken */, false, false, node); @@ -8452,13 +8783,13 @@ var ts; function parseNonArrayType() { switch (token) { case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: + case 123 /* StringKeyword */: + case 121 /* NumberKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: // If these are followed by a dot, then parse these out as a dotted type reference instead. var node = tryParse(parseKeywordAndNoDot); - return node || parseTypeReference(); + return node || parseTypeReferenceOrTypePredicate(); case 99 /* VoidKeyword */: return parseTokenNode(); case 97 /* TypeOfKeyword */: @@ -8470,16 +8801,16 @@ var ts; case 16 /* OpenParenToken */: return parseParenthesizedType(); default: - return parseTypeReference(); + return parseTypeReferenceOrTypePredicate(); } } function isStartOfType() { switch (token) { case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: + case 123 /* StringKeyword */: + case 121 /* NumberKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: case 99 /* VoidKeyword */: case 97 /* TypeOfKeyword */: case 14 /* OpenBraceToken */: @@ -8503,7 +8834,7 @@ var ts; var type = parseNonArrayType(); while (!scanner.hasPrecedingLineBreak() && parseOptional(18 /* OpenBracketToken */)) { parseExpected(19 /* CloseBracketToken */); - var node = createNode(147 /* ArrayType */, type.pos); + var node = createNode(149 /* ArrayType */, type.pos); node.elementType = type; type = finishNode(node); } @@ -8518,7 +8849,7 @@ var ts; types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(149 /* UnionType */, type.pos); + var node = createNode(151 /* UnionType */, type.pos); node.types = types; type = finishNode(node); } @@ -8573,10 +8904,10 @@ var ts; } function parseTypeWorker() { if (isStartOfFunctionType()) { - return parseFunctionOrConstructorType(143 /* FunctionType */); + return parseFunctionOrConstructorType(145 /* FunctionType */); } if (token === 88 /* NewKeyword */) { - return parseFunctionOrConstructorType(144 /* ConstructorType */); + return parseFunctionOrConstructorType(146 /* ConstructorType */); } return parseUnionTypeOrHigher(); } @@ -8745,11 +9076,6 @@ var ts; if (inYieldContext()) { return true; } - if (inStrictModeContext()) { - // If we're in strict mode, then 'yield' is a keyword, could only ever start - // a yield expression. - return true; - } // We're in a context where 'yield expr' is not allowed. However, if we can // definitely tell that the user was trying to parse a 'yield expr' and not // just a normal expr that start with a 'yield' identifier, then parse out @@ -8764,7 +9090,7 @@ var ts; // for now we just check if the next token is an identifier. More heuristics // can be added here later as necessary. We just need to make sure that we // don't accidently consume something legal. - return lookAhead(nextTokenIsIdentifierOnSameLine); + return lookAhead(nextTokenIsIdentifierOrKeywordOrNumberOnSameLine); } return false; } @@ -8773,7 +9099,7 @@ var ts; return !scanner.hasPrecedingLineBreak() && isIdentifier(); } function parseYieldExpression() { - var node = createNode(173 /* YieldExpression */); + var node = createNode(175 /* YieldExpression */); // YieldExpression[In] : // yield // yield [no LineTerminator here] [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield] @@ -8793,8 +9119,8 @@ var ts; } function parseSimpleArrowFunctionExpression(identifier) { ts.Debug.assert(token === 32 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(164 /* ArrowFunction */, identifier.pos); - var parameter = createNode(130 /* Parameter */, identifier.pos); + var node = createNode(166 /* ArrowFunction */, identifier.pos); + var parameter = createNode(131 /* Parameter */, identifier.pos); parameter.name = identifier; finishNode(parameter); node.parameters = [parameter]; @@ -8912,7 +9238,7 @@ var ts; return parseParenthesizedArrowFunctionExpressionHead(false); } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { - var node = createNode(164 /* ArrowFunction */); + var node = createNode(166 /* ArrowFunction */); // Arrow functions are never generators. // // If we're speculatively parsing a signature for a parenthesized arrow function, then @@ -8974,7 +9300,7 @@ var ts; } // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and // we do not that for the 'whenFalse' part. - var node = createNode(171 /* ConditionalExpression */, leftOperand.pos); + var node = createNode(173 /* ConditionalExpression */, leftOperand.pos); node.condition = leftOperand; node.questionToken = questionToken; node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher); @@ -8987,7 +9313,7 @@ var ts; return parseBinaryExpressionRest(precedence, leftOperand); } function isInOrOfKeyword(t) { - return t === 86 /* InKeyword */ || t === 126 /* OfKeyword */; + return t === 86 /* InKeyword */ || t === 127 /* OfKeyword */; } function parseBinaryExpressionRest(precedence, leftOperand) { while (true) { @@ -9053,33 +9379,33 @@ var ts; return -1; } function makeBinaryExpression(left, operatorToken, right) { - var node = createNode(170 /* BinaryExpression */, left.pos); + var node = createNode(172 /* BinaryExpression */, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; return finishNode(node); } function parsePrefixUnaryExpression() { - var node = createNode(168 /* PrefixUnaryExpression */); + var node = createNode(170 /* PrefixUnaryExpression */); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseDeleteExpression() { - var node = createNode(165 /* DeleteExpression */); + var node = createNode(167 /* DeleteExpression */); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(166 /* TypeOfExpression */); + var node = createNode(168 /* TypeOfExpression */); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(167 /* VoidExpression */); + var node = createNode(169 /* VoidExpression */); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); @@ -9109,7 +9435,7 @@ var ts; var expression = parseLeftHandSideExpressionOrHigher(); ts.Debug.assert(ts.isLeftHandSideExpression(expression)); if ((token === 38 /* PlusPlusToken */ || token === 39 /* MinusMinusToken */) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(169 /* PostfixUnaryExpression */, expression.pos); + var node = createNode(171 /* PostfixUnaryExpression */, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -9213,14 +9539,14 @@ var ts; } // If we have seen "super" it must be followed by '(' or '.'. // If it wasn't then just try to parse out a '.' and report an error. - var node = createNode(156 /* PropertyAccessExpression */, expression.pos); + var node = createNode(158 /* PropertyAccessExpression */, expression.pos); node.expression = expression; node.dotToken = parseExpectedToken(20 /* DotToken */, false, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); node.name = parseRightSideOfDot(true); return finishNode(node); } function parseTypeAssertion() { - var node = createNode(161 /* TypeAssertionExpression */); + var node = createNode(163 /* TypeAssertionExpression */); parseExpected(24 /* LessThanToken */); node.type = parseType(); parseExpected(25 /* GreaterThanToken */); @@ -9231,7 +9557,7 @@ var ts; while (true) { var dotToken = parseOptionalToken(20 /* DotToken */); if (dotToken) { - var propertyAccess = createNode(156 /* PropertyAccessExpression */, expression.pos); + var propertyAccess = createNode(158 /* PropertyAccessExpression */, expression.pos); propertyAccess.expression = expression; propertyAccess.dotToken = dotToken; propertyAccess.name = parseRightSideOfDot(true); @@ -9240,7 +9566,7 @@ var ts; } // when in the [Decorator] context, we do not parse ElementAccess as it could be part of a ComputedPropertyName if (!inDecoratorContext() && parseOptional(18 /* OpenBracketToken */)) { - var indexedAccess = createNode(157 /* ElementAccessExpression */, expression.pos); + var indexedAccess = createNode(159 /* ElementAccessExpression */, expression.pos); indexedAccess.expression = expression; // It's not uncommon for a user to write: "new Type[]". // Check for that common pattern and report a better error message. @@ -9256,7 +9582,7 @@ var ts; continue; } if (token === 10 /* NoSubstitutionTemplateLiteral */ || token === 11 /* TemplateHead */) { - var tagExpression = createNode(160 /* TaggedTemplateExpression */, expression.pos); + var tagExpression = createNode(162 /* TaggedTemplateExpression */, expression.pos); tagExpression.tag = expression; tagExpression.template = token === 10 /* NoSubstitutionTemplateLiteral */ ? parseLiteralNode() @@ -9279,7 +9605,7 @@ var ts; if (!typeArguments) { return expression; } - var callExpr = createNode(158 /* CallExpression */, expression.pos); + var callExpr = createNode(160 /* CallExpression */, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); @@ -9287,7 +9613,7 @@ var ts; continue; } else if (token === 16 /* OpenParenToken */) { - var callExpr = createNode(158 /* CallExpression */, expression.pos); + var callExpr = createNode(160 /* CallExpression */, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -9298,7 +9624,7 @@ var ts; } function parseArgumentList() { parseExpected(16 /* OpenParenToken */); - var result = parseDelimitedList(12 /* ArgumentExpressions */, parseArgumentExpression); + var result = parseDelimitedList(11 /* ArgumentExpressions */, parseArgumentExpression); parseExpected(17 /* CloseParenToken */); return result; } @@ -9306,7 +9632,7 @@ var ts; if (!parseOptional(24 /* LessThanToken */)) { return undefined; } - var typeArguments = parseDelimitedList(17 /* TypeArguments */, parseType); + var typeArguments = parseDelimitedList(16 /* TypeArguments */, parseType); if (!parseExpected(25 /* GreaterThanToken */)) { // If it doesn't have the closing > then it's definitely not an type argument list. return undefined; @@ -9389,41 +9715,41 @@ var ts; return parseIdentifier(ts.Diagnostics.Expression_expected); } function parseParenthesizedExpression() { - var node = createNode(162 /* ParenthesizedExpression */); + var node = createNode(164 /* ParenthesizedExpression */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); parseExpected(17 /* CloseParenToken */); return finishNode(node); } function parseSpreadElement() { - var node = createNode(174 /* SpreadElementExpression */); + var node = createNode(176 /* SpreadElementExpression */); parseExpected(21 /* DotDotDotToken */); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } function parseArgumentOrArrayLiteralElement() { return token === 21 /* DotDotDotToken */ ? parseSpreadElement() : - token === 23 /* CommaToken */ ? createNode(176 /* OmittedExpression */) : + token === 23 /* CommaToken */ ? createNode(178 /* OmittedExpression */) : parseAssignmentExpressionOrHigher(); } function parseArgumentExpression() { return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement); } function parseArrayLiteralExpression() { - var node = createNode(154 /* ArrayLiteralExpression */); + var node = createNode(156 /* ArrayLiteralExpression */); parseExpected(18 /* OpenBracketToken */); if (scanner.hasPrecedingLineBreak()) node.flags |= 512 /* MultiLine */; - node.elements = parseDelimitedList(14 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement); + node.elements = parseDelimitedList(13 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement); parseExpected(19 /* CloseBracketToken */); return finishNode(node); } function tryParseAccessorDeclaration(fullStart, decorators, modifiers) { if (parseContextualModifier(116 /* GetKeyword */)) { - return parseAccessorDeclaration(137 /* GetAccessor */, fullStart, decorators, modifiers); + return parseAccessorDeclaration(138 /* GetAccessor */, fullStart, decorators, modifiers); } - else if (parseContextualModifier(121 /* SetKeyword */)) { - return parseAccessorDeclaration(138 /* SetAccessor */, fullStart, decorators, modifiers); + else if (parseContextualModifier(122 /* SetKeyword */)) { + return parseAccessorDeclaration(139 /* SetAccessor */, fullStart, decorators, modifiers); } return undefined; } @@ -9446,13 +9772,13 @@ var ts; } // Parse to check if it is short-hand property assignment or normal property assignment if ((token === 23 /* CommaToken */ || token === 15 /* CloseBraceToken */) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(226 /* ShorthandPropertyAssignment */, fullStart); + var shorthandDeclaration = createNode(228 /* ShorthandPropertyAssignment */, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(225 /* PropertyAssignment */, fullStart); + var propertyAssignment = createNode(227 /* PropertyAssignment */, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; parseExpected(51 /* ColonToken */); @@ -9461,12 +9787,12 @@ var ts; } } function parseObjectLiteralExpression() { - var node = createNode(155 /* ObjectLiteralExpression */); + var node = createNode(157 /* ObjectLiteralExpression */); parseExpected(14 /* OpenBraceToken */); if (scanner.hasPrecedingLineBreak()) { node.flags |= 512 /* MultiLine */; } - node.properties = parseDelimitedList(13 /* ObjectLiteralMembers */, parseObjectLiteralElement, true); + node.properties = parseDelimitedList(12 /* ObjectLiteralMembers */, parseObjectLiteralElement, true); parseExpected(15 /* CloseBraceToken */); return finishNode(node); } @@ -9479,7 +9805,7 @@ var ts; if (saveDecoratorContext) { setDecoratorContext(false); } - var node = createNode(163 /* FunctionExpression */); + var node = createNode(165 /* FunctionExpression */); parseExpected(83 /* FunctionKeyword */); node.asteriskToken = parseOptionalToken(35 /* AsteriskToken */); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); @@ -9494,7 +9820,7 @@ var ts; return isIdentifier() ? parseIdentifier() : undefined; } function parseNewExpression() { - var node = createNode(159 /* NewExpression */); + var node = createNode(161 /* NewExpression */); parseExpected(88 /* NewKeyword */); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); @@ -9504,10 +9830,10 @@ var ts; return finishNode(node); } // STATEMENTS - function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { - var node = createNode(180 /* Block */); + function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) { + var node = createNode(182 /* Block */); if (parseExpected(14 /* OpenBraceToken */, diagnosticMessage) || ignoreMissingOpenBrace) { - node.statements = parseList(2 /* BlockStatements */, checkForStrictMode, parseStatement); + node.statements = parseList(1 /* BlockStatements */, parseStatement); parseExpected(15 /* CloseBraceToken */); } else { @@ -9524,7 +9850,7 @@ var ts; if (saveDecoratorContext) { setDecoratorContext(false); } - var block = parseBlock(ignoreMissingOpenBrace, true, diagnosticMessage); + var block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage); if (saveDecoratorContext) { setDecoratorContext(true); } @@ -9532,12 +9858,12 @@ var ts; return block; } function parseEmptyStatement() { - var node = createNode(182 /* EmptyStatement */); + var node = createNode(184 /* EmptyStatement */); parseExpected(22 /* SemicolonToken */); return finishNode(node); } function parseIfStatement() { - var node = createNode(184 /* IfStatement */); + var node = createNode(186 /* IfStatement */); parseExpected(84 /* IfKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); @@ -9547,7 +9873,7 @@ var ts; return finishNode(node); } function parseDoStatement() { - var node = createNode(185 /* DoStatement */); + var node = createNode(187 /* DoStatement */); parseExpected(75 /* DoKeyword */); node.statement = parseStatement(); parseExpected(100 /* WhileKeyword */); @@ -9562,7 +9888,7 @@ var ts; return finishNode(node); } function parseWhileStatement() { - var node = createNode(186 /* WhileStatement */); + var node = createNode(188 /* WhileStatement */); parseExpected(100 /* WhileKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); @@ -9585,21 +9911,21 @@ var ts; } var forOrForInOrForOfStatement; if (parseOptional(86 /* InKeyword */)) { - var forInStatement = createNode(188 /* ForInStatement */, pos); + var forInStatement = createNode(190 /* ForInStatement */, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); parseExpected(17 /* CloseParenToken */); forOrForInOrForOfStatement = forInStatement; } - else if (parseOptional(126 /* OfKeyword */)) { - var forOfStatement = createNode(189 /* ForOfStatement */, pos); + else if (parseOptional(127 /* OfKeyword */)) { + var forOfStatement = createNode(191 /* ForOfStatement */, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(17 /* CloseParenToken */); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(187 /* ForStatement */, pos); + var forStatement = createNode(189 /* ForStatement */, pos); forStatement.initializer = initializer; parseExpected(22 /* SemicolonToken */); if (token !== 22 /* SemicolonToken */ && token !== 17 /* CloseParenToken */) { @@ -9617,7 +9943,7 @@ var ts; } function parseBreakOrContinueStatement(kind) { var node = createNode(kind); - parseExpected(kind === 191 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */); + parseExpected(kind === 193 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */); if (!canParseSemicolon()) { node.label = parseIdentifier(); } @@ -9625,7 +9951,7 @@ var ts; return finishNode(node); } function parseReturnStatement() { - var node = createNode(192 /* ReturnStatement */); + var node = createNode(194 /* ReturnStatement */); parseExpected(90 /* ReturnKeyword */); if (!canParseSemicolon()) { node.expression = allowInAnd(parseExpression); @@ -9634,7 +9960,7 @@ var ts; return finishNode(node); } function parseWithStatement() { - var node = createNode(193 /* WithStatement */); + var node = createNode(195 /* WithStatement */); parseExpected(101 /* WithKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); @@ -9643,32 +9969,32 @@ var ts; return finishNode(node); } function parseCaseClause() { - var node = createNode(221 /* CaseClause */); + var node = createNode(223 /* CaseClause */); parseExpected(67 /* CaseKeyword */); node.expression = allowInAnd(parseExpression); parseExpected(51 /* ColonToken */); - node.statements = parseList(4 /* SwitchClauseStatements */, false, parseStatement); + node.statements = parseList(3 /* SwitchClauseStatements */, parseStatement); return finishNode(node); } function parseDefaultClause() { - var node = createNode(222 /* DefaultClause */); + var node = createNode(224 /* DefaultClause */); parseExpected(73 /* DefaultKeyword */); parseExpected(51 /* ColonToken */); - node.statements = parseList(4 /* SwitchClauseStatements */, false, parseStatement); + node.statements = parseList(3 /* SwitchClauseStatements */, parseStatement); return finishNode(node); } function parseCaseOrDefaultClause() { return token === 67 /* CaseKeyword */ ? parseCaseClause() : parseDefaultClause(); } function parseSwitchStatement() { - var node = createNode(194 /* SwitchStatement */); + var node = createNode(196 /* SwitchStatement */); parseExpected(92 /* SwitchKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); parseExpected(17 /* CloseParenToken */); - var caseBlock = createNode(208 /* CaseBlock */, scanner.getStartPos()); + var caseBlock = createNode(210 /* CaseBlock */, scanner.getStartPos()); parseExpected(14 /* OpenBraceToken */); - caseBlock.clauses = parseList(3 /* SwitchClauses */, false, parseCaseOrDefaultClause); + caseBlock.clauses = parseList(2 /* SwitchClauses */, parseCaseOrDefaultClause); parseExpected(15 /* CloseBraceToken */); node.caseBlock = finishNode(caseBlock); return finishNode(node); @@ -9681,7 +10007,7 @@ var ts; // directly as that might consume an expression on the following line. // We just return 'undefined' in that case. The actual error will be reported in the // grammar walker. - var node = createNode(196 /* ThrowStatement */); + var node = createNode(198 /* ThrowStatement */); parseExpected(94 /* ThrowKeyword */); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); @@ -9689,30 +10015,30 @@ var ts; } // TODO: Review for error recovery function parseTryStatement() { - var node = createNode(197 /* TryStatement */); + var node = createNode(199 /* TryStatement */); parseExpected(96 /* TryKeyword */); - node.tryBlock = parseBlock(false, false); + node.tryBlock = parseBlock(false); node.catchClause = token === 68 /* CatchKeyword */ ? parseCatchClause() : undefined; // If we don't have a catch clause, then we must have a finally clause. Try to parse // one out no matter what. if (!node.catchClause || token === 81 /* FinallyKeyword */) { parseExpected(81 /* FinallyKeyword */); - node.finallyBlock = parseBlock(false, false); + node.finallyBlock = parseBlock(false); } return finishNode(node); } function parseCatchClause() { - var result = createNode(224 /* CatchClause */); + var result = createNode(226 /* CatchClause */); parseExpected(68 /* CatchKeyword */); if (parseExpected(16 /* OpenParenToken */)) { result.variableDeclaration = parseVariableDeclaration(); } parseExpected(17 /* CloseParenToken */); - result.block = parseBlock(false, false); + result.block = parseBlock(false); return finishNode(result); } function parseDebuggerStatement() { - var node = createNode(198 /* DebuggerStatement */); + var node = createNode(200 /* DebuggerStatement */); parseExpected(72 /* DebuggerKeyword */); parseSemicolon(); return finishNode(node); @@ -9724,13 +10050,13 @@ var ts; var fullStart = scanner.getStartPos(); var expression = allowInAnd(parseExpression); if (expression.kind === 65 /* Identifier */ && parseOptional(51 /* ColonToken */)) { - var labeledStatement = createNode(195 /* LabeledStatement */, fullStart); + var labeledStatement = createNode(197 /* LabeledStatement */, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(183 /* ExpressionStatement */, fullStart); + var expressionStatement = createNode(185 /* ExpressionStatement */, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); @@ -9743,7 +10069,11 @@ var ts; nextToken(); return isIdentifierOrKeyword() && !scanner.hasPrecedingLineBreak(); } - function parseDeclarationFlags() { + function nextTokenIsIdentifierOrKeywordOrNumberOnSameLine() { + nextToken(); + return (isIdentifierOrKeyword() || token === 7 /* NumericLiteral */) && !scanner.hasPrecedingLineBreak(); + } + function isDeclaration() { while (true) { switch (token) { case 98 /* VarKeyword */: @@ -9752,28 +10082,52 @@ var ts; case 83 /* FunctionKeyword */: case 69 /* ClassKeyword */: case 77 /* EnumKeyword */: - return 1 /* Statement */; + return true; + // 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers; + // however, an identifier cannot be followed by another identifier on the same line. This is what we + // count on to parse out the respective declarations. For instance, we exploit this to say that + // + // namespace n + // + // can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees + // + // namespace + // n + // + // as the identifier 'namespace' on one line followed by the identifier 'n' on another. + // We need to look one token ahead to see if it permissible to try parsing a declaration. + // + // *Note*: 'interface' is actually a strict mode reserved word. So while + // + // "use strict" + // interface + // I {} + // + // could be legal, it would add complexity for very little gain. case 103 /* InterfaceKeyword */: - case 124 /* TypeKeyword */: + case 125 /* TypeKeyword */: + return nextTokenIsIdentifierOnSameLine(); + case 118 /* ModuleKeyword */: + case 119 /* NamespaceKeyword */: + return nextTokenIsIdentifierOrStringLiteralOnSameLine(); + case 115 /* DeclareKeyword */: nextToken(); - return isIdentifierOrKeyword() ? 1 /* Statement */ : 0 /* None */; - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: - nextToken(); - return isIdentifierOrKeyword() || token === 8 /* StringLiteral */ ? 2 /* ModuleElement */ : 0 /* None */; + // ASI takes effect for this modifier. + if (scanner.hasPrecedingLineBreak()) { + return false; + } + continue; case 85 /* ImportKeyword */: nextToken(); return token === 8 /* StringLiteral */ || token === 35 /* AsteriskToken */ || - token === 14 /* OpenBraceToken */ || isIdentifierOrKeyword() ? - 2 /* ModuleElement */ : 0 /* None */; + token === 14 /* OpenBraceToken */ || isIdentifierOrKeyword(); case 78 /* ExportKeyword */: nextToken(); if (token === 53 /* EqualsToken */ || token === 35 /* AsteriskToken */ || token === 14 /* OpenBraceToken */ || token === 73 /* DefaultKeyword */) { - return 2 /* ModuleElement */; + return true; } continue; - case 115 /* DeclareKeyword */: case 108 /* PublicKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: @@ -9781,14 +10135,14 @@ var ts; nextToken(); continue; default: - return 0 /* None */; + return false; } } } - function getDeclarationFlags() { - return lookAhead(parseDeclarationFlags); + function isStartOfDeclaration() { + return lookAhead(isDeclaration); } - function getStatementFlags() { + function isStartOfStatement() { switch (token) { case 52 /* AtToken */: case 22 /* SemicolonToken */: @@ -9814,61 +10168,44 @@ var ts; // however, we say they are here so that we may gracefully parse them and error later. case 68 /* CatchKeyword */: case 81 /* FinallyKeyword */: - return 1 /* Statement */; + return true; case 70 /* ConstKeyword */: case 78 /* ExportKeyword */: case 85 /* ImportKeyword */: - return getDeclarationFlags(); + return isStartOfDeclaration(); case 115 /* DeclareKeyword */: case 103 /* InterfaceKeyword */: - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: - case 124 /* TypeKeyword */: + case 118 /* ModuleKeyword */: + case 119 /* NamespaceKeyword */: + case 125 /* TypeKeyword */: // When these don't start a declaration, they're an identifier in an expression statement - return getDeclarationFlags() || 1 /* Statement */; + return true; case 108 /* PublicKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: case 109 /* StaticKeyword */: // When these don't start a declaration, they may be the start of a class member if an identifier // immediately follows. Otherwise they're an identifier in an expression statement. - return getDeclarationFlags() || - (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? 0 /* None */ : 1 /* Statement */); + return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); default: - return isStartOfExpression() ? 1 /* Statement */ : 0 /* None */; + return isStartOfExpression(); } } - function isStartOfStatement() { - return (getStatementFlags() & 1 /* Statement */) !== 0; - } - function isStartOfModuleElement() { - return (getStatementFlags() & 3 /* StatementOrModuleElement */) !== 0; - } - function nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine() { + function nextTokenIsIdentifierOrStartOfDestructuring() { nextToken(); - return !scanner.hasPrecedingLineBreak() && - (isIdentifier() || token === 14 /* OpenBraceToken */ || token === 18 /* OpenBracketToken */); + return isIdentifier() || token === 14 /* OpenBraceToken */ || token === 18 /* OpenBracketToken */; } function isLetDeclaration() { - // It is let declaration if in strict mode or next token is identifier\open bracket\open curly on same line. - // otherwise it needs to be treated like identifier - return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine); + // In ES6 'let' always starts a lexical declaration if followed by an identifier or { + // or [. + return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring); } function parseStatement() { - return parseModuleElementOfKind(1 /* Statement */); - } - function parseModuleElement() { - return parseModuleElementOfKind(3 /* StatementOrModuleElement */); - } - function parseSourceElement() { - return parseModuleElementOfKind(3 /* StatementOrModuleElement */); - } - function parseModuleElementOfKind(flags) { switch (token) { case 22 /* SemicolonToken */: return parseEmptyStatement(); case 14 /* OpenBraceToken */: - return parseBlock(false, false); + return parseBlock(false); case 98 /* VarKeyword */: return parseVariableStatement(scanner.getStartPos(), undefined, undefined); case 104 /* LetKeyword */: @@ -9889,9 +10226,9 @@ var ts; case 82 /* ForKeyword */: return parseForOrForInOrForOfStatement(); case 71 /* ContinueKeyword */: - return parseBreakOrContinueStatement(190 /* ContinueStatement */); + return parseBreakOrContinueStatement(192 /* ContinueStatement */); case 66 /* BreakKeyword */: - return parseBreakOrContinueStatement(191 /* BreakStatement */); + return parseBreakOrContinueStatement(193 /* BreakStatement */); case 90 /* ReturnKeyword */: return parseReturnStatement(); case 101 /* WithKeyword */: @@ -9901,7 +10238,7 @@ var ts; case 94 /* ThrowKeyword */: return parseThrowStatement(); case 96 /* TryKeyword */: - // Include the next two for error recovery. + // Include 'catch' and 'finally' for error recovery. case 68 /* CatchKeyword */: case 81 /* FinallyKeyword */: return parseTryStatement(); @@ -9909,20 +10246,20 @@ var ts; return parseDebuggerStatement(); case 52 /* AtToken */: return parseDeclaration(); - case 70 /* ConstKeyword */: + case 103 /* InterfaceKeyword */: + case 125 /* TypeKeyword */: + case 118 /* ModuleKeyword */: + case 119 /* NamespaceKeyword */: case 115 /* DeclareKeyword */: + case 70 /* ConstKeyword */: case 77 /* EnumKeyword */: case 78 /* ExportKeyword */: case 85 /* ImportKeyword */: - case 103 /* InterfaceKeyword */: - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: case 108 /* PublicKeyword */: case 109 /* StaticKeyword */: - case 124 /* TypeKeyword */: - if (getDeclarationFlags() & flags) { + if (isStartOfDeclaration()) { return parseDeclaration(); } break; @@ -9944,12 +10281,12 @@ var ts; return parseClassDeclaration(fullStart, decorators, modifiers); case 103 /* InterfaceKeyword */: return parseInterfaceDeclaration(fullStart, decorators, modifiers); - case 124 /* TypeKeyword */: + case 125 /* TypeKeyword */: return parseTypeAliasDeclaration(fullStart, decorators, modifiers); case 77 /* EnumKeyword */: return parseEnumDeclaration(fullStart, decorators, modifiers); - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: + case 118 /* ModuleKeyword */: + case 119 /* NamespaceKeyword */: return parseModuleDeclaration(fullStart, decorators, modifiers); case 85 /* ImportKeyword */: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); @@ -9959,10 +10296,10 @@ var ts; parseExportAssignment(fullStart, decorators, modifiers) : parseExportDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { + if (decorators || modifiers) { // We reached this point because we encountered decorators and/or modifiers and assumed a declaration // would follow. For recovery and error reporting purposes, return an incomplete declaration. - var node = createMissingNode(219 /* MissingDeclaration */, true, ts.Diagnostics.Declaration_expected); + var node = createMissingNode(221 /* MissingDeclaration */, true, ts.Diagnostics.Declaration_expected); node.pos = fullStart; node.decorators = decorators; setModifiers(node, modifiers); @@ -9970,6 +10307,10 @@ var ts; } } } + function nextTokenIsIdentifierOrStringLiteralOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token === 8 /* StringLiteral */); + } function parseFunctionBlockOrSemicolon(isGenerator, diagnosticMessage) { if (token !== 14 /* OpenBraceToken */ && canParseSemicolon()) { parseSemicolon(); @@ -9980,16 +10321,16 @@ var ts; // DECLARATIONS function parseArrayBindingElement() { if (token === 23 /* CommaToken */) { - return createNode(176 /* OmittedExpression */); + return createNode(178 /* OmittedExpression */); } - var node = createNode(153 /* BindingElement */); + var node = createNode(155 /* BindingElement */); node.dotDotDotToken = parseOptionalToken(21 /* DotDotDotToken */); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(false); return finishNode(node); } function parseObjectBindingElement() { - var node = createNode(153 /* BindingElement */); + var node = createNode(155 /* BindingElement */); // TODO(andersh): Handle computed properties var tokenIsIdentifier = isIdentifier(); var propertyName = parsePropertyName(); @@ -10005,16 +10346,16 @@ var ts; return finishNode(node); } function parseObjectBindingPattern() { - var node = createNode(151 /* ObjectBindingPattern */); + var node = createNode(153 /* ObjectBindingPattern */); parseExpected(14 /* OpenBraceToken */); - node.elements = parseDelimitedList(10 /* ObjectBindingElements */, parseObjectBindingElement); + node.elements = parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement); parseExpected(15 /* CloseBraceToken */); return finishNode(node); } function parseArrayBindingPattern() { - var node = createNode(152 /* ArrayBindingPattern */); + var node = createNode(154 /* ArrayBindingPattern */); parseExpected(18 /* OpenBracketToken */); - node.elements = parseDelimitedList(11 /* ArrayBindingElements */, parseArrayBindingElement); + node.elements = parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement); parseExpected(19 /* CloseBracketToken */); return finishNode(node); } @@ -10031,7 +10372,7 @@ var ts; return parseIdentifier(); } function parseVariableDeclaration() { - var node = createNode(199 /* VariableDeclaration */); + var node = createNode(201 /* VariableDeclaration */); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -10040,7 +10381,7 @@ var ts; return finishNode(node); } function parseVariableDeclarationList(inForStatementInitializer) { - var node = createNode(200 /* VariableDeclarationList */); + var node = createNode(202 /* VariableDeclarationList */); switch (token) { case 98 /* VarKeyword */: break; @@ -10063,13 +10404,13 @@ var ts; // So we need to look ahead to determine if 'of' should be treated as a keyword in // this context. // The checker will then give an error that there is an empty declaration list. - if (token === 126 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) { + if (token === 127 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) { node.declarations = createMissingList(); } else { var savedDisallowIn = inDisallowInContext(); setDisallowInContext(inForStatementInitializer); - node.declarations = parseDelimitedList(9 /* VariableDeclarations */, parseVariableDeclaration); + node.declarations = parseDelimitedList(8 /* VariableDeclarations */, parseVariableDeclaration); setDisallowInContext(savedDisallowIn); } return finishNode(node); @@ -10078,7 +10419,7 @@ var ts; return nextTokenIsIdentifier() && nextToken() === 17 /* CloseParenToken */; } function parseVariableStatement(fullStart, decorators, modifiers) { - var node = createNode(181 /* VariableStatement */, fullStart); + var node = createNode(183 /* VariableStatement */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(false); @@ -10086,7 +10427,7 @@ var ts; return finishNode(node); } function parseFunctionDeclaration(fullStart, decorators, modifiers) { - var node = createNode(201 /* FunctionDeclaration */, fullStart); + var node = createNode(203 /* FunctionDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(83 /* FunctionKeyword */); @@ -10097,7 +10438,7 @@ var ts; return finishNode(node); } function parseConstructorDeclaration(pos, decorators, modifiers) { - var node = createNode(136 /* Constructor */, pos); + var node = createNode(137 /* Constructor */, pos); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(114 /* ConstructorKeyword */); @@ -10106,7 +10447,7 @@ var ts; return finishNode(node); } function parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { - var method = createNode(135 /* MethodDeclaration */, fullStart); + var method = createNode(136 /* MethodDeclaration */, fullStart); method.decorators = decorators; setModifiers(method, modifiers); method.asteriskToken = asteriskToken; @@ -10117,7 +10458,7 @@ var ts; return finishNode(method); } function parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken) { - var property = createNode(133 /* PropertyDeclaration */, fullStart); + var property = createNode(134 /* PropertyDeclaration */, fullStart); property.decorators = decorators; setModifiers(property, modifiers); property.name = name; @@ -10209,7 +10550,7 @@ var ts; // If we were able to get any potential identifier... if (idToken !== undefined) { // If we have a non-keyword identifier, or if we have an accessor, then it's safe to parse. - if (!ts.isKeyword(idToken) || idToken === 121 /* SetKeyword */ || idToken === 116 /* GetKeyword */) { + if (!ts.isKeyword(idToken) || idToken === 122 /* SetKeyword */ || idToken === 116 /* GetKeyword */) { return true; } // If it *is* a keyword, but not an accessor, check a little farther along @@ -10243,7 +10584,7 @@ var ts; decorators = []; decorators.pos = scanner.getStartPos(); } - var decorator = createNode(131 /* Decorator */, decoratorStart); + var decorator = createNode(132 /* Decorator */, decoratorStart); decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher); decorators.push(finishNode(decorator)); } @@ -10276,7 +10617,7 @@ var ts; } function parseClassElement() { if (token === 22 /* SemicolonToken */) { - var result = createNode(179 /* SemicolonClassElement */); + var result = createNode(181 /* SemicolonClassElement */); nextToken(); return finishNode(result); } @@ -10302,7 +10643,7 @@ var ts; token === 18 /* OpenBracketToken */) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { // treat this as a property declaration with a missing name. var name_6 = createMissingNode(65 /* Identifier */, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_6, undefined); @@ -10314,15 +10655,12 @@ var ts; return parseClassDeclarationOrExpression( /*fullStart*/ scanner.getStartPos(), /*decorators*/ undefined, - /*modifiers*/ undefined, 175 /* ClassExpression */); + /*modifiers*/ undefined, 177 /* ClassExpression */); } function parseClassDeclaration(fullStart, decorators, modifiers) { - return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 202 /* ClassDeclaration */); + return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 204 /* ClassDeclaration */); } function parseClassDeclarationOrExpression(fullStart, decorators, modifiers, kind) { - // In ES6 specification, All parts of a ClassDeclaration or a ClassExpression are strict mode code - var savedStrictModeContext = inStrictModeContext(); - setStrictModeContext(true); var node = createNode(kind, fullStart); node.decorators = decorators; setModifiers(node, modifiers); @@ -10342,9 +10680,7 @@ var ts; else { node.members = createMissingList(); } - var finishedNode = finishNode(node); - setStrictModeContext(savedStrictModeContext); - return finishedNode; + return finishNode(node); } function parseHeritageClauses(isClassHeritageClause) { // ClassTail[Yield,GeneratorParameter] : See 14.5 @@ -10358,23 +10694,23 @@ var ts; return undefined; } function parseHeritageClausesWorker() { - return parseList(19 /* HeritageClauses */, false, parseHeritageClause); + return parseList(18 /* HeritageClauses */, parseHeritageClause); } function parseHeritageClause() { if (token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */) { - var node = createNode(223 /* HeritageClause */); + var node = createNode(225 /* HeritageClause */); node.token = token; nextToken(); - node.types = parseDelimitedList(8 /* HeritageClauseElement */, parseExpressionWithTypeArguments); + node.types = parseDelimitedList(7 /* HeritageClauseElement */, parseExpressionWithTypeArguments); return finishNode(node); } return undefined; } function parseExpressionWithTypeArguments() { - var node = createNode(177 /* ExpressionWithTypeArguments */); + var node = createNode(179 /* ExpressionWithTypeArguments */); node.expression = parseLeftHandSideExpressionOrHigher(); if (token === 24 /* LessThanToken */) { - node.typeArguments = parseBracketedList(17 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + node.typeArguments = parseBracketedList(16 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); } return finishNode(node); } @@ -10382,10 +10718,10 @@ var ts; return token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; } function parseClassMembers() { - return parseList(6 /* ClassMembers */, false, parseClassElement); + return parseList(5 /* ClassMembers */, parseClassElement); } function parseInterfaceDeclaration(fullStart, decorators, modifiers) { - var node = createNode(203 /* InterfaceDeclaration */, fullStart); + var node = createNode(205 /* InterfaceDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(103 /* InterfaceKeyword */); @@ -10396,11 +10732,12 @@ var ts; return finishNode(node); } function parseTypeAliasDeclaration(fullStart, decorators, modifiers) { - var node = createNode(204 /* TypeAliasDeclaration */, fullStart); + var node = createNode(206 /* TypeAliasDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(124 /* TypeKeyword */); + parseExpected(125 /* TypeKeyword */); node.name = parseIdentifier(); + node.typeParameters = parseTypeParameters(); parseExpected(53 /* EqualsToken */); node.type = parseType(); parseSemicolon(); @@ -10411,19 +10748,19 @@ var ts; // ConstantEnumMemberSection, which starts at the beginning of an enum declaration // or any time an integer literal initializer is encountered. function parseEnumMember() { - var node = createNode(227 /* EnumMember */, scanner.getStartPos()); + var node = createNode(229 /* EnumMember */, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart, decorators, modifiers) { - var node = createNode(205 /* EnumDeclaration */, fullStart); + var node = createNode(207 /* EnumDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(77 /* EnumKeyword */); node.name = parseIdentifier(); if (parseExpected(14 /* OpenBraceToken */)) { - node.members = parseDelimitedList(7 /* EnumMembers */, parseEnumMember); + node.members = parseDelimitedList(6 /* EnumMembers */, parseEnumMember); parseExpected(15 /* CloseBraceToken */); } else { @@ -10432,9 +10769,9 @@ var ts; return finishNode(node); } function parseModuleBlock() { - var node = createNode(207 /* ModuleBlock */, scanner.getStartPos()); + var node = createNode(209 /* ModuleBlock */, scanner.getStartPos()); if (parseExpected(14 /* OpenBraceToken */)) { - node.statements = parseList(1 /* ModuleElements */, false, parseModuleElement); + node.statements = parseList(1 /* BlockStatements */, parseStatement); parseExpected(15 /* CloseBraceToken */); } else { @@ -10443,7 +10780,7 @@ var ts; return finishNode(node); } function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) { - var node = createNode(206 /* ModuleDeclaration */, fullStart); + var node = createNode(208 /* ModuleDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.flags |= flags; @@ -10454,7 +10791,7 @@ var ts; return finishNode(node); } function parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers) { - var node = createNode(206 /* ModuleDeclaration */, fullStart); + var node = createNode(208 /* ModuleDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.name = parseLiteralNode(true); @@ -10463,11 +10800,11 @@ var ts; } function parseModuleDeclaration(fullStart, decorators, modifiers) { var flags = modifiers ? modifiers.flags : 0; - if (parseOptional(118 /* NamespaceKeyword */)) { + if (parseOptional(119 /* NamespaceKeyword */)) { flags |= 32768 /* Namespace */; } else { - parseExpected(117 /* ModuleKeyword */); + parseExpected(118 /* ModuleKeyword */); if (token === 8 /* StringLiteral */) { return parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers); } @@ -10475,7 +10812,7 @@ var ts; return parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags); } function isExternalModuleReference() { - return token === 119 /* RequireKeyword */ && + return token === 120 /* RequireKeyword */ && lookAhead(nextTokenIsOpenParen); } function nextTokenIsOpenParen() { @@ -10484,7 +10821,7 @@ var ts; function nextTokenIsCommaOrFromKeyword() { nextToken(); return token === 23 /* CommaToken */ || - token === 125 /* FromKeyword */; + token === 126 /* FromKeyword */; } function parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers) { parseExpected(85 /* ImportKeyword */); @@ -10492,11 +10829,11 @@ var ts; var identifier; if (isIdentifier()) { identifier = parseIdentifier(); - if (token !== 23 /* CommaToken */ && token !== 125 /* FromKeyword */) { + if (token !== 23 /* CommaToken */ && token !== 126 /* FromKeyword */) { // ImportEquals declaration of type: // import x = require("mod"); or // import x = M.x; - var importEqualsDeclaration = createNode(209 /* ImportEqualsDeclaration */, fullStart); + var importEqualsDeclaration = createNode(211 /* ImportEqualsDeclaration */, fullStart); importEqualsDeclaration.decorators = decorators; setModifiers(importEqualsDeclaration, modifiers); importEqualsDeclaration.name = identifier; @@ -10507,7 +10844,7 @@ var ts; } } // Import statement - var importDeclaration = createNode(210 /* ImportDeclaration */, fullStart); + var importDeclaration = createNode(212 /* ImportDeclaration */, fullStart); importDeclaration.decorators = decorators; setModifiers(importDeclaration, modifiers); // ImportDeclaration: @@ -10517,7 +10854,7 @@ var ts; token === 35 /* AsteriskToken */ || token === 14 /* OpenBraceToken */) { importDeclaration.importClause = parseImportClause(identifier, afterImportPos); - parseExpected(125 /* FromKeyword */); + parseExpected(126 /* FromKeyword */); } importDeclaration.moduleSpecifier = parseModuleSpecifier(); parseSemicolon(); @@ -10530,7 +10867,7 @@ var ts; // NamedImports // ImportedDefaultBinding, NameSpaceImport // ImportedDefaultBinding, NamedImports - var importClause = createNode(211 /* ImportClause */, fullStart); + var importClause = createNode(213 /* ImportClause */, fullStart); if (identifier) { // ImportedDefaultBinding: // ImportedBinding @@ -10540,7 +10877,7 @@ var ts; // parse namespace or named imports if (!importClause.name || parseOptional(23 /* CommaToken */)) { - importClause.namedBindings = token === 35 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(213 /* NamedImports */); + importClause.namedBindings = token === 35 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(215 /* NamedImports */); } return finishNode(importClause); } @@ -10550,8 +10887,8 @@ var ts; : parseEntityName(false); } function parseExternalModuleReference() { - var node = createNode(220 /* ExternalModuleReference */); - parseExpected(119 /* RequireKeyword */); + var node = createNode(222 /* ExternalModuleReference */); + parseExpected(120 /* RequireKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = parseModuleSpecifier(); parseExpected(17 /* CloseParenToken */); @@ -10572,7 +10909,7 @@ var ts; function parseNamespaceImport() { // NameSpaceImport: // * as ImportedBinding - var namespaceImport = createNode(212 /* NamespaceImport */); + var namespaceImport = createNode(214 /* NamespaceImport */); parseExpected(35 /* AsteriskToken */); parseExpected(111 /* AsKeyword */); namespaceImport.name = parseIdentifier(); @@ -10587,14 +10924,14 @@ var ts; // ImportsList: // ImportSpecifier // ImportsList, ImportSpecifier - node.elements = parseBracketedList(20 /* ImportOrExportSpecifiers */, kind === 213 /* NamedImports */ ? parseImportSpecifier : parseExportSpecifier, 14 /* OpenBraceToken */, 15 /* CloseBraceToken */); + node.elements = parseBracketedList(19 /* ImportOrExportSpecifiers */, kind === 215 /* NamedImports */ ? parseImportSpecifier : parseExportSpecifier, 14 /* OpenBraceToken */, 15 /* CloseBraceToken */); return finishNode(node); } function parseExportSpecifier() { - return parseImportOrExportSpecifier(218 /* ExportSpecifier */); + return parseImportOrExportSpecifier(220 /* ExportSpecifier */); } function parseImportSpecifier() { - return parseImportOrExportSpecifier(214 /* ImportSpecifier */); + return parseImportOrExportSpecifier(216 /* ImportSpecifier */); } function parseImportOrExportSpecifier(kind) { var node = createNode(kind); @@ -10619,23 +10956,23 @@ var ts; else { node.name = identifierName; } - if (kind === 214 /* ImportSpecifier */ && checkIdentifierIsKeyword) { + if (kind === 216 /* ImportSpecifier */ && checkIdentifierIsKeyword) { // Report error identifier expected parseErrorAtPosition(checkIdentifierStart, checkIdentifierEnd - checkIdentifierStart, ts.Diagnostics.Identifier_expected); } return finishNode(node); } function parseExportDeclaration(fullStart, decorators, modifiers) { - var node = createNode(216 /* ExportDeclaration */, fullStart); + var node = createNode(218 /* ExportDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); if (parseOptional(35 /* AsteriskToken */)) { - parseExpected(125 /* FromKeyword */); + parseExpected(126 /* FromKeyword */); node.moduleSpecifier = parseModuleSpecifier(); } else { - node.exportClause = parseNamedImportsOrExports(217 /* NamedExports */); - if (parseOptional(125 /* FromKeyword */)) { + node.exportClause = parseNamedImportsOrExports(219 /* NamedExports */); + if (parseOptional(126 /* FromKeyword */)) { node.moduleSpecifier = parseModuleSpecifier(); } } @@ -10643,7 +10980,7 @@ var ts; return finishNode(node); } function parseExportAssignment(fullStart, decorators, modifiers) { - var node = createNode(215 /* ExportAssignment */, fullStart); + var node = createNode(217 /* ExportAssignment */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); if (parseOptional(53 /* EqualsToken */)) { @@ -10711,15 +11048,15 @@ var ts; } sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { return node.flags & 1 /* Export */ - || node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 220 /* ExternalModuleReference */ - || node.kind === 210 /* ImportDeclaration */ - || node.kind === 215 /* ExportAssignment */ - || node.kind === 216 /* ExportDeclaration */ + || node.kind === 211 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 222 /* ExternalModuleReference */ + || node.kind === 212 /* ImportDeclaration */ + || node.kind === 217 /* ExportAssignment */ + || node.kind === 218 /* ExportDeclaration */ ? node : undefined; }); @@ -10727,31 +11064,30 @@ var ts; var ParsingContext; (function (ParsingContext) { ParsingContext[ParsingContext["SourceElements"] = 0] = "SourceElements"; - ParsingContext[ParsingContext["ModuleElements"] = 1] = "ModuleElements"; - ParsingContext[ParsingContext["BlockStatements"] = 2] = "BlockStatements"; - ParsingContext[ParsingContext["SwitchClauses"] = 3] = "SwitchClauses"; - ParsingContext[ParsingContext["SwitchClauseStatements"] = 4] = "SwitchClauseStatements"; - ParsingContext[ParsingContext["TypeMembers"] = 5] = "TypeMembers"; - ParsingContext[ParsingContext["ClassMembers"] = 6] = "ClassMembers"; - ParsingContext[ParsingContext["EnumMembers"] = 7] = "EnumMembers"; - ParsingContext[ParsingContext["HeritageClauseElement"] = 8] = "HeritageClauseElement"; - ParsingContext[ParsingContext["VariableDeclarations"] = 9] = "VariableDeclarations"; - ParsingContext[ParsingContext["ObjectBindingElements"] = 10] = "ObjectBindingElements"; - ParsingContext[ParsingContext["ArrayBindingElements"] = 11] = "ArrayBindingElements"; - ParsingContext[ParsingContext["ArgumentExpressions"] = 12] = "ArgumentExpressions"; - ParsingContext[ParsingContext["ObjectLiteralMembers"] = 13] = "ObjectLiteralMembers"; - ParsingContext[ParsingContext["ArrayLiteralMembers"] = 14] = "ArrayLiteralMembers"; - ParsingContext[ParsingContext["Parameters"] = 15] = "Parameters"; - ParsingContext[ParsingContext["TypeParameters"] = 16] = "TypeParameters"; - ParsingContext[ParsingContext["TypeArguments"] = 17] = "TypeArguments"; - ParsingContext[ParsingContext["TupleElementTypes"] = 18] = "TupleElementTypes"; - ParsingContext[ParsingContext["HeritageClauses"] = 19] = "HeritageClauses"; - ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 20] = "ImportOrExportSpecifiers"; - ParsingContext[ParsingContext["JSDocFunctionParameters"] = 21] = "JSDocFunctionParameters"; - ParsingContext[ParsingContext["JSDocTypeArguments"] = 22] = "JSDocTypeArguments"; - ParsingContext[ParsingContext["JSDocRecordMembers"] = 23] = "JSDocRecordMembers"; - ParsingContext[ParsingContext["JSDocTupleTypes"] = 24] = "JSDocTupleTypes"; - ParsingContext[ParsingContext["Count"] = 25] = "Count"; // Number of parsing contexts + ParsingContext[ParsingContext["BlockStatements"] = 1] = "BlockStatements"; + ParsingContext[ParsingContext["SwitchClauses"] = 2] = "SwitchClauses"; + ParsingContext[ParsingContext["SwitchClauseStatements"] = 3] = "SwitchClauseStatements"; + ParsingContext[ParsingContext["TypeMembers"] = 4] = "TypeMembers"; + ParsingContext[ParsingContext["ClassMembers"] = 5] = "ClassMembers"; + ParsingContext[ParsingContext["EnumMembers"] = 6] = "EnumMembers"; + ParsingContext[ParsingContext["HeritageClauseElement"] = 7] = "HeritageClauseElement"; + ParsingContext[ParsingContext["VariableDeclarations"] = 8] = "VariableDeclarations"; + ParsingContext[ParsingContext["ObjectBindingElements"] = 9] = "ObjectBindingElements"; + ParsingContext[ParsingContext["ArrayBindingElements"] = 10] = "ArrayBindingElements"; + ParsingContext[ParsingContext["ArgumentExpressions"] = 11] = "ArgumentExpressions"; + ParsingContext[ParsingContext["ObjectLiteralMembers"] = 12] = "ObjectLiteralMembers"; + ParsingContext[ParsingContext["ArrayLiteralMembers"] = 13] = "ArrayLiteralMembers"; + ParsingContext[ParsingContext["Parameters"] = 14] = "Parameters"; + ParsingContext[ParsingContext["TypeParameters"] = 15] = "TypeParameters"; + ParsingContext[ParsingContext["TypeArguments"] = 16] = "TypeArguments"; + ParsingContext[ParsingContext["TupleElementTypes"] = 17] = "TupleElementTypes"; + ParsingContext[ParsingContext["HeritageClauses"] = 18] = "HeritageClauses"; + ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 19] = "ImportOrExportSpecifiers"; + ParsingContext[ParsingContext["JSDocFunctionParameters"] = 20] = "JSDocFunctionParameters"; + ParsingContext[ParsingContext["JSDocTypeArguments"] = 21] = "JSDocTypeArguments"; + ParsingContext[ParsingContext["JSDocRecordMembers"] = 22] = "JSDocRecordMembers"; + ParsingContext[ParsingContext["JSDocTupleTypes"] = 23] = "JSDocTupleTypes"; + ParsingContext[ParsingContext["Count"] = 24] = "Count"; // Number of parsing contexts })(ParsingContext || (ParsingContext = {})); var Tristate; (function (Tristate) { @@ -10793,7 +11129,7 @@ var ts; scanner.setText(sourceText, start, length); // Prime the first token for us to start processing. token = nextToken(); - var result = createNode(229 /* JSDocTypeExpression */); + var result = createNode(231 /* JSDocTypeExpression */); parseExpected(14 /* OpenBraceToken */); result.type = parseJSDocTopLevelType(); parseExpected(15 /* CloseBraceToken */); @@ -10804,12 +11140,12 @@ var ts; function parseJSDocTopLevelType() { var type = parseJSDocType(); if (token === 44 /* BarToken */) { - var unionType = createNode(233 /* JSDocUnionType */, type.pos); + var unionType = createNode(235 /* JSDocUnionType */, type.pos); unionType.types = parseJSDocTypeList(type); type = finishNode(unionType); } if (token === 53 /* EqualsToken */) { - var optionalType = createNode(240 /* JSDocOptionalType */, type.pos); + var optionalType = createNode(242 /* JSDocOptionalType */, type.pos); nextToken(); optionalType.type = type; type = finishNode(optionalType); @@ -10820,20 +11156,20 @@ var ts; var type = parseBasicTypeExpression(); while (true) { if (token === 18 /* OpenBracketToken */) { - var arrayType = createNode(232 /* JSDocArrayType */, type.pos); + var arrayType = createNode(234 /* JSDocArrayType */, type.pos); arrayType.elementType = type; nextToken(); parseExpected(19 /* CloseBracketToken */); type = finishNode(arrayType); } else if (token === 50 /* QuestionToken */) { - var nullableType = createNode(235 /* JSDocNullableType */, type.pos); + var nullableType = createNode(237 /* JSDocNullableType */, type.pos); nullableType.type = type; nextToken(); type = finishNode(nullableType); } else if (token === 46 /* ExclamationToken */) { - var nonNullableType = createNode(236 /* JSDocNonNullableType */, type.pos); + var nonNullableType = createNode(238 /* JSDocNonNullableType */, type.pos); nonNullableType.type = type; nextToken(); type = finishNode(nonNullableType); @@ -10867,40 +11203,40 @@ var ts; case 93 /* ThisKeyword */: return parseJSDocThisType(); case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: + case 123 /* StringKeyword */: + case 121 /* NumberKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: case 99 /* VoidKeyword */: return parseTokenNode(); } return parseJSDocTypeReference(); } function parseJSDocThisType() { - var result = createNode(244 /* JSDocThisType */); + var result = createNode(246 /* JSDocThisType */); nextToken(); parseExpected(51 /* ColonToken */); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocConstructorType() { - var result = createNode(243 /* JSDocConstructorType */); + var result = createNode(245 /* JSDocConstructorType */); nextToken(); parseExpected(51 /* ColonToken */); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocVariadicType() { - var result = createNode(242 /* JSDocVariadicType */); + var result = createNode(244 /* JSDocVariadicType */); nextToken(); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocFunctionType() { - var result = createNode(241 /* JSDocFunctionType */); + var result = createNode(243 /* JSDocFunctionType */); nextToken(); parseExpected(16 /* OpenParenToken */); - result.parameters = parseDelimitedList(21 /* JSDocFunctionParameters */, parseJSDocParameter); + result.parameters = parseDelimitedList(20 /* JSDocFunctionParameters */, parseJSDocParameter); checkForTrailingComma(result.parameters); parseExpected(17 /* CloseParenToken */); if (token === 51 /* ColonToken */) { @@ -10910,18 +11246,18 @@ var ts; return finishNode(result); } function parseJSDocParameter() { - var parameter = createNode(130 /* Parameter */); + var parameter = createNode(131 /* Parameter */); parameter.type = parseJSDocType(); return finishNode(parameter); } function parseJSDocOptionalType(type) { - var result = createNode(240 /* JSDocOptionalType */, type.pos); + var result = createNode(242 /* JSDocOptionalType */, type.pos); nextToken(); result.type = type; return finishNode(result); } function parseJSDocTypeReference() { - var result = createNode(239 /* JSDocTypeReference */); + var result = createNode(241 /* JSDocTypeReference */); result.name = parseSimplePropertyName(); while (parseOptional(20 /* DotToken */)) { if (token === 24 /* LessThanToken */) { @@ -10937,7 +11273,7 @@ var ts; function parseTypeArguments() { // Move past the < nextToken(); - var typeArguments = parseDelimitedList(22 /* JSDocTypeArguments */, parseJSDocType); + var typeArguments = parseDelimitedList(21 /* JSDocTypeArguments */, parseJSDocType); checkForTrailingComma(typeArguments); checkForEmptyTypeArgumentList(typeArguments); parseExpected(25 /* GreaterThanToken */); @@ -10951,21 +11287,21 @@ var ts; } } function parseQualifiedName(left) { - var result = createNode(127 /* QualifiedName */, left.pos); + var result = createNode(128 /* QualifiedName */, left.pos); result.left = left; result.right = parseIdentifierName(); return finishNode(result); } function parseJSDocRecordType() { - var result = createNode(237 /* JSDocRecordType */); + var result = createNode(239 /* JSDocRecordType */); nextToken(); - result.members = parseDelimitedList(23 /* JSDocRecordMembers */, parseJSDocRecordMember); + result.members = parseDelimitedList(22 /* JSDocRecordMembers */, parseJSDocRecordMember); checkForTrailingComma(result.members); parseExpected(15 /* CloseBraceToken */); return finishNode(result); } function parseJSDocRecordMember() { - var result = createNode(238 /* JSDocRecordMember */); + var result = createNode(240 /* JSDocRecordMember */); result.name = parseSimplePropertyName(); if (token === 51 /* ColonToken */) { nextToken(); @@ -10974,15 +11310,15 @@ var ts; return finishNode(result); } function parseJSDocNonNullableType() { - var result = createNode(236 /* JSDocNonNullableType */); + var result = createNode(238 /* JSDocNonNullableType */); nextToken(); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocTupleType() { - var result = createNode(234 /* JSDocTupleType */); + var result = createNode(236 /* JSDocTupleType */); nextToken(); - result.types = parseDelimitedList(24 /* JSDocTupleTypes */, parseJSDocType); + result.types = parseDelimitedList(23 /* JSDocTupleTypes */, parseJSDocType); checkForTrailingComma(result.types); parseExpected(19 /* CloseBracketToken */); return finishNode(result); @@ -10994,7 +11330,7 @@ var ts; } } function parseJSDocUnionType() { - var result = createNode(233 /* JSDocUnionType */); + var result = createNode(235 /* JSDocUnionType */); nextToken(); result.types = parseJSDocTypeList(parseJSDocType()); parseExpected(17 /* CloseParenToken */); @@ -11012,7 +11348,7 @@ var ts; return types; } function parseJSDocAllType() { - var result = createNode(230 /* JSDocAllType */); + var result = createNode(232 /* JSDocAllType */); nextToken(); return finishNode(result); } @@ -11035,11 +11371,11 @@ var ts; token === 25 /* GreaterThanToken */ || token === 53 /* EqualsToken */ || token === 44 /* BarToken */) { - var result = createNode(231 /* JSDocUnknownType */, pos); + var result = createNode(233 /* JSDocUnknownType */, pos); return finishNode(result); } else { - var result = createNode(235 /* JSDocNullableType */, pos); + var result = createNode(237 /* JSDocNullableType */, pos); result.type = parseJSDocType(); return finishNode(result); } @@ -11127,7 +11463,7 @@ var ts; if (!tags) { return undefined; } - var result = createNode(245 /* JSDocComment */, start); + var result = createNode(247 /* JSDocComment */, start); result.tags = tags; return finishNode(result, end); } @@ -11165,7 +11501,7 @@ var ts; return undefined; } function handleUnknownTag(atToken, tagName) { - var result = createNode(246 /* JSDocTag */, atToken.pos); + var result = createNode(248 /* JSDocTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; return finishNode(result, pos); @@ -11217,7 +11553,7 @@ var ts; if (!typeExpression) { typeExpression = tryParseTypeExpression(); } - var result = createNode(247 /* JSDocParameterTag */, atToken.pos); + var result = createNode(249 /* JSDocParameterTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.preParameterName = preName; @@ -11227,27 +11563,27 @@ var ts; return finishNode(result, pos); } function handleReturnTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 248 /* JSDocReturnTag */; })) { + if (ts.forEach(tags, function (t) { return t.kind === 250 /* JSDocReturnTag */; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } - var result = createNode(248 /* JSDocReturnTag */, atToken.pos); + var result = createNode(250 /* JSDocReturnTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeExpression = tryParseTypeExpression(); return finishNode(result, pos); } function handleTypeTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 249 /* JSDocTypeTag */; })) { + if (ts.forEach(tags, function (t) { return t.kind === 251 /* JSDocTypeTag */; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } - var result = createNode(249 /* JSDocTypeTag */, atToken.pos); + var result = createNode(251 /* JSDocTypeTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeExpression = tryParseTypeExpression(); return finishNode(result, pos); } function handleTemplateTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 250 /* JSDocTemplateTag */; })) { + if (ts.forEach(tags, function (t) { return t.kind === 252 /* JSDocTemplateTag */; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } var typeParameters = []; @@ -11260,7 +11596,7 @@ var ts; parseErrorAtPosition(startPos, 0, ts.Diagnostics.Identifier_expected); return undefined; } - var typeParameter = createNode(129 /* TypeParameter */, name_7.pos); + var typeParameter = createNode(130 /* TypeParameter */, name_7.pos); typeParameter.name = name_7; finishNode(typeParameter, pos); typeParameters.push(typeParameter); @@ -11271,7 +11607,7 @@ var ts; pos++; } typeParameters.end = pos; - var result = createNode(250 /* JSDocTemplateTag */, atToken.pos); + var result = createNode(252 /* JSDocTemplateTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeParameters = typeParameters; @@ -11857,8 +12193,8 @@ var ts; emptyGenericType.instantiations = {}; var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); - var anySignature = createSignature(undefined, undefined, emptyArray, anyType, 0, false, false); - var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, 0, false, false); + var anySignature = createSignature(undefined, undefined, emptyArray, anyType, undefined, 0, false, false); + var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, undefined, 0, false, false); var globals = {}; var globalESSymbolConstructorSymbol; var globalObjectType; @@ -11909,6 +12245,11 @@ var ts; flags: 2097152 /* ESSymbol */ } }; + var subtypeRelation = {}; + var assignableRelation = {}; + var identityRelation = {}; + initializeTypeChecker(); + return checker; function getEmitResolver(sourceFile) { // Ensure we have all the type information in place for this file so that all the // emitter questions of this resolver will return the right information. @@ -12051,10 +12392,10 @@ var ts; return nodeLinks[nodeId] || (nodeLinks[nodeId] = {}); } function getSourceFile(node) { - return ts.getAncestor(node, 228 /* SourceFile */); + return ts.getAncestor(node, 230 /* SourceFile */); } function isGlobalSourceFile(node) { - return node.kind === 228 /* SourceFile */ && !ts.isExternalModule(node); + return node.kind === 230 /* SourceFile */ && !ts.isExternalModule(node); } function getSymbol(symbols, name, meaning) { if (meaning && ts.hasProperty(symbols, name)) { @@ -12111,40 +12452,54 @@ var ts; } } switch (location.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (!ts.isExternalModule(location)) break; - case 206 /* ModuleDeclaration */: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931 /* ModuleMember */)) { - if (result.flags & meaning || !(result.flags & 8388608 /* Alias */ && getDeclarationOfAliasSymbol(result).kind === 218 /* ExportSpecifier */)) { - break loop; + case 208 /* ModuleDeclaration */: + var moduleExports = getSymbolOfNode(location).exports; + if (location.kind === 230 /* SourceFile */ || + (location.kind === 208 /* ModuleDeclaration */ && location.name.kind === 8 /* StringLiteral */)) { + // It's an external module. Because of module/namespace merging, a module's exports are in scope, + // yet we never want to treat an export specifier as putting a member in scope. Therefore, + // if the name we find is purely an export specifier, it is not actually considered in scope. + // Two things to note about this: + // 1. We have to check this without calling getSymbol. The problem with calling getSymbol + // on an export specifier is that it might find the export specifier itself, and try to + // resolve it as an alias. This will cause the checker to consider the export specifier + // a circular alias reference when it might not be. + // 2. We check === SymbolFlags.Alias in order to check that the symbol is *purely* + // an alias. If we used &, we'd be throwing out symbols that have non alias aspects, + // which is not the desired behavior. + if (ts.hasProperty(moduleExports, name) && + moduleExports[name].flags === 8388608 /* Alias */ && + ts.getDeclarationOfKind(moduleExports[name], 220 /* ExportSpecifier */)) { + break; } - result = undefined; - } - else if (location.kind === 228 /* SourceFile */ || - (location.kind === 206 /* ModuleDeclaration */ && location.name.kind === 8 /* StringLiteral */)) { - result = getSymbolOfNode(location).exports["default"]; + result = moduleExports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + if (result = getSymbol(moduleExports, name, meaning & 8914931 /* ModuleMember */)) { + break loop; + } break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8 /* EnumMember */)) { break loop; } break; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: // TypeScript 1.0 spec (April 2014): 8.4.1 // Initializer expressions for instance member variables are evaluated in the scope // of the class constructor body but are not permitted to reference parameters or // local variables of the constructor. This effectively means that entities from outer scopes // by the same name as a constructor parameter or local variable are inaccessible // in initializer expressions for instance member variables. - if (location.parent.kind === 202 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) { + if (location.parent.kind === 204 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455 /* Value */)) { @@ -12154,8 +12509,8 @@ var ts; } } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056 /* Type */)) { if (lastLocation && lastLocation.flags & 128 /* Static */) { // TypeScript 1.0 spec (April 2014): 3.4.1 @@ -12175,9 +12530,9 @@ var ts; // [foo()]() { } // <-- Reference to T from class's own computed property // } // - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: grandparent = location.parent.parent; - if (grandparent.kind === 202 /* ClassDeclaration */ || grandparent.kind === 203 /* InterfaceDeclaration */) { + if (grandparent.kind === 204 /* ClassDeclaration */ || grandparent.kind === 205 /* InterfaceDeclaration */) { // A reference to this grandparent's type parameters would be an error if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056 /* Type */)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); @@ -12185,19 +12540,19 @@ var ts; } } break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: if (meaning & 3 /* Variable */ && name === "arguments") { result = argumentsSymbol; break loop; } break; - case 163 /* FunctionExpression */: + case 165 /* FunctionExpression */: if (meaning & 3 /* Variable */ && name === "arguments") { result = argumentsSymbol; break loop; @@ -12210,7 +12565,7 @@ var ts; } } break; - case 175 /* ClassExpression */: + case 177 /* ClassExpression */: if (meaning & 32 /* Class */) { var className = location.name; if (className && name === className.text) { @@ -12219,7 +12574,7 @@ var ts; } } break; - case 131 /* Decorator */: + case 132 /* Decorator */: // Decorators are resolved at the class declaration. Resolving at the parameter // or member would result in looking up locals in the method. // @@ -12228,7 +12583,7 @@ var ts; // method(@y x, y) {} // <-- decorator y should be resolved at the class declaration, not the parameter. // } // - if (location.parent && location.parent.kind === 130 /* Parameter */) { + if (location.parent && location.parent.kind === 131 /* Parameter */) { location = location.parent; } // @@ -12284,16 +12639,16 @@ var ts; // for (let x in x) // for (let x of x) // climb up to the variable declaration skipping binding patterns - var variableDeclaration = ts.getAncestor(declaration, 199 /* VariableDeclaration */); + var variableDeclaration = ts.getAncestor(declaration, 201 /* VariableDeclaration */); var container = ts.getEnclosingBlockScopeContainer(variableDeclaration); - if (variableDeclaration.parent.parent.kind === 181 /* VariableStatement */ || - variableDeclaration.parent.parent.kind === 187 /* ForStatement */) { + if (variableDeclaration.parent.parent.kind === 183 /* VariableStatement */ || + variableDeclaration.parent.parent.kind === 189 /* ForStatement */) { // variable statement/for statement case, // use site should not be inside variable declaration (initializer of declaration or binding element) isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, variableDeclaration, container); } - else if (variableDeclaration.parent.parent.kind === 189 /* ForOfStatement */ || - variableDeclaration.parent.parent.kind === 188 /* ForInStatement */) { + else if (variableDeclaration.parent.parent.kind === 191 /* ForOfStatement */ || + variableDeclaration.parent.parent.kind === 190 /* ForInStatement */) { // ForIn/ForOf case - use site should not be used in expression part var expression = variableDeclaration.parent.parent.expression; isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, expression, container); @@ -12320,10 +12675,10 @@ var ts; } function getAnyImportSyntax(node) { if (ts.isAliasSymbolDeclaration(node)) { - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 211 /* ImportEqualsDeclaration */) { return node; } - while (node && node.kind !== 210 /* ImportDeclaration */) { + while (node && node.kind !== 212 /* ImportDeclaration */) { node = node.parent; } return node; @@ -12333,7 +12688,7 @@ var ts; return ts.forEach(symbol.declarations, function (d) { return ts.isAliasSymbolDeclaration(d) ? d : undefined; }); } function getTargetOfImportEqualsDeclaration(node) { - if (node.moduleReference.kind === 220 /* ExternalModuleReference */) { + if (node.moduleReference.kind === 222 /* ExternalModuleReference */) { return resolveExternalModuleSymbol(resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node))); } return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); @@ -12440,17 +12795,17 @@ var ts; } function getTargetOfAliasDeclaration(node) { switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return getTargetOfImportEqualsDeclaration(node); - case 211 /* ImportClause */: + case 213 /* ImportClause */: return getTargetOfImportClause(node); - case 212 /* NamespaceImport */: + case 214 /* NamespaceImport */: return getTargetOfNamespaceImport(node); - case 214 /* ImportSpecifier */: + case 216 /* ImportSpecifier */: return getTargetOfImportSpecifier(node); - case 218 /* ExportSpecifier */: + case 220 /* ExportSpecifier */: return getTargetOfExportSpecifier(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return getTargetOfExportAssignment(node); } } @@ -12495,11 +12850,11 @@ var ts; if (!links.referenced) { links.referenced = true; var node = getDeclarationOfAliasSymbol(symbol); - if (node.kind === 215 /* ExportAssignment */) { + if (node.kind === 217 /* ExportAssignment */) { // export default checkExpressionCached(node.expression); } - else if (node.kind === 218 /* ExportSpecifier */) { + else if (node.kind === 220 /* ExportSpecifier */) { // export { } or export { as foo } checkExpressionCached(node.propertyName || node.name); } @@ -12512,7 +12867,7 @@ var ts; // This function is only for imports with entity names function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { if (!importDeclaration) { - importDeclaration = ts.getAncestor(entityName, 209 /* ImportEqualsDeclaration */); + importDeclaration = ts.getAncestor(entityName, 211 /* ImportEqualsDeclaration */); ts.Debug.assert(importDeclaration !== undefined); } // There are three things we might try to look for. In the following examples, @@ -12525,13 +12880,13 @@ var ts; entityName = entityName.parent; } // Check for case 1 and 3 in the above example - if (entityName.kind === 65 /* Identifier */ || entityName.parent.kind === 127 /* QualifiedName */) { + if (entityName.kind === 65 /* Identifier */ || entityName.parent.kind === 128 /* QualifiedName */) { return resolveEntityName(entityName, 1536 /* Namespace */); } else { // Case 2 in above example // entityName.kind could be a QualifiedName or a Missing identifier - ts.Debug.assert(entityName.parent.kind === 209 /* ImportEqualsDeclaration */); + ts.Debug.assert(entityName.parent.kind === 211 /* ImportEqualsDeclaration */); return resolveEntityName(entityName, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */); } } @@ -12551,9 +12906,9 @@ var ts; return undefined; } } - else if (name.kind === 127 /* QualifiedName */ || name.kind === 156 /* PropertyAccessExpression */) { - var left = name.kind === 127 /* QualifiedName */ ? name.left : name.expression; - var right = name.kind === 127 /* QualifiedName */ ? name.right : name.name; + else if (name.kind === 128 /* QualifiedName */ || name.kind === 158 /* PropertyAccessExpression */) { + var left = name.kind === 128 /* QualifiedName */ ? name.left : name.expression; + var right = name.kind === 128 /* QualifiedName */ ? name.right : name.name; var namespace = resolveEntityName(left, 1536 /* Namespace */); if (!namespace || namespace === unknownSymbol || ts.nodeIsMissing(right)) { return undefined; @@ -12714,7 +13069,7 @@ var ts; var members = node.members; for (var _i = 0; _i < members.length; _i++) { var member = members[_i]; - if (member.kind === 136 /* Constructor */ && ts.nodeIsPresent(member.body)) { + if (member.kind === 137 /* Constructor */ && ts.nodeIsPresent(member.body)) { return member; } } @@ -12784,17 +13139,17 @@ var ts; } } switch (location_1.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (!ts.isExternalModule(location_1)) { break; } - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: if (result = callback(getSymbolOfNode(location_1).exports)) { return result; } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: if (result = callback(getSymbolOfNode(location_1).members)) { return result; } @@ -12943,8 +13298,8 @@ var ts; } } function hasExternalModuleSymbol(declaration) { - return (declaration.kind === 206 /* ModuleDeclaration */ && declaration.name.kind === 8 /* StringLiteral */) || - (declaration.kind === 228 /* SourceFile */ && ts.isExternalModule(declaration)); + return (declaration.kind === 208 /* ModuleDeclaration */ && declaration.name.kind === 8 /* StringLiteral */) || + (declaration.kind === 230 /* SourceFile */ && ts.isExternalModule(declaration)); } function hasVisibleDeclarations(symbol) { var aliasesToMakeVisible; @@ -12980,12 +13335,12 @@ var ts; function isEntityNameVisible(entityName, enclosingDeclaration) { // get symbol of the first identifier of the entityName var meaning; - if (entityName.parent.kind === 145 /* TypeQuery */) { + if (entityName.parent.kind === 147 /* TypeQuery */) { // Typeof value meaning = 107455 /* Value */ | 1048576 /* ExportValue */; } - else if (entityName.kind === 127 /* QualifiedName */ || entityName.kind === 156 /* PropertyAccessExpression */ || - entityName.parent.kind === 209 /* ImportEqualsDeclaration */) { + else if (entityName.kind === 128 /* QualifiedName */ || entityName.kind === 158 /* PropertyAccessExpression */ || + entityName.parent.kind === 211 /* ImportEqualsDeclaration */) { // Left identifier from type reference or TypeAlias // Entity name of the import declaration meaning = 1536 /* Namespace */; @@ -13019,6 +13374,13 @@ var ts; ts.releaseStringWriter(writer); return result; } + function signatureToString(signature, enclosingDeclaration, flags) { + var writer = ts.getSingleLineStringWriter(); + getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); + var result = writer.string(); + ts.releaseStringWriter(writer); + return result; + } function typeToString(type, enclosingDeclaration, flags) { var writer = ts.getSingleLineStringWriter(); getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); @@ -13033,10 +13395,10 @@ var ts; function getTypeAliasForTypeLiteral(type) { if (type.symbol && type.symbol.flags & 2048 /* TypeLiteral */) { var node = type.symbol.declarations[0].parent; - while (node.kind === 150 /* ParenthesizedType */) { + while (node.kind === 152 /* ParenthesizedType */) { node = node.parent; } - if (node.kind === 204 /* TypeAliasDeclaration */) { + if (node.kind === 206 /* TypeAliasDeclaration */) { return getSymbolOfNode(node); } } @@ -13286,7 +13648,7 @@ var ts; var isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) && (symbol.parent || ts.forEach(symbol.declarations, function (declaration) { - return declaration.parent.kind === 228 /* SourceFile */ || declaration.parent.kind === 207 /* ModuleBlock */; + return declaration.parent.kind === 230 /* SourceFile */ || declaration.parent.kind === 209 /* ModuleBlock */; })); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { // typeof is allowed only for static/non local functions @@ -13364,7 +13726,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 0 /* String */, "x")); writePunctuation(writer, 51 /* ColonToken */); writeSpace(writer); - writeKeyword(writer, 122 /* StringKeyword */); + writeKeyword(writer, 123 /* StringKeyword */); writePunctuation(writer, 19 /* CloseBracketToken */); writePunctuation(writer, 51 /* ColonToken */); writeSpace(writer); @@ -13378,7 +13740,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 1 /* Number */, "x")); writePunctuation(writer, 51 /* ColonToken */); writeSpace(writer); - writeKeyword(writer, 120 /* NumberKeyword */); + writeKeyword(writer, 121 /* NumberKeyword */); writePunctuation(writer, 19 /* CloseBracketToken */); writePunctuation(writer, 51 /* ColonToken */); writeSpace(writer); @@ -13421,7 +13783,7 @@ var ts; function buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaraiton, flags) { var targetSymbol = getTargetSymbol(symbol); if (targetSymbol.flags & 32 /* Class */ || targetSymbol.flags & 64 /* Interface */) { - buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags); + buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), writer, enclosingDeclaraiton, flags); } } function buildTypeParameterDisplay(tp, writer, enclosingDeclaration, flags, symbolStack) { @@ -13525,12 +13887,12 @@ var ts; function isDeclarationVisible(node) { function getContainingExternalModule(node) { for (; node; node = node.parent) { - if (node.kind === 206 /* ModuleDeclaration */) { + if (node.kind === 208 /* ModuleDeclaration */) { if (node.name.kind === 8 /* StringLiteral */) { return node; } } - else if (node.kind === 228 /* SourceFile */) { + else if (node.kind === 230 /* SourceFile */) { return ts.isExternalModule(node) ? node : undefined; } } @@ -13579,69 +13941,69 @@ var ts; } function determineIfDeclarationIsVisible() { switch (node.kind) { - case 153 /* BindingElement */: + case 155 /* BindingElement */: return isDeclarationVisible(node.parent.parent); - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: if (ts.isBindingPattern(node.name) && !node.name.elements.length) { // If the binding pattern is empty, this variable declaration is not visible return false; } // Otherwise fall through - case 206 /* ModuleDeclaration */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 201 /* FunctionDeclaration */: - case 205 /* EnumDeclaration */: - case 209 /* ImportEqualsDeclaration */: + case 208 /* ModuleDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 203 /* FunctionDeclaration */: + case 207 /* EnumDeclaration */: + case 211 /* ImportEqualsDeclaration */: var parent_4 = getDeclarationContainer(node); // If the node is not exported or it is not ambient module element (except import declaration) if (!(ts.getCombinedNodeFlags(node) & 1 /* Export */) && - !(node.kind !== 209 /* ImportEqualsDeclaration */ && parent_4.kind !== 228 /* SourceFile */ && ts.isInAmbientContext(parent_4))) { + !(node.kind !== 211 /* ImportEqualsDeclaration */ && parent_4.kind !== 230 /* SourceFile */ && ts.isInAmbientContext(parent_4))) { return isGlobalSourceFile(parent_4); } // Exported members/ambient module elements (exception import declaration) are visible if parent is visible return isDeclarationVisible(parent_4); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (node.flags & (32 /* Private */ | 64 /* Protected */)) { // Private/protected properties/methods are not visible return false; } // Public properties/methods are visible if its parents are visible, so let it fall into next case statement - case 136 /* Constructor */: - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 141 /* IndexSignature */: - case 130 /* Parameter */: - case 207 /* ModuleBlock */: - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 146 /* TypeLiteral */: - case 142 /* TypeReference */: - case 147 /* ArrayType */: - case 148 /* TupleType */: - case 149 /* UnionType */: - case 150 /* ParenthesizedType */: + case 137 /* Constructor */: + case 141 /* ConstructSignature */: + case 140 /* CallSignature */: + case 142 /* IndexSignature */: + case 131 /* Parameter */: + case 209 /* ModuleBlock */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 148 /* TypeLiteral */: + case 144 /* TypeReference */: + case 149 /* ArrayType */: + case 150 /* TupleType */: + case 151 /* UnionType */: + case 152 /* ParenthesizedType */: return isDeclarationVisible(node.parent); // Default binding, import specifier and namespace import is visible // only on demand so by default it is not visible - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: + case 213 /* ImportClause */: + case 214 /* NamespaceImport */: + case 216 /* ImportSpecifier */: return false; // Type parameters are always visible - case 129 /* TypeParameter */: + case 130 /* TypeParameter */: // Source file is always visible - case 228 /* SourceFile */: + case 230 /* SourceFile */: return true; // Export assignements do not create name bindings outside the module - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return false; default: ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); @@ -13657,10 +14019,10 @@ var ts; } function collectLinkedAliases(node) { var exportSymbol; - if (node.parent && node.parent.kind === 215 /* ExportAssignment */) { + if (node.parent && node.parent.kind === 217 /* ExportAssignment */) { exportSymbol = resolveName(node.parent, node.text, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */, ts.Diagnostics.Cannot_find_name_0, node); } - else if (node.parent.kind === 218 /* ExportSpecifier */) { + else if (node.parent.kind === 220 /* ExportSpecifier */) { exportSymbol = getTargetOfExportSpecifier(node.parent); } var result = []; @@ -13718,7 +14080,7 @@ var ts; node = ts.getRootDeclaration(node); // Parent chain: // VaribleDeclaration -> VariableDeclarationList -> VariableStatement -> 'Declaration Container' - return node.kind === 199 /* VariableDeclaration */ ? node.parent.parent.parent : node.parent; + return node.kind === 201 /* VariableDeclaration */ ? node.parent.parent.parent : node.parent; } function getTypeOfPrototypeProperty(prototype) { // TypeScript 1.0 spec (April 2014): 8.4 @@ -13754,7 +14116,7 @@ var ts; return parentType; } var type; - if (pattern.kind === 151 /* ObjectBindingPattern */) { + if (pattern.kind === 153 /* ObjectBindingPattern */) { // Use explicitly specified property name ({ p: xxx } form), or otherwise the implied name ({ p } form) var name_9 = declaration.propertyName || declaration.name; // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature, @@ -13801,10 +14163,10 @@ var ts; // Return the inferred type for a variable, parameter, or property declaration function getTypeForVariableLikeDeclaration(declaration) { // A variable declared in a for..in statement is always of type any - if (declaration.parent.parent.kind === 188 /* ForInStatement */) { + if (declaration.parent.parent.kind === 190 /* ForInStatement */) { return anyType; } - if (declaration.parent.parent.kind === 189 /* ForOfStatement */) { + if (declaration.parent.parent.kind === 191 /* ForOfStatement */) { // checkRightHandSideOfForOf will return undefined if the for-of expression type was // missing properties/signatures required to get its iteratedType (like // [Symbol.iterator] or next). This may be because we accessed properties from anyType, @@ -13818,11 +14180,11 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130 /* Parameter */) { + if (declaration.kind === 131 /* Parameter */) { var func = declaration.parent; // For a parameter of a set accessor, use the type of the get accessor if one is present - if (func.kind === 138 /* SetAccessor */ && !ts.hasDynamicName(func)) { - var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 137 /* GetAccessor */); + if (func.kind === 139 /* SetAccessor */ && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 138 /* GetAccessor */); if (getter) { return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); } @@ -13838,7 +14200,7 @@ var ts; return checkExpressionCached(declaration.initializer); } // If it is a short-hand property assignment, use the type of the identifier - if (declaration.kind === 226 /* ShorthandPropertyAssignment */) { + if (declaration.kind === 228 /* ShorthandPropertyAssignment */) { return checkIdentifier(declaration.name); } // No type specified and nothing can be inferred @@ -13873,7 +14235,7 @@ var ts; var hasSpreadElement = false; var elementTypes = []; ts.forEach(pattern.elements, function (e) { - elementTypes.push(e.kind === 176 /* OmittedExpression */ || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + elementTypes.push(e.kind === 178 /* OmittedExpression */ || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); if (e.dotDotDotToken) { hasSpreadElement = true; } @@ -13896,7 +14258,7 @@ var ts; // parameter with no type annotation or initializer, the type implied by the binding pattern becomes the type of // the parameter. function getTypeFromBindingPattern(pattern) { - return pattern.kind === 151 /* ObjectBindingPattern */ + return pattern.kind === 153 /* ObjectBindingPattern */ ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); } @@ -13918,7 +14280,7 @@ var ts; // During a normal type check we'll never get to here with a property assignment (the check of the containing // object literal uses a different path). We exclude widening only so that language services and type verification // tools see the actual type. - return declaration.kind !== 225 /* PropertyAssignment */ ? getWidenedType(type) : type; + return declaration.kind !== 227 /* PropertyAssignment */ ? getWidenedType(type) : type; } // If no type was specified and nothing could be inferred, and if the declaration specifies a binding pattern, use // the type implied by the binding pattern @@ -13930,7 +14292,7 @@ var ts; // Report implicit any errors unless this is a private property within an ambient declaration if (reportErrors && compilerOptions.noImplicitAny) { var root = ts.getRootDeclaration(declaration); - if (!isPrivateWithinAmbient(root) && !(root.kind === 130 /* Parameter */ && isPrivateWithinAmbient(root.parent))) { + if (!isPrivateWithinAmbient(root) && !(root.kind === 131 /* Parameter */ && isPrivateWithinAmbient(root.parent))) { reportImplicitAnyError(declaration, type); } } @@ -13945,11 +14307,11 @@ var ts; } // Handle catch clause variables var declaration = symbol.valueDeclaration; - if (declaration.parent.kind === 224 /* CatchClause */) { + if (declaration.parent.kind === 226 /* CatchClause */) { return links.type = anyType; } // Handle export default expressions - if (declaration.kind === 215 /* ExportAssignment */) { + if (declaration.kind === 217 /* ExportAssignment */) { return links.type = checkExpression(declaration.expression); } // Handle variable, parameter or property @@ -13980,7 +14342,7 @@ var ts; } function getAnnotatedAccessorType(accessor) { if (accessor) { - if (accessor.kind === 137 /* GetAccessor */) { + if (accessor.kind === 138 /* GetAccessor */) { return accessor.type && getTypeFromTypeNode(accessor.type); } else { @@ -13996,8 +14358,8 @@ var ts; if (!pushTypeResolution(symbol)) { return unknownType; } - var getter = ts.getDeclarationOfKind(symbol, 137 /* GetAccessor */); - var setter = ts.getDeclarationOfKind(symbol, 138 /* SetAccessor */); + var getter = ts.getDeclarationOfKind(symbol, 138 /* GetAccessor */); + var setter = ts.getDeclarationOfKind(symbol, 139 /* SetAccessor */); var type; // First try to see if the user specified a return type on the get-accessor. var getterReturnType = getAnnotatedAccessorType(getter); @@ -14026,7 +14388,7 @@ var ts; if (!popTypeResolution()) { type = anyType; if (compilerOptions.noImplicitAny) { - var getter_1 = ts.getDeclarationOfKind(symbol, 137 /* GetAccessor */); + var getter_1 = ts.getDeclarationOfKind(symbol, 138 /* GetAccessor */); error(getter_1, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); } } @@ -14126,9 +14488,9 @@ var ts; if (!node) { return typeParameters; } - if (node.kind === 202 /* ClassDeclaration */ || node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */ || node.kind === 135 /* MethodDeclaration */ || - node.kind === 164 /* ArrowFunction */) { + if (node.kind === 204 /* ClassDeclaration */ || node.kind === 203 /* FunctionDeclaration */ || + node.kind === 165 /* FunctionExpression */ || node.kind === 136 /* MethodDeclaration */ || + node.kind === 166 /* ArrowFunction */) { var declarations = node.typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); @@ -14138,15 +14500,16 @@ var ts; } // The outer type parameters are those defined by enclosing generic classes, methods, or functions. function getOuterTypeParametersOfClassOrInterface(symbol) { - var kind = symbol.flags & 32 /* Class */ ? 202 /* ClassDeclaration */ : 203 /* InterfaceDeclaration */; + var kind = symbol.flags & 32 /* Class */ ? 204 /* ClassDeclaration */ : 205 /* InterfaceDeclaration */; return appendOuterTypeParameters(undefined, ts.getDeclarationOfKind(symbol, kind)); } - // The local type parameters are the combined set of type parameters from all declarations of the class or interface. - function getLocalTypeParametersOfClassOrInterface(symbol) { + // The local type parameters are the combined set of type parameters from all declarations of the class, + // interface, or type alias. + function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) { var result; for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { var node = _a[_i]; - if (node.kind === 203 /* InterfaceDeclaration */ || node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 205 /* InterfaceDeclaration */ || node.kind === 204 /* ClassDeclaration */ || node.kind === 206 /* TypeAliasDeclaration */) { var declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -14158,56 +14521,122 @@ var ts; // The full set of type parameters for a generic class or interface type consists of its outer type parameters plus // its locally declared type parameters. function getTypeParametersOfClassOrInterface(symbol) { - return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterface(symbol)); + return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol)); + } + function isConstructorType(type) { + return type.flags & 48128 /* ObjectType */ && getSignaturesOfType(type, 1 /* Construct */).length > 0; + } + function getBaseTypeNodeOfClass(type) { + return ts.getClassExtendsHeritageClauseElement(type.symbol.valueDeclaration); + } + function getConstructorsForTypeArguments(type, typeArgumentNodes) { + var typeArgCount = typeArgumentNodes ? typeArgumentNodes.length : 0; + return ts.filter(getSignaturesOfType(type, 1 /* Construct */), function (sig) { return (sig.typeParameters ? sig.typeParameters.length : 0) === typeArgCount; }); + } + function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes) { + var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes); + if (typeArgumentNodes) { + var typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode); + signatures = ts.map(signatures, function (sig) { return getSignatureInstantiation(sig, typeArguments); }); + } + return signatures; + } + // The base constructor of a class can resolve to + // undefinedType if the class has no extends clause, + // unknownType if an error occurred during resolution of the extends expression, + // nullType if the extends expression is the null value, or + // an object type with at least one construct signature. + function getBaseConstructorTypeOfClass(type) { + if (!type.resolvedBaseConstructorType) { + var baseTypeNode = getBaseTypeNodeOfClass(type); + if (!baseTypeNode) { + return type.resolvedBaseConstructorType = undefinedType; + } + if (!pushTypeResolution(type)) { + return unknownType; + } + var baseConstructorType = checkExpression(baseTypeNode.expression); + if (baseConstructorType.flags & 48128 /* ObjectType */) { + // Resolving the members of a class requires us to resolve the base class of that class. + // We force resolution here such that we catch circularities now. + resolveObjectOrUnionTypeMembers(baseConstructorType); + } + if (!popTypeResolution()) { + error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol)); + return type.resolvedBaseConstructorType = unknownType; + } + if (baseConstructorType !== unknownType && baseConstructorType !== nullType && !isConstructorType(baseConstructorType)) { + error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType)); + return type.resolvedBaseConstructorType = unknownType; + } + type.resolvedBaseConstructorType = baseConstructorType; + } + return type.resolvedBaseConstructorType; } function getBaseTypes(type) { - var typeWithBaseTypes = type; - if (!typeWithBaseTypes.baseTypes) { + if (!type.resolvedBaseTypes) { if (type.symbol.flags & 32 /* Class */) { - resolveBaseTypesOfClass(typeWithBaseTypes); + resolveBaseTypesOfClass(type); } else if (type.symbol.flags & 64 /* Interface */) { - resolveBaseTypesOfInterface(typeWithBaseTypes); + resolveBaseTypesOfInterface(type); } else { ts.Debug.fail("type must be class or interface"); } } - return typeWithBaseTypes.baseTypes; + return type.resolvedBaseTypes; } function resolveBaseTypesOfClass(type) { - type.baseTypes = []; - var declaration = ts.getDeclarationOfKind(type.symbol, 202 /* ClassDeclaration */); - var baseTypeNode = ts.getClassExtendsHeritageClauseElement(declaration); - if (baseTypeNode) { - var baseType = getTypeFromTypeNode(baseTypeNode); - if (baseType !== unknownType) { - if (getTargetType(baseType).flags & 1024 /* Class */) { - if (type !== baseType && !hasBaseType(baseType, type)) { - type.baseTypes.push(baseType); - } - else { - error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */)); - } - } - else { - error(baseTypeNode, ts.Diagnostics.A_class_may_only_extend_another_class); - } - } + type.resolvedBaseTypes = emptyArray; + var baseContructorType = getBaseConstructorTypeOfClass(type); + if (!(baseContructorType.flags & 48128 /* ObjectType */)) { + return; } + var baseTypeNode = getBaseTypeNodeOfClass(type); + var baseType; + if (baseContructorType.symbol && baseContructorType.symbol.flags & 32 /* Class */) { + // When base constructor type is a class we know that the constructors all have the same type parameters as the + // class and all return the instance type of the class. There is no need for further checks and we can apply the + // type arguments in the same manner as a type reference to get the same error reporting experience. + baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseContructorType.symbol); + } + else { + // The class derives from a "class-like" constructor function, check that we have at least one construct signature + // with a matching number of type parameters and use the return type of the first instantiated signature. Elsewhere + // we check that all instantiated signatures return the same type. + var constructors = getInstantiatedConstructorsForTypeArguments(baseContructorType, baseTypeNode.typeArguments); + if (!constructors.length) { + error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments); + return; + } + baseType = getReturnTypeOfSignature(constructors[0]); + } + if (baseType === unknownType) { + return; + } + if (!(getTargetType(baseType).flags & (1024 /* Class */ | 2048 /* Interface */))) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructor_return_type_0_is_not_a_class_or_interface_type, typeToString(baseType)); + return; + } + if (type === baseType || hasBaseType(baseType, type)) { + error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */)); + return; + } + type.resolvedBaseTypes = [baseType]; } function resolveBaseTypesOfInterface(type) { - type.baseTypes = []; + type.resolvedBaseTypes = []; for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { var declaration = _a[_i]; - if (declaration.kind === 203 /* InterfaceDeclaration */ && ts.getInterfaceBaseTypeNodes(declaration)) { + if (declaration.kind === 205 /* InterfaceDeclaration */ && ts.getInterfaceBaseTypeNodes(declaration)) { for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) { var node = _c[_b]; var baseType = getTypeFromTypeNode(node); if (baseType !== unknownType) { if (getTargetType(baseType).flags & (1024 /* Class */ | 2048 /* Interface */)) { if (type !== baseType && !hasBaseType(baseType, type)) { - type.baseTypes.push(baseType); + type.resolvedBaseTypes.push(baseType); } else { error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */)); @@ -14227,7 +14656,7 @@ var ts; var kind = symbol.flags & 32 /* Class */ ? 1024 /* Class */ : 2048 /* Interface */; var type = links.declaredType = createObjectType(kind, symbol); var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol); - var localTypeParameters = getLocalTypeParametersOfClassOrInterface(symbol); + var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); if (outerTypeParameters || localTypeParameters) { type.flags |= 4096 /* Reference */; type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters); @@ -14249,9 +14678,18 @@ var ts; if (!pushTypeResolution(links)) { return unknownType; } - var declaration = ts.getDeclarationOfKind(symbol, 204 /* TypeAliasDeclaration */); + var declaration = ts.getDeclarationOfKind(symbol, 206 /* TypeAliasDeclaration */); var type = getTypeFromTypeNode(declaration.type); - if (!popTypeResolution()) { + if (popTypeResolution()) { + links.typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (links.typeParameters) { + // Initialize the instantiation cache for generic type aliases. The declared type corresponds to + // an instantiation of the type alias with the type parameters supplied as type arguments. + links.instantiations = {}; + links.instantiations[getTypeListId(links.typeParameters)] = type; + } + } + else { type = unknownType; error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } @@ -14273,7 +14711,7 @@ var ts; if (!links.declaredType) { var type = createType(512 /* TypeParameter */); type.symbol = symbol; - if (!ts.getDeclarationOfKind(symbol, 129 /* TypeParameter */).constraint) { + if (!ts.getDeclarationOfKind(symbol, 130 /* TypeParameter */).constraint) { type.constraint = noConstraintType; } links.declaredType = type; @@ -14388,34 +14826,42 @@ var ts; }); setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } - function createSignature(declaration, typeParameters, parameters, resolvedReturnType, minArgumentCount, hasRestParameter, hasStringLiterals) { + function createSignature(declaration, typeParameters, parameters, resolvedReturnType, typePredicate, minArgumentCount, hasRestParameter, hasStringLiterals) { var sig = new Signature(checker); sig.declaration = declaration; sig.typeParameters = typeParameters; sig.parameters = parameters; sig.resolvedReturnType = resolvedReturnType; + sig.typePredicate = typePredicate; sig.minArgumentCount = minArgumentCount; sig.hasRestParameter = hasRestParameter; sig.hasStringLiterals = hasStringLiterals; return sig; } function cloneSignature(sig) { - return createSignature(sig.declaration, sig.typeParameters, sig.parameters, sig.resolvedReturnType, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); + return createSignature(sig.declaration, sig.typeParameters, sig.parameters, sig.resolvedReturnType, sig.typePredicate, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); } function getDefaultConstructSignatures(classType) { - var baseTypes = getBaseTypes(classType); - if (baseTypes.length) { - var baseType = baseTypes[0]; - var baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), 1 /* Construct */); - return ts.map(baseSignatures, function (baseSignature) { - var signature = baseType.flags & 4096 /* Reference */ ? - getSignatureInstantiation(baseSignature, baseType.typeArguments) : cloneSignature(baseSignature); - signature.typeParameters = classType.localTypeParameters; - signature.resolvedReturnType = classType; - return signature; - }); + if (!getBaseTypes(classType).length) { + return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)]; } - return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, 0, false, false)]; + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + var baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */); + var baseTypeNode = getBaseTypeNodeOfClass(classType); + var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode); + var typeArgCount = typeArguments ? typeArguments.length : 0; + var result = []; + for (var _i = 0; _i < baseSignatures.length; _i++) { + var baseSig = baseSignatures[_i]; + var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0; + if (typeParamCount === typeArgCount) { + var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig); + sig.typeParameters = classType.localTypeParameters; + sig.resolvedReturnType = classType; + result.push(sig); + } + } + return result; } function createTupleTypeMemberSymbols(memberTypes) { var members = {}; @@ -14521,10 +14967,10 @@ var ts; if (!constructSignatures.length) { constructSignatures = getDefaultConstructSignatures(classType); } - var baseTypes = getBaseTypes(classType); - if (baseTypes.length) { + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + if (baseConstructorType.flags & 48128 /* ObjectType */) { members = createSymbolTable(getNamedMembers(members)); - addInheritedMembers(members, getPropertiesOfObjectType(getTypeOfSymbol(baseTypes[0].symbol))); + addInheritedMembers(members, getPropertiesOfObjectType(baseConstructorType)); } } stringIndexType = undefined; @@ -14745,7 +15191,7 @@ var ts; function getSignatureFromDeclaration(declaration) { var links = getNodeLinks(declaration); if (!links.resolvedSignature) { - var classType = declaration.kind === 136 /* Constructor */ ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; + var classType = declaration.kind === 137 /* Constructor */ ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; var typeParameters = classType ? classType.localTypeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; var parameters = []; @@ -14767,24 +15213,33 @@ var ts; minArgumentCount = declaration.parameters.length; } var returnType; + var typePredicate; if (classType) { returnType = classType; } else if (declaration.type) { returnType = getTypeFromTypeNode(declaration.type); + if (declaration.type.kind === 143 /* TypePredicate */) { + var typePredicateNode = declaration.type; + typePredicate = { + parameterName: typePredicateNode.parameterName ? typePredicateNode.parameterName.text : undefined, + parameterIndex: typePredicateNode.parameterName ? getTypePredicateParameterIndex(declaration.parameters, typePredicateNode.parameterName) : undefined, + type: getTypeFromTypeNode(typePredicateNode.type) + }; + } } else { // TypeScript 1.0 spec (April 2014): // If only one accessor includes a type annotation, the other behaves as if it had the same type annotation. - if (declaration.kind === 137 /* GetAccessor */ && !ts.hasDynamicName(declaration)) { - var setter = ts.getDeclarationOfKind(declaration.symbol, 138 /* SetAccessor */); + if (declaration.kind === 138 /* GetAccessor */ && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 139 /* SetAccessor */); returnType = getAnnotatedAccessorType(setter); } if (!returnType && ts.nodeIsMissing(declaration.body)) { returnType = anyType; } } - links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals); + links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, typePredicate, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals); } return links.resolvedSignature; } @@ -14795,19 +15250,19 @@ var ts; for (var i = 0, len = symbol.declarations.length; i < len; i++) { var node = symbol.declarations[i]; switch (node.kind) { - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: // Don't include signature if node is the implementation of an overloaded function. A node is considered // an implementation node if it has a body and the previous node is of the same kind and immediately // precedes the implementation node (i.e. has the same parent and ends where the implementation starts). @@ -14884,7 +15339,7 @@ var ts; // object type literal or interface (using the new keyword). Each way of declaring a constructor // will result in a different declaration kind. if (!signature.isolatedSignatureType) { - var isConstructor = signature.declaration.kind === 136 /* Constructor */ || signature.declaration.kind === 140 /* ConstructSignature */; + var isConstructor = signature.declaration.kind === 137 /* Constructor */ || signature.declaration.kind === 141 /* ConstructSignature */; var type = createObjectType(32768 /* Anonymous */ | 131072 /* FromSignature */); type.members = emptySymbols; type.properties = emptyArray; @@ -14898,7 +15353,7 @@ var ts; return symbol.members["__index"]; } function getIndexDeclarationOfSymbol(symbol, kind) { - var syntaxKind = kind === 1 /* Number */ ? 120 /* NumberKeyword */ : 122 /* StringKeyword */; + var syntaxKind = kind === 1 /* Number */ ? 121 /* NumberKeyword */ : 123 /* StringKeyword */; var indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { var len = indexSymbol.declarations.length; @@ -14928,13 +15383,13 @@ var ts; type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; } else { - type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 129 /* TypeParameter */).constraint); + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 130 /* TypeParameter */).constraint); } } return type.constraint === noConstraintType ? undefined : type.constraint; } function getParentSymbolOfTypeParameter(typeParameter) { - return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 129 /* TypeParameter */).parent); + return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 130 /* TypeParameter */).parent); } function getTypeListId(types) { switch (types.length) { @@ -14987,13 +15442,13 @@ var ts; currentNode = currentNode.parent; } // if last step was made from the type parameter this means that path has started somewhere in constraint which is illegal - links.isIllegalTypeReferenceInConstraint = currentNode.kind === 129 /* TypeParameter */; + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 130 /* TypeParameter */; return links.isIllegalTypeReferenceInConstraint; } function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { var typeParameterSymbol; function check(n) { - if (n.kind === 142 /* TypeReference */ && n.typeName.kind === 65 /* Identifier */) { + if (n.kind === 144 /* TypeReference */ && n.typeName.kind === 65 /* Identifier */) { var links = getNodeLinks(n); if (links.isIllegalTypeReferenceInConstraint === undefined) { var symbol = resolveName(typeParameter, n.typeName.text, 793056 /* Type */, undefined, undefined); @@ -15005,7 +15460,7 @@ var ts; // -> typeParameter and symbol.declaration originate from the same type parameter list // -> illegal for all declarations in symbol // forEach === exists - links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent == typeParameter.parent; }); + links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent === typeParameter.parent; }); } } if (links.isIllegalTypeReferenceInConstraint) { @@ -15019,62 +15474,82 @@ var ts; check(typeParameter.constraint); } } - function getTypeFromTypeReferenceOrExpressionWithTypeArguments(node) { - var links = getNodeLinks(node); - if (!links.resolvedType) { - var type; - // We don't currently support heritage clauses with complex expressions in them. - // For these cases, we just set the type to be the unknownType. - if (node.kind !== 177 /* ExpressionWithTypeArguments */ || ts.isSupportedExpressionWithTypeArguments(node)) { - var typeNameOrExpression = node.kind === 142 /* TypeReference */ - ? node.typeName - : node.expression; - var symbol = resolveEntityName(typeNameOrExpression, 793056 /* Type */); - if (symbol) { - if ((symbol.flags & 262144 /* TypeParameter */) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { - // TypeScript 1.0 spec (April 2014): 3.4.1 - // Type parameters declared in a particular type parameter list - // may not be referenced in constraints in that type parameter list - // Implementation: such type references are resolved to 'unknown' type that usually denotes error - type = unknownType; - } - else { - type = createTypeReferenceIfGeneric(getDeclaredTypeOfSymbol(symbol), node, node.typeArguments); - } - } + // Get type from reference to class or interface + function getTypeFromClassOrInterfaceReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var typeParameters = type.localTypeParameters; + if (typeParameters) { + if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */), typeParameters.length); + return unknownType; } - links.resolvedType = type || unknownType; - } - return links.resolvedType; - } - function createTypeReferenceIfGeneric(type, node, typeArguments) { - if (type.flags & (1024 /* Class */ | 2048 /* Interface */) && type.flags & 4096 /* Reference */) { // In a type reference, the outer type parameters of the referenced class or interface are automatically // supplied as type arguments and the type reference only specifies arguments for the local type parameters // of the class or interface. - var localTypeParameters = type.localTypeParameters; - var expectedTypeArgCount = localTypeParameters ? localTypeParameters.length : 0; - var typeArgCount = typeArguments ? typeArguments.length : 0; - if (typeArgCount === expectedTypeArgCount) { - // When no type arguments are expected we already have the right type because all outer type parameters - // have themselves as default type arguments. - if (typeArgCount) { - return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(typeArguments, getTypeFromTypeNode))); - } - } - else { - error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */), expectedTypeArgCount); - return undefined; - } + return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(node.typeArguments, getTypeFromTypeNode))); } - else { - if (typeArguments) { - error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); - return undefined; - } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); + return unknownType; } return type; } + // Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include + // references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the + // declared type. Instantiations are cached using the type identities of the type arguments as the key. + function getTypeFromTypeAliasReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var links = getSymbolLinks(symbol); + var typeParameters = links.typeParameters; + if (typeParameters) { + if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, symbolToString(symbol), typeParameters.length); + return unknownType; + } + var typeArguments = ts.map(node.typeArguments, getTypeFromTypeNode); + var id = getTypeListId(typeArguments); + return links.instantiations[id] || (links.instantiations[id] = instantiateType(type, createTypeMapper(typeParameters, typeArguments))); + } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol)); + return unknownType; + } + return type; + } + // Get type from reference to named type that cannot be generic (enum or type parameter) + function getTypeFromNonGenericTypeReference(node, symbol) { + if (symbol.flags & 262144 /* TypeParameter */ && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { + // TypeScript 1.0 spec (April 2014): 3.4.1 + // Type parameters declared in a particular type parameter list + // may not be referenced in constraints in that type parameter list + // Implementation: such type references are resolved to 'unknown' type that usually denotes error + return unknownType; + } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol)); + return unknownType; + } + return getDeclaredTypeOfSymbol(symbol); + } + function getTypeFromTypeReference(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + // We only support expressions that are simple qualified names. For other expressions this produces undefined. + var typeNameOrExpression = node.kind === 144 /* TypeReference */ ? node.typeName : + ts.isSupportedExpressionWithTypeArguments(node) ? node.expression : + undefined; + var symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, 793056 /* Type */) || unknownSymbol; + var type = symbol === unknownSymbol ? unknownType : + symbol.flags & (32 /* Class */ | 64 /* Interface */) ? getTypeFromClassOrInterfaceReference(node, symbol) : + symbol.flags & 524288 /* TypeAlias */ ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); + // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the + // type reference in checkTypeReferenceOrExpressionWithTypeArguments. + links.resolvedSymbol = symbol; + links.resolvedType = type; + } + return links.resolvedType; + } function getTypeFromTypeQueryNode(node) { var links = getNodeLinks(node); if (!links.resolvedType) { @@ -15082,7 +15557,7 @@ var ts; // The expression is processed as an identifier expression (section 4.3) // or property access expression(section 4.10), // the widened type(section 3.9) of which becomes the result. - links.resolvedType = getWidenedType(checkExpressionOrQualifiedName(node.exprName)); + links.resolvedType = getWidenedType(checkExpression(node.exprName)); } return links.resolvedType; } @@ -15092,9 +15567,9 @@ var ts; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; switch (declaration.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: return declaration; } } @@ -15307,40 +15782,42 @@ var ts; switch (node.kind) { case 112 /* AnyKeyword */: return anyType; - case 122 /* StringKeyword */: + case 123 /* StringKeyword */: return stringType; - case 120 /* NumberKeyword */: + case 121 /* NumberKeyword */: return numberType; case 113 /* BooleanKeyword */: return booleanType; - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: return esSymbolType; case 99 /* VoidKeyword */: return voidType; case 8 /* StringLiteral */: return getTypeFromStringLiteral(node); - case 142 /* TypeReference */: - return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 177 /* ExpressionWithTypeArguments */: - return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 145 /* TypeQuery */: + case 144 /* TypeReference */: + return getTypeFromTypeReference(node); + case 143 /* TypePredicate */: + return booleanType; + case 179 /* ExpressionWithTypeArguments */: + return getTypeFromTypeReference(node); + case 147 /* TypeQuery */: return getTypeFromTypeQueryNode(node); - case 147 /* ArrayType */: + case 149 /* ArrayType */: return getTypeFromArrayTypeNode(node); - case 148 /* TupleType */: + case 150 /* TupleType */: return getTypeFromTupleTypeNode(node); - case 149 /* UnionType */: + case 151 /* UnionType */: return getTypeFromUnionTypeNode(node); - case 150 /* ParenthesizedType */: + case 152 /* ParenthesizedType */: return getTypeFromTypeNode(node.type); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 146 /* TypeLiteral */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 148 /* TypeLiteral */: return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); // This function assumes that an identifier or qualified name is a type expression // Callers should first ensure this by calling isTypeNode case 65 /* Identifier */: - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: var symbol = getSymbolInfo(node); return symbol && getDeclaredTypeOfSymbol(symbol); default: @@ -15430,11 +15907,19 @@ var ts; } function instantiateSignature(signature, mapper, eraseTypeParameters) { var freshTypeParameters; + var freshTypePredicate; if (signature.typeParameters && !eraseTypeParameters) { freshTypeParameters = instantiateList(signature.typeParameters, mapper, instantiateTypeParameter); mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper); } - var result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); + if (signature.typePredicate) { + freshTypePredicate = { + parameterName: signature.typePredicate.parameterName, + parameterIndex: signature.typePredicate.parameterIndex, + type: instantiateType(signature.typePredicate.type, mapper) + }; + } + var result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, freshTypePredicate, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); result.target = signature; result.mapper = mapper; return result; @@ -15499,27 +15984,27 @@ var ts; // Returns true if the given expression contains (at any level of nesting) a function or arrow expression // that is subject to contextual typing. function isContextSensitive(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); switch (node.kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: return isContextSensitiveFunctionLikeDeclaration(node); - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return ts.forEach(node.properties, isContextSensitive); - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return ts.forEach(node.elements, isContextSensitive); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return node.operatorToken.kind === 49 /* BarBarToken */ && (isContextSensitive(node.left) || isContextSensitive(node.right)); - case 225 /* PropertyAssignment */: + case 227 /* PropertyAssignment */: return isContextSensitive(node.initializer); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return isContextSensitiveFunctionLikeDeclaration(node); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return isContextSensitive(node.expression); } return false; @@ -15527,14 +16012,14 @@ var ts; function isContextSensitiveFunctionLikeDeclaration(node) { return !node.typeParameters && node.parameters.length && !ts.forEach(node.parameters, function (p) { return p.type; }); } - function getTypeWithoutConstructors(type) { + function getTypeWithoutSignatures(type) { if (type.flags & 48128 /* ObjectType */) { var resolved = resolveObjectOrUnionTypeMembers(type); if (resolved.constructSignatures.length) { var result = createObjectType(32768 /* Anonymous */, type.symbol); result.members = resolved.members; result.properties = resolved.properties; - result.callSignatures = resolved.callSignatures; + result.callSignatures = emptyArray; result.constructSignatures = emptyArray; type = result; } @@ -15542,9 +16027,6 @@ var ts; return type; } // TYPE CHECKING - var subtypeRelation = {}; - var assignableRelation = {}; - var identityRelation = {}; function isTypeIdenticalTo(source, target) { return checkTypeRelatedTo(source, target, identityRelation, undefined); } @@ -15821,9 +16303,9 @@ var ts; maybeStack[depth][id] = 1 /* Succeeded */; depth++; var saveExpandingFlags = expandingFlags; - if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack)) + if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack, depth)) expandingFlags |= 1; - if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack)) + if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack, depth)) expandingFlags |= 2; var result; if (expandingFlags === 3) { @@ -15859,27 +16341,6 @@ var ts; } return result; } - // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case - // when structural type comparisons have been started for 10 or more instantiations of the same generic type. It is possible, - // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely expanding. - // Effectively, we will generate a false positive when two types are structurally equal to at least 10 levels, but unequal at - // some level beyond that. - function isDeeplyNestedGeneric(type, stack) { - // We track type references (created by createTypeReference) and instantiated types (created by instantiateType) - if (type.flags & (4096 /* Reference */ | 65536 /* Instantiated */) && depth >= 10) { - var symbol = type.symbol; - var count = 0; - for (var i = 0; i < depth; i++) { - var t = stack[i]; - if (t.flags & (4096 /* Reference */ | 65536 /* Instantiated */) && t.symbol === symbol) { - count++; - if (count >= 10) - return true; - } - } - } - return false; - } function propertiesRelatedTo(source, target, reportErrors) { if (relation === identityRelation) { return propertiesIdenticalTo(source, target); @@ -16060,6 +16521,33 @@ var ts; } result &= related; } + if (source.typePredicate && target.typePredicate) { + var hasDifferentParameterIndex = source.typePredicate.parameterIndex !== target.typePredicate.parameterIndex; + var hasDifferentTypes; + if (hasDifferentParameterIndex || + (hasDifferentTypes = !isTypeIdenticalTo(source.typePredicate.type, target.typePredicate.type))) { + if (reportErrors) { + var sourceParamText = source.typePredicate.parameterName; + var targetParamText = target.typePredicate.parameterName; + var sourceTypeText = typeToString(source.typePredicate.type); + var targetTypeText = typeToString(target.typePredicate.type); + if (hasDifferentParameterIndex) { + reportError(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, sourceParamText, targetParamText); + } + else if (hasDifferentTypes) { + reportError(ts.Diagnostics.Type_0_is_not_assignable_to_type_1, sourceTypeText, targetTypeText); + } + reportError(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, sourceParamText + " is " + sourceTypeText, targetParamText + " is " + targetTypeText); + } + return 0 /* False */; + } + } + else if (!source.typePredicate && target.typePredicate) { + if (reportErrors) { + reportError(ts.Diagnostics.Signature_0_must_have_a_type_predicate, signatureToString(source)); + } + return 0 /* False */; + } var t = getReturnTypeOfSignature(target); if (t === voidType) return result; @@ -16150,6 +16638,27 @@ var ts; return 0 /* False */; } } + // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case + // when structural type comparisons have been started for 10 or more instantiations of the same generic type. It is possible, + // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely expanding. + // Effectively, we will generate a false positive when two types are structurally equal to at least 10 levels, but unequal at + // some level beyond that. + function isDeeplyNestedGeneric(type, stack, depth) { + // We track type references (created by createTypeReference) and instantiated types (created by instantiateType) + if (type.flags & (4096 /* Reference */ | 65536 /* Instantiated */) && depth >= 5) { + var symbol = type.symbol; + var count = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (t.flags & (4096 /* Reference */ | 65536 /* Instantiated */) && t.symbol === symbol) { + count++; + if (count >= 5) + return true; + } + } + } + return false; + } function isPropertyIdenticalTo(sourceProp, targetProp) { return compareProperties(sourceProp, targetProp, compareTypes) !== 0 /* False */; } @@ -16356,22 +16865,22 @@ var ts; var typeAsString = typeToString(getWidenedType(type)); var diagnostic; switch (declaration.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; break; - case 130 /* Parameter */: + case 131 /* Parameter */: diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; break; - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: if (!declaration.name) { error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); return; @@ -16444,20 +16953,6 @@ var ts; } return false; } - function isWithinDepthLimit(type, stack) { - if (depth >= 5) { - var target_1 = type.target; - var count = 0; - for (var i = 0; i < depth; i++) { - var t = stack[i]; - if (t.flags & 4096 /* Reference */ && t.target === target_1) { - count++; - } - } - return count < 5; - } - return true; - } function inferFromTypes(source, target) { if (source === anyFunctionType) { return; @@ -16527,22 +17022,26 @@ var ts; else if (source.flags & 48128 /* ObjectType */ && (target.flags & (4096 /* Reference */ | 8192 /* Tuple */) || (target.flags & 32768 /* Anonymous */) && target.symbol && target.symbol.flags & (8192 /* Method */ | 2048 /* TypeLiteral */))) { // If source is an object type, and target is a type reference, a tuple type, the type of a method, or a type literal, infer from members - if (!isInProcess(source, target) && isWithinDepthLimit(source, sourceStack) && isWithinDepthLimit(target, targetStack)) { - if (depth === 0) { - sourceStack = []; - targetStack = []; - } - sourceStack[depth] = source; - targetStack[depth] = target; - depth++; - inferFromProperties(source, target); - inferFromSignatures(source, target, 0 /* Call */); - inferFromSignatures(source, target, 1 /* Construct */); - inferFromIndexTypes(source, target, 0 /* String */, 0 /* String */); - inferFromIndexTypes(source, target, 1 /* Number */, 1 /* Number */); - inferFromIndexTypes(source, target, 0 /* String */, 1 /* Number */); - depth--; + if (isInProcess(source, target)) { + return; } + if (isDeeplyNestedGeneric(source, sourceStack, depth) && isDeeplyNestedGeneric(target, targetStack, depth)) { + return; + } + if (depth === 0) { + sourceStack = []; + targetStack = []; + } + sourceStack[depth] = source; + targetStack[depth] = target; + depth++; + inferFromProperties(source, target); + inferFromSignatures(source, target, 0 /* Call */); + inferFromSignatures(source, target, 1 /* Construct */); + inferFromIndexTypes(source, target, 0 /* String */, 0 /* String */); + inferFromIndexTypes(source, target, 1 /* Number */, 1 /* Number */); + inferFromIndexTypes(source, target, 0 /* String */, 1 /* Number */); + depth--; } } function inferFromProperties(source, target) { @@ -16567,7 +17066,17 @@ var ts; } function inferFromSignature(source, target) { forEachMatchingParameterType(source, target, inferFromTypes); - inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + if (source.typePredicate && target.typePredicate) { + if (target.typePredicate.parameterIndex === source.typePredicate.parameterIndex) { + // Return types from type predicates are treated as booleans. In order to infer types + // from type predicates we would need to infer using the type within the type predicate + // (i.e. 'Foo' from 'x is Foo'). + inferFromTypes(source.typePredicate.type, target.typePredicate.type); + } + } + else { + inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } } function inferFromIndexTypes(source, target, sourceKind, targetKind) { var targetIndexType = getIndexTypeOfType(target, targetKind); @@ -16640,10 +17149,10 @@ var ts; // The expression is restricted to a single identifier or a sequence of identifiers separated by periods while (node) { switch (node.kind) { - case 145 /* TypeQuery */: + case 147 /* TypeQuery */: return true; case 65 /* Identifier */: - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: node = node.parent; continue; default: @@ -16691,7 +17200,7 @@ var ts; function isAssignedInBinaryExpression(node) { if (node.operatorToken.kind >= 53 /* FirstAssignment */ && node.operatorToken.kind <= 64 /* LastAssignment */) { var n = node.left; - while (n.kind === 162 /* ParenthesizedExpression */) { + while (n.kind === 164 /* ParenthesizedExpression */) { n = n.expression; } if (n.kind === 65 /* Identifier */ && getResolvedSymbol(n) === symbol) { @@ -16708,46 +17217,46 @@ var ts; } function isAssignedIn(node) { switch (node.kind) { - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return isAssignedInBinaryExpression(node); - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: return isAssignedInVariableDeclaration(node); - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 168 /* PrefixUnaryExpression */: - case 165 /* DeleteExpression */: - case 166 /* TypeOfExpression */: - case 167 /* VoidExpression */: - case 169 /* PostfixUnaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 180 /* Block */: - case 181 /* VariableStatement */: - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 192 /* ReturnStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 196 /* ThrowStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: + case 156 /* ArrayLiteralExpression */: + case 157 /* ObjectLiteralExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 163 /* TypeAssertionExpression */: + case 164 /* ParenthesizedExpression */: + case 170 /* PrefixUnaryExpression */: + case 167 /* DeleteExpression */: + case 168 /* TypeOfExpression */: + case 169 /* VoidExpression */: + case 171 /* PostfixUnaryExpression */: + case 173 /* ConditionalExpression */: + case 176 /* SpreadElementExpression */: + case 182 /* Block */: + case 183 /* VariableStatement */: + case 185 /* ExpressionStatement */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 194 /* ReturnStatement */: + case 195 /* WithStatement */: + case 196 /* SwitchStatement */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: + case 197 /* LabeledStatement */: + case 198 /* ThrowStatement */: + case 199 /* TryStatement */: + case 226 /* CatchClause */: return ts.forEachChild(node, isAssignedIn); } return false; @@ -16800,19 +17309,19 @@ var ts; node = node.parent; var narrowedType = type; switch (node.kind) { - case 184 /* IfStatement */: + case 186 /* IfStatement */: // In a branch of an if statement, narrow based on controlling expression if (child !== node.expression) { narrowedType = narrowType(type, node.expression, child === node.thenStatement); } break; - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: // In a branch of a conditional expression, narrow based on controlling condition if (child !== node.condition) { narrowedType = narrowType(type, node.condition, child === node.whenTrue); } break; - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: // In the right operand of an && or ||, narrow based on left operand if (child === node.right) { if (node.operatorToken.kind === 48 /* AmpersandAmpersandToken */) { @@ -16823,14 +17332,14 @@ var ts; } } break; - case 228 /* SourceFile */: - case 206 /* ModuleDeclaration */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: + case 230 /* SourceFile */: + case 208 /* ModuleDeclaration */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 137 /* Constructor */: // Stop at the first containing function or module declaration break loop; } @@ -16847,7 +17356,7 @@ var ts; return type; function narrowTypeByEquality(type, expr, assumeTrue) { // Check that we have 'typeof ' on the left and string literal on the right - if (expr.left.kind !== 166 /* TypeOfExpression */ || expr.right.kind !== 8 /* StringLiteral */) { + if (expr.left.kind !== 168 /* TypeOfExpression */ || expr.right.kind !== 8 /* StringLiteral */) { return type; } var left = expr.left; @@ -16923,7 +17432,7 @@ var ts; var targetType; var prototypeProperty = getPropertyOfType(rightType, "prototype"); if (prototypeProperty) { - // Target type is type of the protoype property + // Target type is type of the prototype property var prototypePropertyType = getTypeOfSymbol(prototypeProperty); if (!isTypeAny(prototypePropertyType)) { targetType = prototypePropertyType; @@ -16943,14 +17452,36 @@ var ts; } } if (targetType) { - // Narrow to the target type if it's a subtype of the current type - if (isTypeSubtypeOf(targetType, type)) { - return targetType; - } - // If the current type is a union type, remove all constituents that aren't subtypes of the target. - if (type.flags & 16384 /* Union */) { - return getUnionType(ts.filter(type.types, function (t) { return isTypeSubtypeOf(t, targetType); })); + return getNarrowedType(type, targetType); + } + return type; + } + function getNarrowedType(originalType, narrowedTypeCandidate) { + // Narrow to the target type if it's a subtype of the current type + if (isTypeSubtypeOf(narrowedTypeCandidate, originalType)) { + return narrowedTypeCandidate; + } + // If the current type is a union type, remove all constituents that aren't subtypes of the target. + if (originalType.flags & 16384 /* Union */) { + return getUnionType(ts.filter(originalType.types, function (t) { return isTypeSubtypeOf(t, narrowedTypeCandidate); })); + } + return originalType; + } + function narrowTypeByTypePredicate(type, expr, assumeTrue) { + if (type.flags & 1 /* Any */) { + return type; + } + var signature = getResolvedSignature(expr); + if (signature.typePredicate && + expr.arguments[signature.typePredicate.parameterIndex] && + getSymbolAtLocation(expr.arguments[signature.typePredicate.parameterIndex]) === symbol) { + if (!assumeTrue) { + if (type.flags & 16384 /* Union */) { + return getUnionType(ts.filter(type.types, function (t) { return !isTypeSubtypeOf(t, signature.typePredicate.type); })); + } + return type; } + return getNarrowedType(type, signature.typePredicate.type); } return type; } @@ -16958,9 +17489,11 @@ var ts; // will be a subtype or the same type as the argument. function narrowType(type, expr, assumeTrue) { switch (expr.kind) { - case 162 /* ParenthesizedExpression */: + case 160 /* CallExpression */: + return narrowTypeByTypePredicate(type, expr, assumeTrue); + case 164 /* ParenthesizedExpression */: return narrowType(type, expr.expression, assumeTrue); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: var operator = expr.operatorToken.kind; if (operator === 30 /* EqualsEqualsEqualsToken */ || operator === 31 /* ExclamationEqualsEqualsToken */) { return narrowTypeByEquality(type, expr, assumeTrue); @@ -16975,7 +17508,7 @@ var ts; return narrowTypeByInstanceof(type, expr, assumeTrue); } break; - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: if (expr.operator === 46 /* ExclamationToken */) { return narrowType(type, expr.operand, !assumeTrue); } @@ -16992,7 +17525,7 @@ var ts; // will be bound to non-arrow function that contain this arrow function. This results in inconsistent behavior. // To avoid that we will give an error to users if they use arguments objects in arrow function so that they // can explicitly bound arguments objects - if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 164 /* ArrowFunction */ && languageVersion < 2 /* ES6 */) { + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 166 /* ArrowFunction */ && languageVersion < 2 /* ES6 */) { error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); } if (symbol.flags & 8388608 /* Alias */ && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { @@ -17016,7 +17549,7 @@ var ts; function checkBlockScopedBindingCapturedInLoop(node, symbol) { if (languageVersion >= 2 /* ES6 */ || (symbol.flags & 2 /* BlockScopedVariable */) === 0 || - symbol.valueDeclaration.parent.kind === 224 /* CatchClause */) { + symbol.valueDeclaration.parent.kind === 226 /* CatchClause */) { return; } // - check if binding is used in some function @@ -17025,12 +17558,12 @@ var ts; // nesting structure: // (variable declaration or binding element) -> variable declaration list -> container var container = symbol.valueDeclaration; - while (container.kind !== 200 /* VariableDeclarationList */) { + while (container.kind !== 202 /* VariableDeclarationList */) { container = container.parent; } // get the parent of variable declaration list container = container.parent; - if (container.kind === 181 /* VariableStatement */) { + if (container.kind === 183 /* VariableStatement */) { // if parent is variable statement - get its parent container = container.parent; } @@ -17049,9 +17582,9 @@ var ts; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 202 /* ClassDeclaration */ ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 204 /* ClassDeclaration */ ? container.parent : undefined; getNodeLinks(node).flags |= 2 /* LexicalThis */; - if (container.kind === 133 /* PropertyDeclaration */ || container.kind === 136 /* Constructor */) { + if (container.kind === 134 /* PropertyDeclaration */ || container.kind === 137 /* Constructor */) { getNodeLinks(classNode).flags |= 4 /* CaptureThis */; } else { @@ -17064,39 +17597,39 @@ var ts; var container = ts.getThisContainer(node, true); var needToCaptureLexicalThis = false; // Now skip arrow functions to get the "real" owner of 'this'. - if (container.kind === 164 /* ArrowFunction */) { + if (container.kind === 166 /* ArrowFunction */) { container = ts.getThisContainer(container, false); // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code needToCaptureLexicalThis = (languageVersion < 2 /* ES6 */); } switch (container.kind) { - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body); // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks break; - case 136 /* Constructor */: + case 137 /* Constructor */: if (isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); } break; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: if (container.flags & 128 /* Static */) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); } break; - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name); break; } if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 202 /* ClassDeclaration */ ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 204 /* ClassDeclaration */ ? container.parent : undefined; if (classNode) { var symbol = getSymbolOfNode(classNode); return container.flags & 128 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); @@ -17105,23 +17638,21 @@ var ts; } function isInConstructorArgumentInitializer(node, constructorDecl) { for (var n = node; n && n !== constructorDecl; n = n.parent) { - if (n.kind === 130 /* Parameter */) { + if (n.kind === 131 /* Parameter */) { return true; } } return false; } function checkSuperExpression(node) { - var isCallExpression = node.parent.kind === 158 /* CallExpression */ && node.parent.expression === node; - var enclosingClass = ts.getAncestor(node, 202 /* ClassDeclaration */); - var baseClass; - if (enclosingClass && ts.getClassExtendsHeritageClauseElement(enclosingClass)) { - var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); - var baseTypes = getBaseTypes(classType); - baseClass = baseTypes.length && baseTypes[0]; - } - if (!baseClass) { - error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + var isCallExpression = node.parent.kind === 160 /* CallExpression */ && node.parent.expression === node; + var classDeclaration = ts.getAncestor(node, 204 /* ClassDeclaration */); + var classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); + var baseClassType = classType && getBaseTypes(classType)[0]; + if (!baseClassType) { + if (!classDeclaration || !ts.getClassExtendsHeritageClauseElement(classDeclaration)) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + } return unknownType; } var container = ts.getSuperContainer(node, true); @@ -17131,7 +17662,7 @@ var ts; if (isCallExpression) { // TS 1.0 SPEC (April 2014): 4.8.1 // Super calls are only permitted in constructors of derived classes - canUseSuperExpression = container.kind === 136 /* Constructor */; + canUseSuperExpression = container.kind === 137 /* Constructor */; } else { // TS 1.0 SPEC (April 2014) @@ -17140,28 +17671,28 @@ var ts; // - In a static member function or static member accessor // super property access might appear in arrow functions with arbitrary deep nesting needToCaptureLexicalThis = false; - while (container && container.kind === 164 /* ArrowFunction */) { + while (container && container.kind === 166 /* ArrowFunction */) { container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = languageVersion < 2 /* ES6 */; } // topmost container must be something that is directly nested in the class declaration - if (container && container.parent && container.parent.kind === 202 /* ClassDeclaration */) { + if (container && container.parent && container.parent.kind === 204 /* ClassDeclaration */) { if (container.flags & 128 /* Static */) { canUseSuperExpression = - container.kind === 135 /* MethodDeclaration */ || - container.kind === 134 /* MethodSignature */ || - container.kind === 137 /* GetAccessor */ || - container.kind === 138 /* SetAccessor */; + container.kind === 136 /* MethodDeclaration */ || + container.kind === 135 /* MethodSignature */ || + container.kind === 138 /* GetAccessor */ || + container.kind === 139 /* SetAccessor */; } else { canUseSuperExpression = - container.kind === 135 /* MethodDeclaration */ || - container.kind === 134 /* MethodSignature */ || - container.kind === 137 /* GetAccessor */ || - container.kind === 138 /* SetAccessor */ || - container.kind === 133 /* PropertyDeclaration */ || - container.kind === 132 /* PropertySignature */ || - container.kind === 136 /* Constructor */; + container.kind === 136 /* MethodDeclaration */ || + container.kind === 135 /* MethodSignature */ || + container.kind === 138 /* GetAccessor */ || + container.kind === 139 /* SetAccessor */ || + container.kind === 134 /* PropertyDeclaration */ || + container.kind === 133 /* PropertySignature */ || + container.kind === 137 /* Constructor */; } } } @@ -17169,13 +17700,13 @@ var ts; var returnType; if ((container.flags & 128 /* Static */) || isCallExpression) { getNodeLinks(node).flags |= 32 /* SuperStatic */; - returnType = getTypeOfSymbol(baseClass.symbol); + returnType = getBaseConstructorTypeOfClass(classType); } else { getNodeLinks(node).flags |= 16 /* SuperInstance */; - returnType = baseClass; + returnType = baseClassType; } - if (container.kind === 136 /* Constructor */ && isInConstructorArgumentInitializer(node, container)) { + if (container.kind === 137 /* Constructor */ && isInConstructorArgumentInitializer(node, container)) { // issue custom error message for super property access in constructor arguments (to be aligned with old compiler) error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); returnType = unknownType; @@ -17189,7 +17720,7 @@ var ts; return returnType; } } - if (container && container.kind === 128 /* ComputedPropertyName */) { + if (container && container.kind === 129 /* ComputedPropertyName */) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); } else if (isCallExpression) { @@ -17234,7 +17765,7 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130 /* Parameter */) { + if (declaration.kind === 131 /* Parameter */) { var type = getContextuallyTypedParameterType(declaration); if (type) { return type; @@ -17269,8 +17800,8 @@ var ts; // If the containing function has a return type annotation, is a constructor, or is a get accessor whose // corresponding set accessor has a type annotation, return statements in the function are contextually typed if (functionDecl.type || - functionDecl.kind === 136 /* Constructor */ || - functionDecl.kind === 137 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 138 /* SetAccessor */))) { + functionDecl.kind === 137 /* Constructor */ || + functionDecl.kind === 138 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 139 /* SetAccessor */))) { return getReturnTypeOfSignature(getSignatureFromDeclaration(functionDecl)); } // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature @@ -17292,7 +17823,7 @@ var ts; return undefined; } function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { - if (template.parent.kind === 160 /* TaggedTemplateExpression */) { + if (template.parent.kind === 162 /* TaggedTemplateExpression */) { return getContextualTypeForArgument(template.parent, substitutionExpression); } return undefined; @@ -17423,34 +17954,34 @@ var ts; } var parent = node.parent; switch (parent.kind) { - case 199 /* VariableDeclaration */: - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 131 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 155 /* BindingElement */: return getContextualTypeForInitializerExpression(node); - case 164 /* ArrowFunction */: - case 192 /* ReturnStatement */: + case 166 /* ArrowFunction */: + case 194 /* ReturnStatement */: return getContextualTypeForReturnExpression(node); - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: return getContextualTypeForYieldOperand(parent); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return getContextualTypeForArgument(parent, node); - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return getTypeFromTypeNode(parent.type); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return getContextualTypeForBinaryOperand(node); - case 225 /* PropertyAssignment */: + case 227 /* PropertyAssignment */: return getContextualTypeForObjectLiteralElement(parent); - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return getContextualTypeForElementExpression(node); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return getContextualTypeForConditionalOperand(node); - case 178 /* TemplateSpan */: - ts.Debug.assert(parent.parent.kind === 172 /* TemplateExpression */); + case 180 /* TemplateSpan */: + ts.Debug.assert(parent.parent.kind === 174 /* TemplateExpression */); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return getContextualType(parent); } return undefined; @@ -17467,7 +17998,7 @@ var ts; } } function isFunctionExpressionOrArrowFunction(node) { - return node.kind === 163 /* FunctionExpression */ || node.kind === 164 /* ArrowFunction */; + return node.kind === 165 /* FunctionExpression */ || node.kind === 166 /* ArrowFunction */; } function getContextualSignatureForFunctionLikeDeclaration(node) { // Only function expressions, arrow functions, and object literal methods are contextually typed. @@ -17481,7 +18012,7 @@ var ts; // all identical ignoring their return type, the result is same signature but with return type as // union type of return types from these signatures function getContextualSignature(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); @@ -17537,13 +18068,13 @@ var ts; // an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ p: a}] = xxx'. function isAssignmentTarget(node) { var parent = node.parent; - if (parent.kind === 170 /* BinaryExpression */ && parent.operatorToken.kind === 53 /* EqualsToken */ && parent.left === node) { + if (parent.kind === 172 /* BinaryExpression */ && parent.operatorToken.kind === 53 /* EqualsToken */ && parent.left === node) { return true; } - if (parent.kind === 225 /* PropertyAssignment */) { + if (parent.kind === 227 /* PropertyAssignment */) { return isAssignmentTarget(parent.parent); } - if (parent.kind === 154 /* ArrayLiteralExpression */) { + if (parent.kind === 156 /* ArrayLiteralExpression */) { return isAssignmentTarget(parent); } return false; @@ -17568,7 +18099,7 @@ var ts; var inDestructuringPattern = isAssignmentTarget(node); for (var _i = 0; _i < elements.length; _i++) { var e = elements[_i]; - if (inDestructuringPattern && e.kind === 174 /* SpreadElementExpression */) { + if (inDestructuringPattern && e.kind === 176 /* SpreadElementExpression */) { // Given the following situation: // var c: {}; // [...c] = ["", 0]; @@ -17592,7 +18123,7 @@ var ts; var type = checkExpression(e, contextualMapper); elementTypes.push(type); } - hasSpreadElement = hasSpreadElement || e.kind === 174 /* SpreadElementExpression */; + hasSpreadElement = hasSpreadElement || e.kind === 176 /* SpreadElementExpression */; } if (!hasSpreadElement) { var contextualType = getContextualType(node); @@ -17603,7 +18134,7 @@ var ts; return createArrayType(getUnionType(elementTypes)); } function isNumericName(name) { - return name.kind === 128 /* ComputedPropertyName */ ? isNumericComputedName(name) : isNumericLiteralName(name.text); + return name.kind === 129 /* ComputedPropertyName */ ? isNumericComputedName(name) : isNumericLiteralName(name.text); } function isNumericComputedName(name) { // It seems odd to consider an expression of type Any to result in a numeric name, @@ -17662,18 +18193,18 @@ var ts; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var memberDecl = _a[_i]; var member = memberDecl.symbol; - if (memberDecl.kind === 225 /* PropertyAssignment */ || - memberDecl.kind === 226 /* ShorthandPropertyAssignment */ || + if (memberDecl.kind === 227 /* PropertyAssignment */ || + memberDecl.kind === 228 /* ShorthandPropertyAssignment */ || ts.isObjectLiteralMethod(memberDecl)) { var type = void 0; - if (memberDecl.kind === 225 /* PropertyAssignment */) { + if (memberDecl.kind === 227 /* PropertyAssignment */) { type = checkPropertyAssignment(memberDecl, contextualMapper); } - else if (memberDecl.kind === 135 /* MethodDeclaration */) { + else if (memberDecl.kind === 136 /* MethodDeclaration */) { type = checkObjectLiteralMethod(memberDecl, contextualMapper); } else { - ts.Debug.assert(memberDecl.kind === 226 /* ShorthandPropertyAssignment */); + ts.Debug.assert(memberDecl.kind === 228 /* ShorthandPropertyAssignment */); type = checkExpression(memberDecl.name, contextualMapper); } typeFlags |= type.flags; @@ -17693,7 +18224,7 @@ var ts; // an ordinary function declaration(section 6.1) with no parameters. // A set accessor declaration is processed in the same manner // as an ordinary function declaration with a single parameter and a Void return type. - ts.Debug.assert(memberDecl.kind === 137 /* GetAccessor */ || memberDecl.kind === 138 /* SetAccessor */); + ts.Debug.assert(memberDecl.kind === 138 /* GetAccessor */ || memberDecl.kind === 139 /* SetAccessor */); checkAccessorDeclaration(memberDecl); } if (!ts.hasDynamicName(memberDecl)) { @@ -17732,7 +18263,7 @@ var ts; // If a symbol is a synthesized symbol with no value declaration, we assume it is a property. Example of this are the synthesized // '.prototype' property as well as synthesized tuple index properties. function getDeclarationKindFromSymbol(s) { - return s.valueDeclaration ? s.valueDeclaration.kind : 133 /* PropertyDeclaration */; + return s.valueDeclaration ? s.valueDeclaration.kind : 134 /* PropertyDeclaration */; } function getDeclarationFlagsFromSymbol(s) { return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 16 /* Public */ | 128 /* Static */ : 0; @@ -17745,7 +18276,7 @@ var ts; } // Property is known to be private or protected at this point // Get the declaring and enclosing class instance types - var enclosingClassDeclaration = ts.getAncestor(node, 202 /* ClassDeclaration */); + var enclosingClassDeclaration = ts.getAncestor(node, 204 /* ClassDeclaration */); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); // Private property is accessible if declaring and enclosing class are the same @@ -17781,7 +18312,7 @@ var ts; return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right); } function checkPropertyAccessExpressionOrQualifiedName(node, left, right) { - var type = checkExpressionOrQualifiedName(left); + var type = checkExpression(left); if (isTypeAny(type)) { return type; } @@ -17806,7 +18337,7 @@ var ts; // - In a static member function or static member accessor // where this references the constructor function object of a derived class, // a super property access is permitted and must specify a public static member function of the base class. - if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 135 /* MethodDeclaration */) { + if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 136 /* MethodDeclaration */) { error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { @@ -17816,14 +18347,14 @@ var ts; return getTypeOfSymbol(prop); } function isValidPropertyAccess(node, propertyName) { - var left = node.kind === 156 /* PropertyAccessExpression */ + var left = node.kind === 158 /* PropertyAccessExpression */ ? node.expression : node.left; - var type = checkExpressionOrQualifiedName(left); + var type = checkExpression(left); if (type !== unknownType && !isTypeAny(type)) { var prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & 32 /* Class */) { - if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 135 /* MethodDeclaration */) { + if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 136 /* MethodDeclaration */) { return false; } else { @@ -17839,7 +18370,7 @@ var ts; // Grammar checking if (!node.argumentExpression) { var sourceFile = getSourceFile(node); - if (node.parent.kind === 159 /* NewExpression */ && node.parent.expression === node) { + if (node.parent.kind === 161 /* NewExpression */ && node.parent.expression === node) { var start = ts.skipTrivia(sourceFile.text, node.expression.end); var end = node.end; grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead); @@ -17968,7 +18499,7 @@ var ts; return true; } function resolveUntypedCall(node) { - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 162 /* TaggedTemplateExpression */) { checkExpression(node.template); } else { @@ -18036,7 +18567,7 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 174 /* SpreadElementExpression */) { + if (args[i].kind === 176 /* SpreadElementExpression */) { return i; } } @@ -18046,13 +18577,13 @@ var ts; var adjustedArgCount; // Apparent number of arguments we will have in this call var typeArguments; // Type arguments (undefined if none) var callIsIncomplete; // In incomplete call we want to be lenient when we have too few arguments - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 162 /* TaggedTemplateExpression */) { var tagExpression = node; // Even if the call is incomplete, we'll have a missing expression as our last argument, // so we can say the count is just the arg list length adjustedArgCount = args.length; typeArguments = undefined; - if (tagExpression.template.kind === 172 /* TemplateExpression */) { + if (tagExpression.template.kind === 174 /* TemplateExpression */) { // If a tagged template expression lacks a tail literal, the call is incomplete. // Specifically, a template only can end in a TemplateTail or a Missing literal. var templateExpression = tagExpression.template; @@ -18073,7 +18604,7 @@ var ts; var callExpression = node; if (!callExpression.arguments) { // This only happens when we have something of the form: 'new C' - ts.Debug.assert(callExpression.kind === 159 /* NewExpression */); + ts.Debug.assert(callExpression.kind === 161 /* NewExpression */); return signature.minArgumentCount === 0; } // For IDE scenarios we may have an incomplete call, so a trailing comma is tantamount to adding another argument. @@ -18150,10 +18681,10 @@ var ts; // wildcards for all context sensitive function expressions. for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176 /* OmittedExpression */) { + if (arg.kind !== 178 /* OmittedExpression */) { var paramType = getTypeAtPosition(signature, i); var argType = void 0; - if (i === 0 && args[i].parent.kind === 160 /* TaggedTemplateExpression */) { + if (i === 0 && args[i].parent.kind === 162 /* TaggedTemplateExpression */) { argType = globalTemplateStringsArrayType; } else { @@ -18200,12 +18731,12 @@ var ts; function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176 /* OmittedExpression */) { + if (arg.kind !== 178 /* OmittedExpression */) { // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) var paramType = getTypeAtPosition(signature, i); // A tagged template expression provides a special first argument, and string literals get string literal types // unless we're reporting errors - var argType = i === 0 && node.kind === 160 /* TaggedTemplateExpression */ + var argType = i === 0 && node.kind === 162 /* TaggedTemplateExpression */ ? globalTemplateStringsArrayType : arg.kind === 8 /* StringLiteral */ && !reportErrors ? getStringLiteralType(arg) @@ -18227,10 +18758,10 @@ var ts; */ function getEffectiveCallArguments(node) { var args; - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 162 /* TaggedTemplateExpression */) { var template = node.template; args = [template]; - if (template.kind === 172 /* TemplateExpression */) { + if (template.kind === 174 /* TemplateExpression */) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); @@ -18241,32 +18772,11 @@ var ts; } return args; } - /** - * In a 'super' call, type arguments are not provided within the CallExpression node itself. - * Instead, they must be fetched from the class declaration's base type node. - * - * If 'node' is a 'super' call (e.g. super(...), new super(...)), then we attempt to fetch - * the type arguments off the containing class's first heritage clause (if one exists). Note that if - * type arguments are supplied on the 'super' call, they are ignored (though this is syntactically incorrect). - * - * In all other cases, the call's explicit type arguments are returned. - */ - function getEffectiveTypeArguments(callExpression) { - if (callExpression.expression.kind === 91 /* SuperKeyword */) { - var containingClass = ts.getAncestor(callExpression, 202 /* ClassDeclaration */); - var baseClassTypeNode = containingClass && ts.getClassExtendsHeritageClauseElement(containingClass); - return baseClassTypeNode && baseClassTypeNode.typeArguments; - } - else { - // Ordinary case - simple function invocation. - return callExpression.typeArguments; - } - } function resolveCall(node, signatures, candidatesOutArray) { - var isTaggedTemplate = node.kind === 160 /* TaggedTemplateExpression */; + var isTaggedTemplate = node.kind === 162 /* TaggedTemplateExpression */; var typeArguments; if (!isTaggedTemplate) { - typeArguments = getEffectiveTypeArguments(node); + typeArguments = node.typeArguments; // We already perform checking on the type arguments on the class declaration itself. if (node.expression.kind !== 91 /* SuperKeyword */) { ts.forEach(typeArguments, checkSourceElement); @@ -18361,8 +18871,8 @@ var ts; checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && node.typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true); + if (!isTaggedTemplate && typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], true); } else { ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); @@ -18456,7 +18966,11 @@ var ts; if (node.expression.kind === 91 /* SuperKeyword */) { var superType = checkSuperExpression(node.expression); if (superType !== unknownType) { - return resolveCall(node, getSignaturesOfType(superType, 1 /* Construct */), candidatesOutArray); + // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated + // with the type arguments specified in the extends clause. + var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getAncestor(node, 204 /* ClassDeclaration */)); + var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); + return resolveCall(node, baseConstructors, candidatesOutArray); } return resolveUntypedCall(node); } @@ -18578,13 +19092,13 @@ var ts; // to correctly fill the candidatesOutArray. if (!links.resolvedSignature || candidatesOutArray) { links.resolvedSignature = anySignature; - if (node.kind === 158 /* CallExpression */) { + if (node.kind === 160 /* CallExpression */) { links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); } - else if (node.kind === 159 /* NewExpression */) { + else if (node.kind === 161 /* NewExpression */) { links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); } - else if (node.kind === 160 /* TaggedTemplateExpression */) { + else if (node.kind === 162 /* TaggedTemplateExpression */) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } else { @@ -18600,12 +19114,12 @@ var ts; if (node.expression.kind === 91 /* SuperKeyword */) { return voidType; } - if (node.kind === 159 /* NewExpression */) { + if (node.kind === 161 /* NewExpression */) { var declaration = signature.declaration; if (declaration && - declaration.kind !== 136 /* Constructor */ && - declaration.kind !== 140 /* ConstructSignature */ && - declaration.kind !== 144 /* ConstructorType */) { + declaration.kind !== 137 /* Constructor */ && + declaration.kind !== 141 /* ConstructSignature */ && + declaration.kind !== 146 /* ConstructorType */) { // When resolved signature is a call signature (and not a construct signature) the result type is any if (compilerOptions.noImplicitAny) { error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); @@ -18653,7 +19167,7 @@ var ts; return unknownType; } var type; - if (func.body.kind !== 180 /* Block */) { + if (func.body.kind !== 182 /* Block */) { type = checkExpressionCached(func.body, contextualMapper); } else { @@ -18733,7 +19247,7 @@ var ts; }); } function bodyContainsSingleThrowStatement(body) { - return (body.statements.length === 1) && (body.statements[0].kind === 196 /* ThrowStatement */); + return (body.statements.length === 1) && (body.statements[0].kind === 198 /* ThrowStatement */); } // TypeScript Specification 1.0 (6.3) - July 2014 // An explicitly typed function whose return type isn't the Void or the Any type @@ -18748,7 +19262,7 @@ var ts; return; } // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check. - if (ts.nodeIsMissing(func.body) || func.body.kind !== 180 /* Block */) { + if (ts.nodeIsMissing(func.body) || func.body.kind !== 182 /* Block */) { return; } var bodyBlock = func.body; @@ -18766,11 +19280,11 @@ var ts; error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement); } function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); // Grammar checking - var hasGrammarError = checkGrammarDeclarationNameInStrictMode(node) || checkGrammarFunctionLikeDeclaration(node); - if (!hasGrammarError && node.kind === 163 /* FunctionExpression */) { - checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); + var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); + if (!hasGrammarError && node.kind === 165 /* FunctionExpression */) { + checkGrammarForGenerator(node); } // The identityMapper object is used to indicate that function expressions are wildcards if (contextualMapper === identityMapper && isContextSensitive(node)) { @@ -18801,14 +19315,14 @@ var ts; checkSignatureDeclaration(node); } } - if (produceDiagnostics && node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { + if (produceDiagnostics && node.kind !== 136 /* MethodDeclaration */ && node.kind !== 135 /* MethodSignature */) { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); } return type; } function checkFunctionExpressionOrObjectLiteralMethodBody(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); if (node.type && !node.asteriskToken) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } @@ -18821,7 +19335,7 @@ var ts; // checkFunctionExpressionBodies). So it must be done now. getReturnTypeOfSignature(getSignatureFromDeclaration(node)); } - if (node.body.kind === 180 /* Block */) { + if (node.body.kind === 182 /* Block */) { checkSourceElement(node.body); } else { @@ -18863,17 +19377,17 @@ var ts; // An identifier expression that references any other kind of entity is classified as a value(and therefore cannot be the target of an assignment). return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3 /* Variable */) !== 0; } - case 156 /* PropertyAccessExpression */: { + case 158 /* PropertyAccessExpression */: { var symbol = findSymbol(n); // TypeScript 1.0 spec (April 2014): 4.10 // A property access expression is always classified as a reference. // NOTE (not in spec): assignment to enum members should not be allowed return !symbol || symbol === unknownSymbol || (symbol.flags & ~8 /* EnumMember */) !== 0; } - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: // old compiler doesn't check indexed assess return true; - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return isReferenceOrErrorExpression(n.expression); default: return false; @@ -18882,11 +19396,11 @@ var ts; function isConstVariableReference(n) { switch (n.kind) { case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: { + case 158 /* PropertyAccessExpression */: { var symbol = findSymbol(n); return symbol && (symbol.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 8192 /* Const */) !== 0; } - case 157 /* ElementAccessExpression */: { + case 159 /* ElementAccessExpression */: { var index = n.argumentExpression; var symbol = findSymbol(n.expression); if (symbol && index && index.kind === 8 /* StringLiteral */) { @@ -18896,7 +19410,7 @@ var ts; } return false; } - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return isConstVariableReference(n.expression); default: return false; @@ -18913,13 +19427,7 @@ var ts; return true; } function checkDeleteExpression(node) { - // Grammar checking - if (node.parserContextFlags & 1 /* StrictMode */ && node.expression.kind === 65 /* 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(node.expression, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode); - } - var operandType = checkExpression(node.expression); + checkExpression(node.expression); return booleanType; } function checkTypeOfExpression(node) { @@ -18931,13 +19439,6 @@ var ts; return undefinedType; } function checkPrefixUnaryExpression(node) { - // Grammar checking - // 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 ((node.operator === 38 /* PlusPlusToken */ || node.operator === 39 /* MinusMinusToken */)) { - checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); - } var operandType = checkExpression(node.operand); switch (node.operator) { case 33 /* PlusToken */: @@ -18961,11 +19462,6 @@ var ts; return unknownType; } function checkPostfixUnaryExpression(node) { - // Grammar checking - // 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. - checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); var operandType = checkExpression(node.operand); var ok = checkArithmeticOperandType(node.operand, operandType, ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type); if (ok) { @@ -19047,7 +19543,7 @@ var ts; var properties = node.properties; for (var _i = 0; _i < properties.length; _i++) { var p = properties[_i]; - if (p.kind === 225 /* PropertyAssignment */ || p.kind === 226 /* ShorthandPropertyAssignment */) { + if (p.kind === 227 /* PropertyAssignment */ || p.kind === 228 /* ShorthandPropertyAssignment */) { // TODO(andersh): Computed property support var name_12 = p.name; var type = isTypeAny(sourceType) @@ -19076,8 +19572,8 @@ var ts; var elements = node.elements; for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176 /* OmittedExpression */) { - if (e.kind !== 174 /* SpreadElementExpression */) { + if (e.kind !== 178 /* OmittedExpression */) { + if (e.kind !== 176 /* SpreadElementExpression */) { var propName = "" + i; var type = isTypeAny(sourceType) ? sourceType @@ -19102,7 +19598,7 @@ var ts; } else { var restExpression = e.expression; - if (restExpression.kind === 170 /* BinaryExpression */ && restExpression.operatorToken.kind === 53 /* EqualsToken */) { + if (restExpression.kind === 172 /* BinaryExpression */ && restExpression.operatorToken.kind === 53 /* EqualsToken */) { error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } else { @@ -19115,14 +19611,14 @@ var ts; return sourceType; } function checkDestructuringAssignment(target, sourceType, contextualMapper) { - if (target.kind === 170 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { + if (target.kind === 172 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { checkBinaryExpression(target, contextualMapper); target = target.left; } - if (target.kind === 155 /* ObjectLiteralExpression */) { + if (target.kind === 157 /* ObjectLiteralExpression */) { return checkObjectLiteralAssignment(target, sourceType, contextualMapper); } - if (target.kind === 154 /* ArrayLiteralExpression */) { + if (target.kind === 156 /* ArrayLiteralExpression */) { return checkArrayLiteralAssignment(target, sourceType, contextualMapper); } return checkReferenceAssignment(target, sourceType, contextualMapper); @@ -19135,14 +19631,8 @@ var ts; return sourceType; } function checkBinaryExpression(node, contextualMapper) { - // Grammar checking - if (ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { - // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an - // Assignment operator(11.13) or of a PostfixExpression(11.3) - checkGrammarEvalOrArgumentsInStrictMode(node, node.left); - } var operator = node.operatorToken.kind; - if (operator === 53 /* EqualsToken */ && (node.left.kind === 155 /* ObjectLiteralExpression */ || node.left.kind === 154 /* ArrayLiteralExpression */)) { + if (operator === 53 /* EqualsToken */ && (node.left.kind === 157 /* ObjectLiteralExpression */ || node.left.kind === 156 /* ArrayLiteralExpression */)) { return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); } var leftType = checkExpression(node.left, contextualMapper); @@ -19317,7 +19807,7 @@ var ts; if (ts.isFunctionLike(parent) && current === parent.body) { return false; } - else if (current.kind === 202 /* ClassDeclaration */ || current.kind === 175 /* ClassExpression */) { + else if (current.kind === 204 /* ClassDeclaration */ || current.kind === 177 /* ClassExpression */) { return true; } current = parent; @@ -19393,7 +19883,7 @@ var ts; // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { checkComputedPropertyName(node.name); } return checkExpression(node.initializer, contextualMapper); @@ -19404,7 +19894,7 @@ var ts; // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { checkComputedPropertyName(node.name); } var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); @@ -19425,10 +19915,6 @@ var ts; } return type; } - function checkExpression(node, contextualMapper) { - checkGrammarIdentifierInStrictMode(node); - return checkExpressionOrQualifiedName(node, contextualMapper); - } // Checks an expression and returns its type. The contextualMapper parameter serves two purposes: When // contextualMapper is not undefined and not equal to the identityMapper function object it indicates that the // expression is being inferentially typed (section 4.12.2 in spec) and provides the type mapper to use in @@ -19436,9 +19922,9 @@ var ts; // object, it serves as an indicator that all contained function and arrow expressions should be considered to // have the wildcard function type; this form of type check is used during overload resolution to exclude // contextually typed function and arrow expressions in the initial phase. - function checkExpressionOrQualifiedName(node, contextualMapper) { + function checkExpression(node, contextualMapper) { var type; - if (node.kind == 127 /* QualifiedName */) { + if (node.kind === 128 /* QualifiedName */) { type = checkQualifiedName(node); } else { @@ -19450,9 +19936,9 @@ var ts; // - 'left' in property access // - 'object' in indexed access // - target in rhs of import statement - var ok = (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.expression === node) || - (node.parent.kind === 157 /* ElementAccessExpression */ && node.parent.expression === node) || - ((node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */) && isInRightSideOfImportOrExportAssignment(node)); + var ok = (node.parent.kind === 158 /* PropertyAccessExpression */ && node.parent.expression === node) || + (node.parent.kind === 159 /* ElementAccessExpression */ && node.parent.expression === node) || + ((node.kind === 65 /* Identifier */ || node.kind === 128 /* QualifiedName */) && isInRightSideOfImportOrExportAssignment(node)); if (!ok) { error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment); } @@ -19479,61 +19965,60 @@ var ts; return booleanType; case 7 /* NumericLiteral */: return checkNumericLiteral(node); - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: return checkTemplateExpression(node); case 8 /* StringLiteral */: case 10 /* NoSubstitutionTemplateLiteral */: return stringType; case 9 /* RegularExpressionLiteral */: return globalRegExpType; - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return checkArrayLiteral(node, contextualMapper); - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return checkObjectLiteral(node, contextualMapper); - case 156 /* PropertyAccessExpression */: + case 158 /* PropertyAccessExpression */: return checkPropertyAccessExpression(node); - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: return checkIndexedAccess(node); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return checkCallExpression(node); - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: return checkTaggedTemplateExpression(node); - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return checkTypeAssertion(node); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return checkExpression(node.expression, contextualMapper); - case 175 /* ClassExpression */: + case 177 /* ClassExpression */: return checkClassExpression(node); - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); - case 166 /* TypeOfExpression */: + case 168 /* TypeOfExpression */: return checkTypeOfExpression(node); - case 165 /* DeleteExpression */: + case 167 /* DeleteExpression */: return checkDeleteExpression(node); - case 167 /* VoidExpression */: + case 169 /* VoidExpression */: return checkVoidExpression(node); - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: return checkPrefixUnaryExpression(node); - case 169 /* PostfixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: return checkPostfixUnaryExpression(node); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return checkBinaryExpression(node, contextualMapper); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return checkConditionalExpression(node, contextualMapper); - case 174 /* SpreadElementExpression */: + case 176 /* SpreadElementExpression */: return checkSpreadElementExpression(node, contextualMapper); - case 176 /* OmittedExpression */: + case 178 /* OmittedExpression */: return undefinedType; - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: return checkYieldExpression(node); } return unknownType; } // DECLARATION AND STATEMENT TYPE CHECKING function checkTypeParameter(node) { - checkGrammarDeclarationNameInStrictMode(node); // Grammar Checking if (node.expression) { grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected); @@ -19550,15 +20035,13 @@ var ts; // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code // or if its FunctionBody is strict code(11.1.5). - // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a - // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) // Grammar checking - checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + checkGrammarDecorators(node) || checkGrammarModifiers(node); checkVariableLikeDeclaration(node); var func = ts.getContainingFunction(node); if (node.flags & 112 /* AccessibilityModifier */) { func = ts.getContainingFunction(node); - if (!(func.kind === 136 /* Constructor */ && ts.nodeIsPresent(func.body))) { + if (!(func.kind === 137 /* Constructor */ && ts.nodeIsPresent(func.body))) { error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } @@ -19575,33 +20058,107 @@ var ts; if (!node.asteriskToken || !node.body) { return false; } - return node.kind === 135 /* MethodDeclaration */ || - node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */; + return node.kind === 136 /* MethodDeclaration */ || + node.kind === 203 /* FunctionDeclaration */ || + node.kind === 165 /* FunctionExpression */; + } + function getTypePredicateParameterIndex(parameterList, parameter) { + if (parameterList) { + for (var i = 0; i < parameterList.length; i++) { + var param = parameterList[i]; + if (param.name.kind === 65 /* Identifier */ && + param.name.text === parameter.text) { + return i; + } + } + } + return -1; + } + function isInLegalTypePredicatePosition(node) { + switch (node.parent.kind) { + case 166 /* ArrowFunction */: + case 140 /* CallSignature */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 145 /* FunctionType */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + return node === node.parent.type; + } + return false; } function checkSignatureDeclaration(node) { // Grammar checking - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 142 /* IndexSignature */) { checkGrammarIndexSignature(node); } - else if (node.kind === 143 /* FunctionType */ || node.kind === 201 /* FunctionDeclaration */ || node.kind === 144 /* ConstructorType */ || - node.kind === 139 /* CallSignature */ || node.kind === 136 /* Constructor */ || - node.kind === 140 /* ConstructSignature */) { + else if (node.kind === 145 /* FunctionType */ || node.kind === 203 /* FunctionDeclaration */ || node.kind === 146 /* ConstructorType */ || + node.kind === 140 /* CallSignature */ || node.kind === 137 /* Constructor */ || + node.kind === 141 /* ConstructSignature */) { checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); ts.forEach(node.parameters, checkParameter); if (node.type) { - checkSourceElement(node.type); + if (node.type.kind === 143 /* TypePredicate */) { + var typePredicate = getSignatureFromDeclaration(node).typePredicate; + var typePredicateNode = node.type; + if (isInLegalTypePredicatePosition(typePredicateNode)) { + if (typePredicate.parameterIndex >= 0) { + if (node.parameters[typePredicate.parameterIndex].dotDotDotToken) { + error(typePredicateNode.parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter); + } + else { + checkTypeAssignableTo(typePredicate.type, getTypeAtLocation(node.parameters[typePredicate.parameterIndex]), typePredicateNode.type); + } + } + else if (typePredicateNode.parameterName) { + var hasReportedError = false; + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var param = _a[_i]; + if (hasReportedError) { + break; + } + if (param.name.kind === 153 /* ObjectBindingPattern */ || + param.name.kind === 154 /* ArrayBindingPattern */) { + (function checkBindingPattern(pattern) { + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (element.name.kind === 65 /* Identifier */ && + element.name.text === typePredicate.parameterName) { + error(typePredicateNode.parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, typePredicate.parameterName); + hasReportedError = true; + break; + } + else if (element.name.kind === 154 /* ArrayBindingPattern */ || + element.name.kind === 153 /* ObjectBindingPattern */) { + checkBindingPattern(element.name); + } + } + })(param.name); + } + } + if (!hasReportedError) { + error(typePredicateNode.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName); + } + } + } + else { + error(typePredicateNode, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + } + } + else { + checkSourceElement(node.type); + } } if (produceDiagnostics) { checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; - case 139 /* CallSignature */: + case 140 /* CallSignature */: error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; } @@ -19629,7 +20186,7 @@ var ts; checkSpecializedSignatureDeclaration(node); } function checkTypeForDuplicateIndexSignatures(node) { - if (node.kind === 203 /* InterfaceDeclaration */) { + if (node.kind === 205 /* InterfaceDeclaration */) { var nodeSymbol = getSymbolOfNode(node); // in case of merging interface declaration it is possible that we'll enter this check procedure several times for every declaration // to prevent this run check only for the first declaration of a given kind @@ -19649,7 +20206,7 @@ var ts; var declaration = decl; if (declaration.parameters.length === 1 && declaration.parameters[0].type) { switch (declaration.parameters[0].type.kind) { - case 122 /* StringKeyword */: + case 123 /* StringKeyword */: if (!seenStringIndexer) { seenStringIndexer = true; } @@ -19657,7 +20214,7 @@ var ts; error(declaration, ts.Diagnostics.Duplicate_string_index_signature); } break; - case 120 /* NumberKeyword */: + case 121 /* NumberKeyword */: if (!seenNumericIndexer) { seenNumericIndexer = true; } @@ -19701,17 +20258,17 @@ var ts; return; } function isSuperCallExpression(n) { - return n.kind === 158 /* CallExpression */ && n.expression.kind === 91 /* SuperKeyword */; + return n.kind === 160 /* CallExpression */ && n.expression.kind === 91 /* SuperKeyword */; } function containsSuperCall(n) { if (isSuperCallExpression(n)) { return true; } switch (n.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 155 /* ObjectLiteralExpression */: return false; + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: + case 157 /* ObjectLiteralExpression */: return false; default: return ts.forEachChild(n, containsSuperCall); } } @@ -19719,12 +20276,12 @@ var ts; if (n.kind === 93 /* ThisKeyword */) { error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); } - else if (n.kind !== 163 /* FunctionExpression */ && n.kind !== 201 /* FunctionDeclaration */) { + else if (n.kind !== 165 /* FunctionExpression */ && n.kind !== 203 /* FunctionDeclaration */) { ts.forEachChild(n, markThisReferencesAsErrors); } } function isInstancePropertyWithInitializer(n) { - return n.kind === 133 /* PropertyDeclaration */ && + return n.kind === 134 /* PropertyDeclaration */ && !(n.flags & 128 /* Static */) && !!n.initializer; } @@ -19741,7 +20298,7 @@ var ts; ts.forEach(node.parameters, function (p) { return p.flags & (16 /* Public */ | 32 /* Private */ | 64 /* Protected */); }); if (superCallShouldBeFirst) { var statements = node.body.statements; - if (!statements.length || statements[0].kind !== 183 /* ExpressionStatement */ || !isSuperCallExpression(statements[0].expression)) { + if (!statements.length || statements[0].kind !== 185 /* ExpressionStatement */ || !isSuperCallExpression(statements[0].expression)) { error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties); } else { @@ -19759,7 +20316,7 @@ var ts; if (produceDiagnostics) { // Grammar checking accessors checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); - if (node.kind === 137 /* GetAccessor */) { + if (node.kind === 138 /* GetAccessor */) { if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) { error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement); } @@ -19767,7 +20324,7 @@ var ts; if (!ts.hasDynamicName(node)) { // TypeScript 1.0 spec (April 2014): 8.4.3 // Accessors for the same member name must specify the same accessibility. - var otherKind = node.kind === 137 /* GetAccessor */ ? 138 /* SetAccessor */ : 137 /* GetAccessor */; + var otherKind = node.kind === 138 /* GetAccessor */ ? 139 /* SetAccessor */ : 138 /* GetAccessor */; var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); if (otherAccessor) { if (((node.flags & 112 /* AccessibilityModifier */) !== (otherAccessor.flags & 112 /* AccessibilityModifier */))) { @@ -19791,28 +20348,27 @@ var ts; function checkMissingDeclaration(node) { checkDecorators(node); } + function checkTypeArgumentConstraints(typeParameters, typeArguments) { + var result = true; + for (var i = 0; i < typeParameters.length; i++) { + var constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + var typeArgument = typeArguments[i]; + result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + } + } + return result; + } function checkTypeReferenceNode(node) { - checkGrammarTypeReferenceInStrictMode(node.typeName); - return checkTypeReferenceOrExpressionWithTypeArguments(node); - } - function checkExpressionWithTypeArguments(node) { - checkGrammarExpressionWithTypeArgumentsInStrictMode(node.expression); - return checkTypeReferenceOrExpressionWithTypeArguments(node); - } - function checkTypeReferenceOrExpressionWithTypeArguments(node) { - // Grammar checking checkGrammarTypeArguments(node, node.typeArguments); - var type = getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); + var type = getTypeFromTypeReference(node); if (type !== unknownType && node.typeArguments) { // Do type argument local checks only if referenced type is successfully resolved - var len = node.typeArguments.length; - for (var i = 0; i < len; i++) { - checkSourceElement(node.typeArguments[i]); - var constraint = getConstraintOfTypeParameter(type.target.typeParameters[i]); - if (produceDiagnostics && constraint) { - var typeArgument = type.typeArguments[i]; - checkTypeAssignableTo(typeArgument, constraint, node, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); - } + ts.forEach(node.typeArguments, checkSourceElement); + if (produceDiagnostics) { + var symbol = getNodeLinks(node).resolvedSymbol; + var typeParameters = symbol.flags & 524288 /* TypeAlias */ ? getSymbolLinks(symbol).typeParameters : type.target.localTypeParameters; + checkTypeArgumentConstraints(typeParameters, node.typeArguments); } } } @@ -19864,9 +20420,9 @@ var ts; var signaturesToCheck; // Unnamed (call\construct) signatures in interfaces are inherited and not shadowed so examining just node symbol won't give complete answer. // Use declaring type to obtain full list of signatures. - if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 203 /* InterfaceDeclaration */) { - ts.Debug.assert(signatureDeclarationNode.kind === 139 /* CallSignature */ || signatureDeclarationNode.kind === 140 /* ConstructSignature */); - var signatureKind = signatureDeclarationNode.kind === 139 /* CallSignature */ ? 0 /* Call */ : 1 /* Construct */; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 205 /* InterfaceDeclaration */) { + ts.Debug.assert(signatureDeclarationNode.kind === 140 /* CallSignature */ || signatureDeclarationNode.kind === 141 /* ConstructSignature */); + var signatureKind = signatureDeclarationNode.kind === 140 /* CallSignature */ ? 0 /* Call */ : 1 /* Construct */; var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); var containingType = getDeclaredTypeOfSymbol(containingSymbol); signaturesToCheck = getSignaturesOfType(containingType, signatureKind); @@ -19884,7 +20440,7 @@ var ts; } function getEffectiveDeclarationFlags(n, flagsToCheck) { var flags = ts.getCombinedNodeFlags(n); - if (n.parent.kind !== 203 /* InterfaceDeclaration */ && ts.isInAmbientContext(n)) { + if (n.parent.kind !== 205 /* InterfaceDeclaration */ && ts.isInAmbientContext(n)) { if (!(flags & 2 /* Ambient */)) { // It is nested in an ambient context, which means it is automatically exported flags |= 1 /* Export */; @@ -19967,7 +20523,7 @@ var ts; // TODO(jfreeman): These are methods, so handle computed name case if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { // the only situation when this is possible (same kind\same name but different symbol) - mixed static and instance class members - ts.Debug.assert(node.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */); + ts.Debug.assert(node.kind === 136 /* MethodDeclaration */ || node.kind === 135 /* MethodSignature */); ts.Debug.assert((node.flags & 128 /* Static */) !== (subsequentNode.flags & 128 /* Static */)); var diagnostic = node.flags & 128 /* Static */ ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static; error(errorNode_1, diagnostic); @@ -19996,7 +20552,7 @@ var ts; var current = declarations[_i]; var node = current; var inAmbientContext = ts.isInAmbientContext(node); - var inAmbientContextOrInterface = node.parent.kind === 203 /* InterfaceDeclaration */ || node.parent.kind === 146 /* TypeLiteral */ || inAmbientContext; + var inAmbientContextOrInterface = node.parent.kind === 205 /* InterfaceDeclaration */ || node.parent.kind === 148 /* TypeLiteral */ || inAmbientContext; if (inAmbientContextOrInterface) { // check if declarations are consecutive only if they are non-ambient // 1. ambient declarations can be interleaved @@ -20007,7 +20563,7 @@ var ts; // 2. mixing ambient and non-ambient declarations is a separate error that will be reported - do not want to report an extra one previousDeclaration = undefined; } - if (node.kind === 201 /* FunctionDeclaration */ || node.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */ || node.kind === 136 /* Constructor */) { + if (node.kind === 203 /* FunctionDeclaration */ || node.kind === 136 /* MethodDeclaration */ || node.kind === 135 /* MethodSignature */ || node.kind === 137 /* Constructor */) { var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); someNodeFlags |= currentNodeFlags; allNodeFlags &= currentNodeFlags; @@ -20130,16 +20686,16 @@ var ts; } function getDeclarationSpaces(d) { switch (d.kind) { - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return 2097152 /* ExportType */; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return d.name.kind === 8 /* StringLiteral */ || ts.getModuleInstanceState(d) !== 0 /* NonInstantiated */ ? 4194304 /* ExportNamespace */ | 1048576 /* ExportValue */ : 4194304 /* ExportNamespace */; - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: return 2097152 /* ExportType */ | 1048576 /* ExportValue */; - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: var result = 0; var target = resolveAlias(getSymbolOfNode(d)); ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); @@ -20154,23 +20710,23 @@ var ts; var expression = node.expression; var exprType = checkExpression(expression); switch (node.parent.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); checkTypeAssignableTo(exprType, classDecoratorType, node); break; - case 133 /* PropertyDeclaration */: + case 134 /* PropertyDeclaration */: checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); break; - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: var methodType = getTypeOfNode(node.parent); var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); checkTypeAssignableTo(exprType, methodDecoratorType, node); break; - case 130 /* Parameter */: + case 131 /* Parameter */: checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); break; } @@ -20180,14 +20736,14 @@ var ts; // When we are emitting type metadata for decorators, we need to try to check the type // as if it were an expression so that we can emit the type in a value position when we // serialize the type metadata. - if (node && node.kind === 142 /* TypeReference */) { + if (node && node.kind === 144 /* TypeReference */) { var type = getTypeFromTypeNode(node); var shouldCheckIfUnknownType = type === unknownType && compilerOptions.isolatedModules; if (!type || (!shouldCheckIfUnknownType && type.flags & (2097279 /* Intrinsic */ | 132 /* NumberLike */ | 258 /* StringLike */))) { return; } if (shouldCheckIfUnknownType || type.symbol.valueDeclaration) { - checkExpressionOrQualifiedName(node.typeName); + checkExpression(node.typeName); } } } @@ -20197,19 +20753,19 @@ var ts; */ function checkTypeAnnotationAsExpression(node) { switch (node.kind) { - case 133 /* PropertyDeclaration */: + case 134 /* PropertyDeclaration */: checkTypeNodeAsExpression(node.type); break; - case 130 /* Parameter */: + case 131 /* Parameter */: checkTypeNodeAsExpression(node.type); break; - case 135 /* MethodDeclaration */: + case 136 /* MethodDeclaration */: checkTypeNodeAsExpression(node.type); break; - case 137 /* GetAccessor */: + case 138 /* GetAccessor */: checkTypeNodeAsExpression(node.type); break; - case 138 /* SetAccessor */: + case 139 /* SetAccessor */: checkTypeNodeAsExpression(getSetAccessorTypeAnnotationNode(node)); break; } @@ -20238,47 +20794,44 @@ var ts; if (compilerOptions.emitDecoratorMetadata) { // we only need to perform these checks if we are emitting serialized type metadata for the target of a decorator. switch (node.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: var constructor = ts.getFirstConstructorWithBody(node); if (constructor) { checkParameterTypeAnnotationsAsExpressions(constructor); } break; - case 135 /* MethodDeclaration */: + case 136 /* MethodDeclaration */: checkParameterTypeAnnotationsAsExpressions(node); // fall-through - case 138 /* SetAccessor */: - case 137 /* GetAccessor */: - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 139 /* SetAccessor */: + case 138 /* GetAccessor */: + case 134 /* PropertyDeclaration */: + case 131 /* Parameter */: checkTypeAnnotationAsExpression(node); break; } } emitDecorate = true; - if (node.kind === 130 /* Parameter */) { + if (node.kind === 131 /* Parameter */) { emitParam = true; } ts.forEach(node.decorators, checkDecorator); } function checkFunctionDeclaration(node) { if (produceDiagnostics) { - checkFunctionLikeDeclaration(node) || - checkGrammarFunctionName(node.name) || - checkGrammarForGenerator(node); + checkFunctionLikeDeclaration(node) || checkGrammarForGenerator(node); checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); } } function checkFunctionLikeDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSignatureDeclaration(node); // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name && node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name && node.name.kind === 129 /* ComputedPropertyName */) { // This check will account for methods in class/interface declarations, // as well as accessors in classes/object literals checkComputedPropertyName(node.name); @@ -20322,11 +20875,11 @@ var ts; } function checkBlock(node) { // Grammar checking for SyntaxKind.Block - if (node.kind === 180 /* Block */) { + if (node.kind === 182 /* Block */) { checkGrammarStatementInAmbientContext(node); } ts.forEach(node.statements, checkSourceElement); - if (ts.isFunctionBlock(node) || node.kind === 207 /* ModuleBlock */) { + if (ts.isFunctionBlock(node) || node.kind === 209 /* ModuleBlock */) { checkFunctionExpressionBodies(node); } } @@ -20345,12 +20898,12 @@ var ts; if (!(identifier && identifier.text === name)) { return false; } - if (node.kind === 133 /* PropertyDeclaration */ || - node.kind === 132 /* PropertySignature */ || - node.kind === 135 /* MethodDeclaration */ || - node.kind === 134 /* MethodSignature */ || - node.kind === 137 /* GetAccessor */ || - node.kind === 138 /* SetAccessor */) { + if (node.kind === 134 /* PropertyDeclaration */ || + node.kind === 133 /* PropertySignature */ || + node.kind === 136 /* MethodDeclaration */ || + node.kind === 135 /* MethodSignature */ || + node.kind === 138 /* GetAccessor */ || + node.kind === 139 /* SetAccessor */) { // it is ok to have member named '_super' or '_this' - member access is always qualified return false; } @@ -20359,7 +20912,7 @@ var ts; return false; } var root = ts.getRootDeclaration(node); - if (root.kind === 130 /* Parameter */ && ts.nodeIsMissing(root.parent.body)) { + if (root.kind === 131 /* Parameter */ && ts.nodeIsMissing(root.parent.body)) { // just an overload - no codegen impact return false; } @@ -20392,7 +20945,7 @@ var ts; return; } // bubble up and find containing type - var enclosingClass = ts.getAncestor(node, 202 /* ClassDeclaration */); + var enclosingClass = ts.getAncestor(node, 204 /* ClassDeclaration */); // if containing type was not found or it is ambient - exit (no codegen) if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; @@ -20412,12 +20965,12 @@ var ts; return; } // Uninstantiated modules shouldnt do this check - if (node.kind === 206 /* ModuleDeclaration */ && ts.getModuleInstanceState(node) !== 1 /* Instantiated */) { + if (node.kind === 208 /* ModuleDeclaration */ && ts.getModuleInstanceState(node) !== 1 /* Instantiated */) { return; } // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent var parent = getDeclarationContainer(node); - if (parent.kind === 228 /* SourceFile */ && ts.isExternalModule(parent)) { + if (parent.kind === 230 /* SourceFile */ && ts.isExternalModule(parent)) { // If the declaration happens to be in external module, report error that require and exports are reserved keywords error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); } @@ -20452,7 +21005,7 @@ var ts; // skip variable declarations that don't have initializers // NOTE: in ES6 spec initializer is required in variable declarations where name is binding pattern // so we'll always treat binding elements as initialized - if (node.kind === 199 /* VariableDeclaration */ && !node.initializer) { + if (node.kind === 201 /* VariableDeclaration */ && !node.initializer) { return; } var symbol = getSymbolOfNode(node); @@ -20462,17 +21015,17 @@ var ts; localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2 /* BlockScopedVariable */) { if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 12288 /* BlockScoped */) { - var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 200 /* VariableDeclarationList */); - var container = varDeclList.parent.kind === 181 /* VariableStatement */ && varDeclList.parent.parent + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 202 /* VariableDeclarationList */); + var container = varDeclList.parent.kind === 183 /* VariableStatement */ && varDeclList.parent.parent ? varDeclList.parent.parent : undefined; // names of block-scoped and function scoped variables can collide only // if block scoped variable is defined in the function\module\source file scope (because of variable hoisting) var namesShareScope = container && - (container.kind === 180 /* Block */ && ts.isFunctionLike(container.parent) || - container.kind === 207 /* ModuleBlock */ || - container.kind === 206 /* ModuleDeclaration */ || - container.kind === 228 /* SourceFile */); + (container.kind === 182 /* Block */ && ts.isFunctionLike(container.parent) || + container.kind === 209 /* ModuleBlock */ || + container.kind === 208 /* ModuleDeclaration */ || + container.kind === 230 /* SourceFile */); // here we know that function scoped variable is shadowed by block scoped one // if they are defined in the same scope - binder has already reported redeclaration error // otherwise if variable has an initializer - show error that initialization will fail @@ -20487,7 +21040,7 @@ var ts; } // Check that a parameter initializer contains no references to parameters declared to the right of itself function checkParameterInitializer(node) { - if (ts.getRootDeclaration(node).kind !== 130 /* Parameter */) { + if (ts.getRootDeclaration(node).kind !== 131 /* Parameter */) { return; } var func = ts.getContainingFunction(node); @@ -20498,7 +21051,7 @@ var ts; // check FunctionLikeDeclaration.locals (stores parameters\function local variable) // if it contains entry with a specified name and if this entry matches the resolved symbol if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455 /* Value */) === referencedSymbol) { - if (referencedSymbol.valueDeclaration.kind === 130 /* Parameter */) { + if (referencedSymbol.valueDeclaration.kind === 131 /* Parameter */) { if (referencedSymbol.valueDeclaration === node) { error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); return; @@ -20518,14 +21071,13 @@ var ts; } // Check variable, parameter, or property declaration function checkVariableLikeDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSourceElement(node.type); // For a computed property, just check the initializer and exit // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { checkComputedPropertyName(node.name); if (node.initializer) { checkExpressionCached(node.initializer); @@ -20536,7 +21088,7 @@ var ts; ts.forEach(node.name.elements, checkSourceElement); } // For a parameter declaration with an initializer, error and exit if the containing function doesn't have a body - if (node.initializer && ts.getRootDeclaration(node).kind === 130 /* Parameter */ && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + if (node.initializer && ts.getRootDeclaration(node).kind === 131 /* Parameter */ && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); return; } @@ -20568,10 +21120,10 @@ var ts; checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); } } - if (node.kind !== 133 /* PropertyDeclaration */ && node.kind !== 132 /* PropertySignature */) { + if (node.kind !== 134 /* PropertyDeclaration */ && node.kind !== 133 /* PropertySignature */) { // We know we don't have a binding pattern or computed name here checkExportsOnMergedDeclarations(node); - if (node.kind === 199 /* VariableDeclaration */ || node.kind === 153 /* BindingElement */) { + if (node.kind === 201 /* VariableDeclaration */ || node.kind === 155 /* BindingElement */) { checkVarDeclaredNamesNotShadowed(node); } checkCollisionWithCapturedSuperVariable(node, node.name); @@ -20601,7 +21153,7 @@ var ts; } function inBlockOrObjectLiteralExpression(node) { while (node) { - if (node.kind === 180 /* Block */ || node.kind === 155 /* ObjectLiteralExpression */) { + if (node.kind === 182 /* Block */ || node.kind === 157 /* ObjectLiteralExpression */) { return true; } node = node.parent; @@ -20634,12 +21186,12 @@ var ts; function checkForStatement(node) { // Grammar checking if (!checkGrammarStatementInAmbientContext(node)) { - if (node.initializer && node.initializer.kind == 200 /* VariableDeclarationList */) { + if (node.initializer && node.initializer.kind === 202 /* VariableDeclarationList */) { checkGrammarVariableDeclarationList(node.initializer); } } if (node.initializer) { - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { ts.forEach(node.initializer.declarations, checkVariableDeclaration); } else { @@ -20659,14 +21211,14 @@ var ts; // via checkRightHandSideOfForOf. // If the LHS is an expression, check the LHS, as a destructuring assignment or as a reference. // Then check that the RHS is assignable to it. - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { checkForInOrForOfVariableDeclaration(node); } else { var varExpr = node.initializer; var iteratedType = checkRightHandSideOfForOf(node.expression); // There may be a destructuring assignment on the left side - if (varExpr.kind === 154 /* ArrayLiteralExpression */ || varExpr.kind === 155 /* ObjectLiteralExpression */) { + if (varExpr.kind === 156 /* ArrayLiteralExpression */ || varExpr.kind === 157 /* ObjectLiteralExpression */) { // iteratedType may be undefined. In this case, we still want to check the structure of // varExpr, in particular making sure it's a valid LeftHandSideExpression. But we'd like // to short circuit the type relation checking as much as possible, so we pass the unknownType. @@ -20695,7 +21247,7 @@ var ts; // for (let VarDecl in Expr) Statement // VarDecl must be a variable declaration without a type annotation that declares a variable of type Any, // and Expr must be an expression of type Any, an object type, or a type parameter type. - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { var variable = node.initializer.declarations[0]; if (variable && ts.isBindingPattern(variable.name)) { error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); @@ -20709,7 +21261,7 @@ var ts; // and Expr must be an expression of type Any, an object type, or a type parameter type. var varExpr = node.initializer; var leftType = checkExpression(varExpr); - if (varExpr.kind === 154 /* ArrayLiteralExpression */ || varExpr.kind === 155 /* ObjectLiteralExpression */) { + if (varExpr.kind === 156 /* ArrayLiteralExpression */ || varExpr.kind === 157 /* ObjectLiteralExpression */) { error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); } else if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, 258 /* StringLike */)) { @@ -20948,7 +21500,7 @@ var ts; // TODO: Check that target label is valid } function isGetAccessorWithAnnotatatedSetAccessor(node) { - return !!(node.kind === 137 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 138 /* SetAccessor */))); + return !!(node.kind === 138 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 139 /* SetAccessor */))); } function checkReturnStatement(node) { // Grammar checking @@ -20961,7 +21513,8 @@ var ts; if (node.expression) { var func = ts.getContainingFunction(node); if (func) { - var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); + var signature = getSignatureFromDeclaration(func); + var returnType = getReturnTypeOfSignature(signature); var exprType = checkExpressionCached(node.expression); if (func.asteriskToken) { // A generator does not need its return expressions checked against its return type. @@ -20970,27 +21523,22 @@ var ts; // for generators. return; } - if (func.kind === 138 /* SetAccessor */) { + if (func.kind === 139 /* SetAccessor */) { error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); } - else if (func.kind === 136 /* Constructor */) { + else if (func.kind === 137 /* Constructor */) { if (!isTypeAssignableTo(exprType, returnType)) { error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } } - else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) { + else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) { checkTypeAssignableTo(exprType, returnType, node.expression, undefined); } } } } function checkWithStatement(node) { - // Grammar checking for withStatement - if (!checkGrammarStatementInAmbientContext(node)) { - if (node.parserContextFlags & 1 /* StrictMode */) { - grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); - } - } + checkGrammarStatementInAmbientContext(node); checkExpression(node.expression); error(node.expression, ts.Diagnostics.All_symbols_within_a_with_block_will_be_resolved_to_any); } @@ -21002,7 +21550,7 @@ var ts; var expressionType = checkExpression(node.expression); ts.forEach(node.caseBlock.clauses, function (clause) { // Grammar check for duplicate default clauses, skip if we already report duplicate default clause - if (clause.kind === 222 /* DefaultClause */ && !hasDuplicateDefaultClause) { + if (clause.kind === 224 /* DefaultClause */ && !hasDuplicateDefaultClause) { if (firstDefaultClause === undefined) { firstDefaultClause = clause; } @@ -21014,7 +21562,7 @@ var ts; hasDuplicateDefaultClause = true; } } - if (produceDiagnostics && clause.kind === 221 /* CaseClause */) { + if (produceDiagnostics && clause.kind === 223 /* CaseClause */) { var caseClause = clause; // TypeScript 1.0 spec (April 2014):5.9 // In a 'switch' statement, each 'case' expression must be of a type that is assignable to or from the type of the 'switch' expression. @@ -21035,7 +21583,7 @@ var ts; if (ts.isFunctionLike(current)) { break; } - if (current.kind === 195 /* LabeledStatement */ && current.label.text === node.label.text) { + if (current.kind === 197 /* LabeledStatement */ && current.label.text === node.label.text) { var sourceFile = ts.getSourceFileOfNode(node); grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNodeFromSourceText(sourceFile.text, node.label)); break; @@ -21083,9 +21631,6 @@ var ts; grammarErrorOnNode(localSymbol.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, identifierName); } } - // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the - // Catch production is eval or arguments - checkGrammarEvalOrArgumentsInStrictMode(node, catchClause.variableDeclaration.name); } } checkBlock(catchClause.block); @@ -21105,7 +21650,7 @@ var ts; checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */); checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */); }); - if (type.flags & 1024 /* Class */ && type.symbol.valueDeclaration.kind === 202 /* ClassDeclaration */) { + if (type.flags & 1024 /* Class */ && type.symbol.valueDeclaration.kind === 204 /* ClassDeclaration */) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; @@ -21143,7 +21688,7 @@ var ts; // perform property check if property or indexer is declared in 'type' // this allows to rule out cases when both property and indexer are inherited from the base class var errorNode; - if (prop.valueDeclaration.name.kind === 128 /* ComputedPropertyName */ || prop.parent === containingType.symbol) { + if (prop.valueDeclaration.name.kind === 129 /* ComputedPropertyName */ || prop.parent === containingType.symbol) { errorNode = prop.valueDeclaration; } else if (indexDeclaration) { @@ -21199,7 +21744,6 @@ var ts; return unknownType; } function checkClassDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); // Grammar checking if (!node.name && !(node.flags & 256 /* Default */)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); @@ -21218,36 +21762,42 @@ var ts; var staticType = getTypeOfSymbol(symbol); var baseTypeNode = ts.getClassExtendsHeritageClauseElement(node); if (baseTypeNode) { - if (!ts.isSupportedExpressionWithTypeArguments(baseTypeNode)) { - error(baseTypeNode.expression, ts.Diagnostics.Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses); - } emitExtends = emitExtends || !ts.isInAmbientContext(node); - checkExpressionWithTypeArguments(baseTypeNode); - } - var baseTypes = getBaseTypes(type); - if (baseTypes.length) { - if (produceDiagnostics) { + var baseTypes = getBaseTypes(type); + if (baseTypes.length && produceDiagnostics) { var baseType = baseTypes[0]; + var staticBaseType = getBaseConstructorTypeOfClass(type); + if (baseTypeNode.typeArguments) { + ts.forEach(baseTypeNode.typeArguments, checkSourceElement); + for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); _i < _a.length; _i++) { + var constructor = _a[_i]; + if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) { + break; + } + } + } checkTypeAssignableTo(type, baseType, node.name || node, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1); - var staticBaseType = getTypeOfSymbol(baseType.symbol); - checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); - if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, 107455 /* Value */)) { - error(baseTypeNode, ts.Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType)); + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); + if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32 /* Class */)) { + // When the static base type is a "class-like" constructor function (but not actually a class), we verify + // that all instantiated base constructor signatures return the same type. We can simply compare the type + // references (as opposed to checking the structure of the types) because elsewhere we have already checked + // that the base type is a class or interface type (and not, for example, an anonymous object type). + var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); + if (ts.forEach(constructors, function (sig) { return getReturnTypeOfSignature(sig) !== baseType; })) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type); + } } checkKindsOfPropertyMemberOverrides(type, baseType); } } - if (baseTypes.length || (baseTypeNode && compilerOptions.isolatedModules)) { - // Check that base type can be evaluated as expression - checkExpressionOrQualifiedName(baseTypeNode.expression); - } var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node); if (implementedTypeNodes) { ts.forEach(implementedTypeNodes, function (typeRefNode) { if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) { error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments); } - checkExpressionWithTypeArguments(typeRefNode); + checkTypeReferenceNode(typeRefNode); if (produceDiagnostics) { var t = getTypeFromTypeNode(typeRefNode); if (t !== unknownType) { @@ -21335,7 +21885,7 @@ var ts; } } function isAccessor(kind) { - return kind === 137 /* GetAccessor */ || kind === 138 /* SetAccessor */; + return kind === 138 /* GetAccessor */ || kind === 139 /* SetAccessor */; } function areTypeParametersIdentical(list1, list2) { if (!list1 && !list2) { @@ -21399,13 +21949,13 @@ var ts; } function checkInterfaceDeclaration(node) { // Grammar checking - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); checkTypeParameters(node.typeParameters); if (produceDiagnostics) { checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 203 /* InterfaceDeclaration */); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 205 /* InterfaceDeclaration */); if (symbol.declarations.length > 1) { if (node !== firstInterfaceDecl && !areTypeParametersIdentical(firstInterfaceDecl.typeParameters, node.typeParameters)) { error(node.name, ts.Diagnostics.All_declarations_of_an_interface_must_have_identical_type_parameters); @@ -21427,7 +21977,7 @@ var ts; if (!ts.isSupportedExpressionWithTypeArguments(heritageElement)) { error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments); } - checkExpressionWithTypeArguments(heritageElement); + checkTypeReferenceNode(heritageElement); }); ts.forEach(node.members, checkSourceElement); if (produceDiagnostics) { @@ -21449,7 +21999,7 @@ var ts; var ambient = ts.isInAmbientContext(node); var enumIsConst = ts.isConst(node); ts.forEach(node.members, function (member) { - if (member.name.kind !== 128 /* ComputedPropertyName */ && isNumericLiteralName(member.name.text)) { + if (member.name.kind !== 129 /* ComputedPropertyName */ && isNumericLiteralName(member.name.text)) { error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); } var initializer = member.initializer; @@ -21489,7 +22039,7 @@ var ts; return evalConstant(initializer); function evalConstant(e) { switch (e.kind) { - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: var value = evalConstant(e.operand); if (value === undefined) { return undefined; @@ -21500,7 +22050,7 @@ var ts; case 47 /* TildeToken */: return ~value; } return undefined; - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: var left = evalConstant(e.left); if (left === undefined) { return undefined; @@ -21525,11 +22075,11 @@ var ts; return undefined; case 7 /* NumericLiteral */: return +e.text; - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return evalConstant(e.expression); case 65 /* Identifier */: - case 157 /* ElementAccessExpression */: - case 156 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 158 /* PropertyAccessExpression */: var member = initializer.parent; var currentType = getTypeOfSymbol(getSymbolOfNode(member.parent)); var enumType; @@ -21542,7 +22092,7 @@ var ts; } else { var expression; - if (e.kind === 157 /* ElementAccessExpression */) { + if (e.kind === 159 /* ElementAccessExpression */) { if (e.argumentExpression === undefined || e.argumentExpression.kind !== 8 /* StringLiteral */) { return undefined; @@ -21560,7 +22110,7 @@ var ts; if (current.kind === 65 /* Identifier */) { break; } - else if (current.kind === 156 /* PropertyAccessExpression */) { + else if (current.kind === 158 /* PropertyAccessExpression */) { current = current.expression; } else { @@ -21599,7 +22149,7 @@ var ts; return; } // Grammar checking - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); @@ -21629,7 +22179,7 @@ var ts; var seenEnumMissingInitialInitializer = false; ts.forEach(enumSymbol.declarations, function (declaration) { // return true if we hit a violation of the rule, false otherwise - if (declaration.kind !== 205 /* EnumDeclaration */) { + if (declaration.kind !== 207 /* EnumDeclaration */) { return false; } var enumDeclaration = declaration; @@ -21652,8 +22202,8 @@ var ts; var declarations = symbol.declarations; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; - if ((declaration.kind === 202 /* ClassDeclaration */ || - (declaration.kind === 201 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) && + if ((declaration.kind === 204 /* ClassDeclaration */ || + (declaration.kind === 203 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { return declaration; } @@ -21676,7 +22226,15 @@ var ts; function checkModuleDeclaration(node) { if (produceDiagnostics) { // Grammar checking - if (!checkGrammarDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { + var isAmbientExternalModule = node.name.kind === 8 /* StringLiteral */; + var contextErrorMessage = isAmbientExternalModule + ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file + : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module; + if (checkGrammarModuleElementContext(node, contextErrorMessage)) { + // If we hit a module declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { if (!ts.isInAmbientContext(node) && node.name.kind === 8 /* StringLiteral */) { grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); } @@ -21701,14 +22259,14 @@ var ts; } // if the module merges with a class declaration in the same lexical scope, // we need to track this to ensure the correct emit. - var mergedClass = ts.getDeclarationOfKind(symbol, 202 /* ClassDeclaration */); + var mergedClass = ts.getDeclarationOfKind(symbol, 204 /* ClassDeclaration */); if (mergedClass && inSameLexicalScope(node, mergedClass)) { getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */; } } // Checks for ambient external modules. - if (node.name.kind === 8 /* StringLiteral */) { + if (isAmbientExternalModule) { if (!isGlobalSourceFile(node.parent)) { error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules); } @@ -21721,10 +22279,10 @@ var ts; } function getFirstIdentifier(node) { while (true) { - if (node.kind === 127 /* QualifiedName */) { + if (node.kind === 128 /* QualifiedName */) { node = node.left; } - else if (node.kind === 156 /* PropertyAccessExpression */) { + else if (node.kind === 158 /* PropertyAccessExpression */) { node = node.expression; } else { @@ -21740,9 +22298,9 @@ var ts; error(moduleName, ts.Diagnostics.String_literal_expected); return false; } - var inAmbientExternalModule = node.parent.kind === 207 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; - if (node.parent.kind !== 228 /* SourceFile */ && !inAmbientExternalModule) { - error(moduleName, node.kind === 216 /* ExportDeclaration */ ? + var inAmbientExternalModule = node.parent.kind === 209 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; + if (node.parent.kind !== 230 /* SourceFile */ && !inAmbientExternalModule) { + error(moduleName, node.kind === 218 /* ExportDeclaration */ ? ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module); return false; @@ -21765,7 +22323,7 @@ var ts; (symbol.flags & 793056 /* Type */ ? 793056 /* Type */ : 0) | (symbol.flags & 1536 /* Namespace */ ? 1536 /* Namespace */ : 0); if (target.flags & excludedMeanings) { - var message = node.kind === 218 /* ExportSpecifier */ ? + var message = node.kind === 220 /* ExportSpecifier */ ? ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0; error(node, message, symbolToString(symbol)); @@ -21778,7 +22336,11 @@ var ts; checkAliasSymbol(node); } function checkImportDeclaration(node) { - if (!checkGrammarImportDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); } if (checkExternalImportOrExportDeclaration(node)) { @@ -21788,7 +22350,7 @@ var ts; checkImportBinding(importClause); } if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 214 /* NamespaceImport */) { checkImportBinding(importClause.namedBindings); } else { @@ -21799,7 +22361,11 @@ var ts; } } function checkImportEqualsDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node); + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + checkGrammarDecorators(node) || checkGrammarModifiers(node); if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) { checkImportBinding(node); if (node.flags & 1 /* Export */) { @@ -21829,6 +22395,10 @@ var ts; } } function checkExportDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) { + // If we hit an export in an illegal context, just bail out to avoid cascading errors. + return; + } if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); } @@ -21837,8 +22407,8 @@ var ts; // export { x, y } // export { x, y } from "foo" ts.forEach(node.exportClause.elements, checkExportSpecifier); - var inAmbientExternalModule = node.parent.kind === 207 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; - if (node.parent.kind !== 228 /* SourceFile */ && !inAmbientExternalModule) { + var inAmbientExternalModule = node.parent.kind === 209 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; + if (node.parent.kind !== 230 /* SourceFile */ && !inAmbientExternalModule) { error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace); } } @@ -21851,6 +22421,11 @@ var ts; } } } + function checkGrammarModuleElementContext(node, errorMessage) { + if (node.parent.kind !== 230 /* SourceFile */ && node.parent.kind !== 209 /* ModuleBlock */ && node.parent.kind !== 208 /* ModuleDeclaration */) { + return grammarErrorOnFirstToken(node, errorMessage); + } + } function checkExportSpecifier(node) { checkAliasSymbol(node); if (!node.parent.parent.moduleSpecifier) { @@ -21858,8 +22433,12 @@ var ts; } } function checkExportAssignment(node) { - var container = node.parent.kind === 228 /* SourceFile */ ? node.parent : node.parent.parent; - if (container.kind === 206 /* ModuleDeclaration */ && container.name.kind === 65 /* Identifier */) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) { + // If we hit an export assignment in an illegal context, just bail out to avoid cascading errors. + return; + } + var container = node.parent.kind === 230 /* SourceFile */ ? node.parent : node.parent.parent; + if (container.kind === 208 /* ModuleDeclaration */ && container.name.kind === 65 /* Identifier */) { error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace); return; } @@ -21886,10 +22465,10 @@ var ts; } } function getModuleStatements(node) { - if (node.kind === 228 /* SourceFile */) { + if (node.kind === 230 /* SourceFile */) { return node.statements; } - if (node.kind === 206 /* ModuleDeclaration */ && node.body.kind === 207 /* ModuleBlock */) { + if (node.kind === 208 /* ModuleDeclaration */ && node.body.kind === 209 /* ModuleBlock */) { return node.body.statements; } return emptyArray; @@ -21914,111 +22493,118 @@ var ts; links.exportsChecked = true; } } + function checkTypePredicate(node) { + if (!isInLegalTypePredicatePosition(node)) { + error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + } + } function checkSourceElement(node) { if (!node) return; switch (node.kind) { - case 129 /* TypeParameter */: + case 130 /* TypeParameter */: return checkTypeParameter(node); - case 130 /* Parameter */: + case 131 /* Parameter */: return checkParameter(node); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return checkPropertyDeclaration(node); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: return checkSignatureDeclaration(node); - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: return checkSignatureDeclaration(node); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return checkMethodDeclaration(node); - case 136 /* Constructor */: + case 137 /* Constructor */: return checkConstructorDeclaration(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return checkAccessorDeclaration(node); - case 142 /* TypeReference */: + case 144 /* TypeReference */: return checkTypeReferenceNode(node); - case 145 /* TypeQuery */: + case 143 /* TypePredicate */: + return checkTypePredicate(node); + case 147 /* TypeQuery */: return checkTypeQuery(node); - case 146 /* TypeLiteral */: + case 148 /* TypeLiteral */: return checkTypeLiteral(node); - case 147 /* ArrayType */: + case 149 /* ArrayType */: return checkArrayType(node); - case 148 /* TupleType */: + case 150 /* TupleType */: return checkTupleType(node); - case 149 /* UnionType */: + case 151 /* UnionType */: return checkUnionType(node); - case 150 /* ParenthesizedType */: + case 152 /* ParenthesizedType */: return checkSourceElement(node.type); - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return checkFunctionDeclaration(node); - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return checkBlock(node); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return checkVariableStatement(node); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: return checkExpressionStatement(node); - case 184 /* IfStatement */: + case 186 /* IfStatement */: return checkIfStatement(node); - case 185 /* DoStatement */: + case 187 /* DoStatement */: return checkDoStatement(node); - case 186 /* WhileStatement */: + case 188 /* WhileStatement */: return checkWhileStatement(node); - case 187 /* ForStatement */: + case 189 /* ForStatement */: return checkForStatement(node); - case 188 /* ForInStatement */: + case 190 /* ForInStatement */: return checkForInStatement(node); - case 189 /* ForOfStatement */: + case 191 /* ForOfStatement */: return checkForOfStatement(node); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 193 /* BreakStatement */: return checkBreakOrContinueStatement(node); - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: return checkReturnStatement(node); - case 193 /* WithStatement */: + case 195 /* WithStatement */: return checkWithStatement(node); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: return checkSwitchStatement(node); - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return checkLabeledStatement(node); - case 196 /* ThrowStatement */: + case 198 /* ThrowStatement */: return checkThrowStatement(node); - case 197 /* TryStatement */: + case 199 /* TryStatement */: return checkTryStatement(node); - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: return checkVariableDeclaration(node); - case 153 /* BindingElement */: + case 155 /* BindingElement */: return checkBindingElement(node); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return checkClassDeclaration(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return checkInterfaceDeclaration(node); - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: return checkTypeAliasDeclaration(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return checkEnumDeclaration(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return checkModuleDeclaration(node); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: return checkImportDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return checkImportEqualsDeclaration(node); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return checkExportDeclaration(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return checkExportAssignment(node); - case 182 /* EmptyStatement */: + case 184 /* EmptyStatement */: checkGrammarStatementInAmbientContext(node); return; - case 198 /* DebuggerStatement */: + case 200 /* DebuggerStatement */: checkGrammarStatementInAmbientContext(node); return; - case 219 /* MissingDeclaration */: + case 221 /* MissingDeclaration */: return checkMissingDeclaration(node); } } @@ -22033,83 +22619,83 @@ var ts; // Delaying the type check of the body ensures foo has been assigned a type. function checkFunctionExpressionBodies(node) { switch (node.kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: ts.forEach(node.parameters, checkFunctionExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: ts.forEach(node.decorators, checkFunctionExpressionBodies); ts.forEach(node.parameters, checkFunctionExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } break; - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: ts.forEach(node.parameters, checkFunctionExpressionBodies); break; - case 193 /* WithStatement */: + case 195 /* WithStatement */: checkFunctionExpressionBodies(node.expression); break; - case 131 /* Decorator */: - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 153 /* BindingElement */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 225 /* PropertyAssignment */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 160 /* TaggedTemplateExpression */: - case 172 /* TemplateExpression */: - case 178 /* TemplateSpan */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 166 /* TypeOfExpression */: - case 167 /* VoidExpression */: - case 165 /* DeleteExpression */: - case 168 /* PrefixUnaryExpression */: - case 169 /* PostfixUnaryExpression */: - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 181 /* VariableStatement */: - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: - case 208 /* CaseBlock */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 196 /* ThrowStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: - case 199 /* VariableDeclaration */: - case 200 /* VariableDeclarationList */: - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 215 /* ExportAssignment */: - case 228 /* SourceFile */: + case 132 /* Decorator */: + case 131 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: + case 155 /* BindingElement */: + case 156 /* ArrayLiteralExpression */: + case 157 /* ObjectLiteralExpression */: + case 227 /* PropertyAssignment */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 162 /* TaggedTemplateExpression */: + case 174 /* TemplateExpression */: + case 180 /* TemplateSpan */: + case 163 /* TypeAssertionExpression */: + case 164 /* ParenthesizedExpression */: + case 168 /* TypeOfExpression */: + case 169 /* VoidExpression */: + case 167 /* DeleteExpression */: + case 170 /* PrefixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: + case 172 /* BinaryExpression */: + case 173 /* ConditionalExpression */: + case 176 /* SpreadElementExpression */: + case 182 /* Block */: + case 209 /* ModuleBlock */: + case 183 /* VariableStatement */: + case 185 /* ExpressionStatement */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 192 /* ContinueStatement */: + case 193 /* BreakStatement */: + case 194 /* ReturnStatement */: + case 196 /* SwitchStatement */: + case 210 /* CaseBlock */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: + case 197 /* LabeledStatement */: + case 198 /* ThrowStatement */: + case 199 /* TryStatement */: + case 226 /* CatchClause */: + case 201 /* VariableDeclaration */: + case 202 /* VariableDeclarationList */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 229 /* EnumMember */: + case 217 /* ExportAssignment */: + case 230 /* SourceFile */: ts.forEachChild(node, checkFunctionExpressionBodies); break; } @@ -22123,6 +22709,11 @@ var ts; function checkSourceFileWorker(node) { var links = getNodeLinks(node); if (!(links.flags & 1 /* TypeChecked */)) { + // Check whether the file has declared it is the default lib, + // and whether the user has specifically chosen to avoid checking it. + if (node.isDefaultLib && compilerOptions.skipDefaultLibCheck) { + return; + } // Grammar checking checkGrammarSourceFile(node); emitExtends = false; @@ -22172,7 +22763,7 @@ var ts; function isInsideWithStatementBody(node) { if (node) { while (node.parent) { - if (node.parent.kind === 193 /* WithStatement */ && node.parent.statement === node) { + if (node.parent.kind === 195 /* WithStatement */ && node.parent.statement === node) { return true; } node = node.parent; @@ -22195,23 +22786,23 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (!ts.isExternalModule(location)) { break; } - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */); break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: if (!(memberFlags & 128 /* Static */)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */); } break; - case 163 /* FunctionExpression */: + case 165 /* FunctionExpression */: if (location.name) { copySymbol(location.symbol, meaning); } @@ -22249,22 +22840,22 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (!ts.isExternalModule(location)) break; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */); break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: if (!(memberFlags & 128 /* Static */)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */); } break; - case 163 /* FunctionExpression */: + case 165 /* FunctionExpression */: if (location.name) { copySymbol(location.symbol, meaning); } @@ -22277,43 +22868,43 @@ var ts; return symbolsToArray(symbols); } function isTypeDeclarationName(name) { - return name.kind == 65 /* Identifier */ && + return name.kind === 65 /* Identifier */ && isTypeDeclaration(name.parent) && name.parent.name === name; } function isTypeDeclaration(node) { switch (node.kind) { - case 129 /* TypeParameter */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: + case 130 /* TypeParameter */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 207 /* EnumDeclaration */: return true; } } // True if the given identifier is part of a type reference function isTypeReferenceIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 127 /* QualifiedName */) { + while (node.parent && node.parent.kind === 128 /* QualifiedName */) { node = node.parent; } - return node.parent && node.parent.kind === 142 /* TypeReference */; + return node.parent && node.parent.kind === 144 /* TypeReference */; } function isHeritageClauseElementIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 156 /* PropertyAccessExpression */) { + while (node.parent && node.parent.kind === 158 /* PropertyAccessExpression */) { node = node.parent; } - return node.parent && node.parent.kind === 177 /* ExpressionWithTypeArguments */; + return node.parent && node.parent.kind === 179 /* ExpressionWithTypeArguments */; } function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { - while (nodeOnRightSide.parent.kind === 127 /* QualifiedName */) { + while (nodeOnRightSide.parent.kind === 128 /* QualifiedName */) { nodeOnRightSide = nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 209 /* ImportEqualsDeclaration */) { + if (nodeOnRightSide.parent.kind === 211 /* ImportEqualsDeclaration */) { return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 215 /* ExportAssignment */) { + if (nodeOnRightSide.parent.kind === 217 /* ExportAssignment */) { return nodeOnRightSide.parent.expression === nodeOnRightSide && nodeOnRightSide.parent; } return undefined; @@ -22325,11 +22916,11 @@ var ts; if (ts.isDeclarationName(entityName)) { return getSymbolOfNode(entityName.parent); } - if (entityName.parent.kind === 215 /* ExportAssignment */) { + if (entityName.parent.kind === 217 /* ExportAssignment */) { return resolveEntityName(entityName, /*all meanings*/ 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */); } - if (entityName.kind !== 156 /* PropertyAccessExpression */) { + if (entityName.kind !== 158 /* PropertyAccessExpression */) { if (isInRightSideOfImportOrExportAssignment(entityName)) { // Since we already checked for ExportAssignment, this really could only be an Import return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); @@ -22339,7 +22930,7 @@ var ts; entityName = entityName.parent; } if (isHeritageClauseElementIdentifier(entityName)) { - var meaning = entityName.parent.kind === 177 /* ExpressionWithTypeArguments */ ? 793056 /* Type */ : 1536 /* Namespace */; + var meaning = entityName.parent.kind === 179 /* ExpressionWithTypeArguments */ ? 793056 /* Type */ : 1536 /* Namespace */; meaning |= 8388608 /* Alias */; return resolveEntityName(entityName, meaning); } @@ -22354,14 +22945,14 @@ var ts; var meaning = 107455 /* Value */ | 8388608 /* Alias */; return resolveEntityName(entityName, meaning); } - else if (entityName.kind === 156 /* PropertyAccessExpression */) { + else if (entityName.kind === 158 /* PropertyAccessExpression */) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkPropertyAccessExpression(entityName); } return getNodeLinks(entityName).resolvedSymbol; } - else if (entityName.kind === 127 /* QualifiedName */) { + else if (entityName.kind === 128 /* QualifiedName */) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkQualifiedName(entityName); @@ -22370,7 +22961,7 @@ var ts; } } else if (isTypeReferenceIdentifier(entityName)) { - var meaning = entityName.parent.kind === 142 /* TypeReference */ ? 793056 /* Type */ : 1536 /* Namespace */; + var meaning = entityName.parent.kind === 144 /* TypeReference */ ? 793056 /* Type */ : 1536 /* Namespace */; // Include aliases in the meaning, this ensures that we do not follow aliases to where they point and instead // return the alias symbol. meaning |= 8388608 /* Alias */; @@ -22389,14 +22980,14 @@ var ts; return getSymbolOfNode(node.parent); } if (node.kind === 65 /* Identifier */ && isInRightSideOfImportOrExportAssignment(node)) { - return node.parent.kind === 215 /* ExportAssignment */ + return node.parent.kind === 217 /* ExportAssignment */ ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); } switch (node.kind) { case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: + case 158 /* PropertyAccessExpression */: + case 128 /* QualifiedName */: return getSymbolOfEntityNameOrPropertyAccessExpression(node); case 93 /* ThisKeyword */: case 91 /* SuperKeyword */: @@ -22405,7 +22996,7 @@ var ts; case 114 /* ConstructorKeyword */: // constructor keyword for an overload, should take us to the definition if it exist var constructorDeclaration = node.parent; - if (constructorDeclaration && constructorDeclaration.kind === 136 /* Constructor */) { + if (constructorDeclaration && constructorDeclaration.kind === 137 /* Constructor */) { return constructorDeclaration.parent.symbol; } return undefined; @@ -22414,14 +23005,14 @@ var ts; var moduleName; if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) || - ((node.parent.kind === 210 /* ImportDeclaration */ || node.parent.kind === 216 /* ExportDeclaration */) && + ((node.parent.kind === 212 /* ImportDeclaration */ || node.parent.kind === 218 /* ExportDeclaration */) && node.parent.moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } // Intentional fall-through case 7 /* NumericLiteral */: // index access - if (node.parent.kind == 157 /* ElementAccessExpression */ && node.parent.argumentExpression === node) { + if (node.parent.kind === 159 /* ElementAccessExpression */ && node.parent.argumentExpression === node) { var objectType = checkExpression(node.parent.expression); if (objectType === unknownType) return undefined; @@ -22438,7 +23029,7 @@ var ts; // The function returns a value symbol of an identifier in the short-hand property assignment. // This is necessary as an identifier in short-hand property assignment can contains two meaning: // property name and property value. - if (location && location.kind === 226 /* ShorthandPropertyAssignment */) { + if (location && location.kind === 228 /* ShorthandPropertyAssignment */) { return resolveEntityName(location.name, 107455 /* Value */); } return undefined; @@ -22454,6 +23045,11 @@ var ts; if (ts.isExpression(node)) { return getTypeOfExpression(node); } + if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(node)) { + // A SyntaxKind.ExpressionWithTypeArguments is considered a type node, except when it occurs in the + // extends clause of a class. We handle that case here. + return getBaseTypes(getDeclaredTypeOfSymbol(getSymbolOfNode(node.parent.parent)))[0]; + } if (isTypeDeclaration(node)) { // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration var symbol = getSymbolOfNode(node); @@ -22517,93 +23113,92 @@ var ts; return [symbol]; } // Emitter support - function isExternalModuleSymbol(symbol) { - return symbol.flags & 512 /* ValueModule */ && symbol.declarations.length === 1 && symbol.declarations[0].kind === 228 /* SourceFile */; - } - function getAliasNameSubstitution(symbol, getGeneratedNameForNode) { - // If this is es6 or higher, just use the name of the export - // no need to qualify it. - if (languageVersion >= 2 /* ES6 */) { - return undefined; - } - var node = getDeclarationOfAliasSymbol(symbol); - if (node) { - if (node.kind === 211 /* ImportClause */) { - var defaultKeyword; - if (languageVersion === 0 /* ES3 */) { - defaultKeyword = "[\"default\"]"; - } - else { - defaultKeyword = ".default"; - } - return getGeneratedNameForNode(node.parent) + defaultKeyword; - } - if (node.kind === 214 /* ImportSpecifier */) { - var moduleName = getGeneratedNameForNode(node.parent.parent.parent); - var propertyName = node.propertyName || node.name; - return moduleName + "." + ts.unescapeIdentifier(propertyName.text); - } - } - } - function getExportNameSubstitution(symbol, location, getGeneratedNameForNode) { - if (isExternalModuleSymbol(symbol.parent)) { - // 1. If this is es6 or higher, just use the name of the export - // no need to qualify it. - // 2. export mechanism for System modules is different from CJS\AMD - // and it does not need qualifications for exports - if (languageVersion >= 2 /* ES6 */ || compilerOptions.module === 4 /* System */) { - return undefined; - } - return "exports." + ts.unescapeIdentifier(symbol.name); - } - var node = location; - var containerSymbol = getParentOfSymbol(symbol); - while (node) { - if ((node.kind === 206 /* ModuleDeclaration */ || node.kind === 205 /* EnumDeclaration */) && getSymbolOfNode(node) === containerSymbol) { - return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); - } - node = node.parent; - } - } - function getExpressionNameSubstitution(node, getGeneratedNameForNode) { - var symbol = getNodeLinks(node).resolvedSymbol || (ts.isDeclarationName(node) ? getSymbolOfNode(node.parent) : undefined); + // When resolved as an expression identifier, if the given node references an exported entity, return the declaration + // node of the exported entity's container. Otherwise, return undefined. + function getReferencedExportContainer(node) { + var symbol = getReferencedValueSymbol(node); if (symbol) { - // Whan an identifier resolves to a parented symbol, it references an exported entity from - // another declaration of the same internal module. - if (symbol.parent) { - return getExportNameSubstitution(symbol, node.parent, getGeneratedNameForNode); + if (symbol.flags & 1048576 /* ExportValue */) { + // If we reference an exported entity within the same module declaration, then whether + // we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the + // kinds that we do NOT prefix. + var exportSymbol = getMergedSymbol(symbol.exportSymbol); + if (exportSymbol.flags & 944 /* ExportHasLocal */) { + return undefined; + } + symbol = exportSymbol; } - // If we reference an exported entity within the same module declaration, then whether - // we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the - // kinds that we do NOT prefix. - var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); - if (symbol !== exportSymbol && !(exportSymbol.flags & 944 /* ExportHasLocal */)) { - return getExportNameSubstitution(exportSymbol, node.parent, getGeneratedNameForNode); - } - // Named imports from ES6 import declarations are rewritten - if (symbol.flags & 8388608 /* Alias */) { - return getAliasNameSubstitution(symbol, getGeneratedNameForNode); + var parentSymbol = getParentOfSymbol(symbol); + if (parentSymbol) { + if (parentSymbol.flags & 512 /* ValueModule */ && parentSymbol.valueDeclaration.kind === 230 /* SourceFile */) { + return parentSymbol.valueDeclaration; + } + for (var n = node.parent; n; n = n.parent) { + if ((n.kind === 208 /* ModuleDeclaration */ || n.kind === 207 /* EnumDeclaration */) && getSymbolOfNode(n) === parentSymbol) { + return n; + } + } } } } + // When resolved as an expression identifier, if the given node references an import, return the declaration of + // that import. Otherwise, return undefined. + function getReferencedImportDeclaration(node) { + var symbol = getReferencedValueSymbol(node); + return symbol && symbol.flags & 8388608 /* Alias */ ? getDeclarationOfAliasSymbol(symbol) : undefined; + } + function isStatementWithLocals(node) { + switch (node.kind) { + case 182 /* Block */: + case 210 /* CaseBlock */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + return true; + } + return false; + } + function isNestedRedeclarationSymbol(symbol) { + if (symbol.flags & 418 /* BlockScoped */) { + var links = getSymbolLinks(symbol); + if (links.isNestedRedeclaration === undefined) { + var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration); + links.isNestedRedeclaration = isStatementWithLocals(container) && + !!resolveName(container.parent, symbol.name, 107455 /* Value */, undefined, undefined); + } + return links.isNestedRedeclaration; + } + return false; + } + // When resolved as an expression identifier, if the given node references a nested block scoped entity with + // a name that hides an existing name, return the declaration of that entity. Otherwise, return undefined. + function getReferencedNestedRedeclaration(node) { + var symbol = getReferencedValueSymbol(node); + return symbol && isNestedRedeclarationSymbol(symbol) ? symbol.valueDeclaration : undefined; + } + // Return true if the given node is a declaration of a nested block scoped entity with a name that hides an + // existing name. + function isNestedRedeclaration(node) { + return isNestedRedeclarationSymbol(getSymbolOfNode(node)); + } function isValueAliasDeclaration(node) { switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 213 /* ImportClause */: + case 214 /* NamespaceImport */: + case 216 /* ImportSpecifier */: + case 220 /* ExportSpecifier */: return isAliasResolvedToValue(getSymbolOfNode(node)); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: var exportClause = node.exportClause; return exportClause && ts.forEach(exportClause.elements, isValueAliasDeclaration); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return node.expression && node.expression.kind === 65 /* Identifier */ ? isAliasResolvedToValue(getSymbolOfNode(node)) : true; } return false; } function isTopLevelValueImportEqualsWithEntityName(node) { - if (node.parent.kind !== 228 /* SourceFile */ || !ts.isInternalModuleImportEqualsDeclaration(node)) { + if (node.parent.kind !== 230 /* SourceFile */ || !ts.isInternalModuleImportEqualsDeclaration(node)) { // parent is not source file or it is not reference to internal module return false; } @@ -22661,7 +23256,7 @@ var ts; return getNodeLinks(node).enumMemberValue; } function getConstantValue(node) { - if (node.kind === 227 /* EnumMember */) { + if (node.kind === 229 /* EnumMember */) { return getEnumMemberValue(node); } var symbol = getNodeLinks(node).resolvedSymbol; @@ -22674,10 +23269,13 @@ var ts; return undefined; } /** Serializes an EntityName (with substitutions) to an appropriate JS constructor value. Used by the __metadata decorator. */ - function serializeEntityName(node, getGeneratedNameForNode, fallbackPath) { + function serializeEntityName(node, fallbackPath) { if (node.kind === 65 /* Identifier */) { - var substitution = getExpressionNameSubstitution(node, getGeneratedNameForNode); - var text = substitution || node.text; + // TODO(ron.buckton): The getExpressionNameSubstitution function has been removed, but calling it + // here has no effect anyway as an identifier in a type name is not an expression. + // var substitution = getExpressionNameSubstitution(node, getGeneratedNameForNode); + // var text = substitution || (node).text; + var text = node.text; if (fallbackPath) { fallbackPath.push(text); } @@ -22686,15 +23284,15 @@ var ts; } } else { - var left = serializeEntityName(node.left, getGeneratedNameForNode, fallbackPath); - var right = serializeEntityName(node.right, getGeneratedNameForNode, fallbackPath); + var left = serializeEntityName(node.left, fallbackPath); + var right = serializeEntityName(node.right, fallbackPath); if (!fallbackPath) { return left + "." + right; } } } /** Serializes a TypeReferenceNode to an appropriate JS constructor value. Used by the __metadata decorator. */ - function serializeTypeReferenceNode(node, getGeneratedNameForNode) { + function serializeTypeReferenceNode(node) { // serialization of a TypeReferenceNode uses the following rules: // // * The serialized type of a TypeReference that is `void` is "void 0". @@ -22727,11 +23325,11 @@ var ts; } else if (type === unknownType) { var fallbackPath = []; - serializeEntityName(node.typeName, getGeneratedNameForNode, fallbackPath); + serializeEntityName(node.typeName, fallbackPath); return fallbackPath; } else if (type.symbol && type.symbol.valueDeclaration) { - return serializeEntityName(node.typeName, getGeneratedNameForNode); + return serializeEntityName(node.typeName); } else if (typeHasCallOrConstructSignatures(type)) { return "Function"; @@ -22739,7 +23337,7 @@ var ts; return "Object"; } /** Serializes a TypeNode to an appropriate JS constructor value. Used by the __metadata decorator. */ - function serializeTypeNode(node, getGeneratedNameForNode) { + function serializeTypeNode(node) { // serialization of a TypeNode uses the following rules: // // * The serialized type of `void` is "void 0" (undefined). @@ -22754,26 +23352,26 @@ var ts; switch (node.kind) { case 99 /* VoidKeyword */: return "void 0"; - case 150 /* ParenthesizedType */: - return serializeTypeNode(node.type, getGeneratedNameForNode); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 152 /* ParenthesizedType */: + return serializeTypeNode(node.type); + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return "Function"; - case 147 /* ArrayType */: - case 148 /* TupleType */: + case 149 /* ArrayType */: + case 150 /* TupleType */: return "Array"; case 113 /* BooleanKeyword */: return "Boolean"; - case 122 /* StringKeyword */: + case 123 /* StringKeyword */: case 8 /* StringLiteral */: return "String"; - case 120 /* NumberKeyword */: + case 121 /* NumberKeyword */: return "Number"; - case 142 /* TypeReference */: - return serializeTypeReferenceNode(node, getGeneratedNameForNode); - case 145 /* TypeQuery */: - case 146 /* TypeLiteral */: - case 149 /* UnionType */: + case 144 /* TypeReference */: + return serializeTypeReferenceNode(node); + case 147 /* TypeQuery */: + case 148 /* TypeLiteral */: + case 151 /* UnionType */: case 112 /* AnyKeyword */: break; default: @@ -22784,7 +23382,7 @@ var ts; return "Object"; } /** Serializes the type of a declaration to an appropriate JS constructor value. Used by the __metadata decorator for a class member. */ - function serializeTypeOfNode(node, getGeneratedNameForNode) { + function serializeTypeOfNode(node) { // serialization of the type of a declaration uses the following rules: // // * The serialized type of a ClassDeclaration is "Function" @@ -22796,11 +23394,11 @@ var ts; // // For rules on serializing type annotations, see `serializeTypeNode`. switch (node.kind) { - case 202 /* ClassDeclaration */: return "Function"; - case 133 /* PropertyDeclaration */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 130 /* Parameter */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 137 /* GetAccessor */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 138 /* SetAccessor */: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node), getGeneratedNameForNode); + case 204 /* ClassDeclaration */: return "Function"; + case 134 /* PropertyDeclaration */: return serializeTypeNode(node.type); + case 131 /* Parameter */: return serializeTypeNode(node.type); + case 138 /* GetAccessor */: return serializeTypeNode(node.type); + case 139 /* SetAccessor */: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node)); } if (ts.isFunctionLike(node)) { return "Function"; @@ -22808,7 +23406,7 @@ var ts; return "void 0"; } /** Serializes the parameter types of a function or the constructor of a class. Used by the __metadata decorator for a method or set accessor. */ - function serializeParameterTypesOfNode(node, getGeneratedNameForNode) { + function serializeParameterTypesOfNode(node) { // serialization of parameter types uses the following rules: // // * If the declaration is a class, the parameters of the first constructor with a body are used. @@ -22817,7 +23415,7 @@ var ts; // For the rules on serializing the type of each parameter declaration, see `serializeTypeOfDeclaration`. if (node) { var valueDeclaration; - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { valueDeclaration = ts.getFirstConstructorWithBody(node); } else if (ts.isFunctionLike(node) && ts.nodeIsPresent(node.body)) { @@ -22832,19 +23430,19 @@ var ts; for (var i = 0; i < parameterCount; i++) { if (parameters[i].dotDotDotToken) { var parameterType = parameters[i].type; - if (parameterType.kind === 147 /* ArrayType */) { + if (parameterType.kind === 149 /* ArrayType */) { parameterType = parameterType.elementType; } - else if (parameterType.kind === 142 /* TypeReference */ && parameterType.typeArguments && parameterType.typeArguments.length === 1) { + else if (parameterType.kind === 144 /* TypeReference */ && parameterType.typeArguments && parameterType.typeArguments.length === 1) { parameterType = parameterType.typeArguments[0]; } else { parameterType = undefined; } - result[i] = serializeTypeNode(parameterType, getGeneratedNameForNode); + result[i] = serializeTypeNode(parameterType); } else { - result[i] = serializeTypeOfNode(parameters[i], getGeneratedNameForNode); + result[i] = serializeTypeOfNode(parameters[i]); } } return result; @@ -22854,9 +23452,9 @@ var ts; return emptyArray; } /** Serializes the return type of function. Used by the __metadata decorator for a method. */ - function serializeReturnTypeOfNode(node, getGeneratedNameForNode) { + function serializeReturnTypeOfNode(node) { if (node && ts.isFunctionLike(node)) { - return serializeTypeNode(node.type, getGeneratedNameForNode); + return serializeTypeNode(node.type); } return "void 0"; } @@ -22879,25 +23477,25 @@ var ts; function hasGlobalName(name) { return ts.hasProperty(globals, name); } - function resolvesToSomeValue(location, name) { - ts.Debug.assert(!ts.nodeIsSynthesized(location), "resolvesToSomeValue called with a synthesized location"); - return !!resolveName(location, name, 107455 /* Value */, undefined, undefined); + function getReferencedValueSymbol(reference) { + return getNodeLinks(reference).resolvedSymbol || + resolveName(reference, reference.text, 107455 /* Value */ | 1048576 /* ExportValue */ | 8388608 /* Alias */, + /*nodeNotFoundMessage*/ undefined, undefined); } function getReferencedValueDeclaration(reference) { ts.Debug.assert(!ts.nodeIsSynthesized(reference)); - var symbol = getNodeLinks(reference).resolvedSymbol || - resolveName(reference, reference.text, 107455 /* Value */ | 8388608 /* Alias */, undefined, undefined); + var symbol = getReferencedValueSymbol(reference); return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration; } function getBlockScopedVariableId(n) { ts.Debug.assert(!ts.nodeIsSynthesized(n)); - var isVariableDeclarationOrBindingElement = n.parent.kind === 153 /* BindingElement */ || (n.parent.kind === 199 /* VariableDeclaration */ && n.parent.name === n); + var isVariableDeclarationOrBindingElement = n.parent.kind === 155 /* BindingElement */ || (n.parent.kind === 201 /* VariableDeclaration */ && n.parent.name === n); var symbol = (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) || getNodeLinks(n).resolvedSymbol || resolveName(n, n.text, 107455 /* Value */ | 8388608 /* Alias */, undefined, undefined); var isLetOrConst = symbol && (symbol.flags & 2 /* BlockScopedVariable */) && - symbol.valueDeclaration.parent.kind !== 224 /* CatchClause */; + symbol.valueDeclaration.parent.kind !== 226 /* CatchClause */; if (isLetOrConst) { // side-effect of calling this method: // assign id to symbol if it was not yet set @@ -22919,7 +23517,10 @@ var ts; } function createResolver() { return { - getExpressionNameSubstitution: getExpressionNameSubstitution, + getReferencedExportContainer: getReferencedExportContainer, + getReferencedImportDeclaration: getReferencedImportDeclaration, + getReferencedNestedRedeclaration: getReferencedNestedRedeclaration, + isNestedRedeclaration: isNestedRedeclaration, isValueAliasDeclaration: isValueAliasDeclaration, hasGlobalName: hasGlobalName, isReferencedAliasDeclaration: isReferencedAliasDeclaration, @@ -22933,7 +23534,6 @@ var ts; isSymbolAccessible: isSymbolAccessible, isEntityNameVisible: isEntityNameVisible, getConstantValue: getConstantValue, - resolvesToSomeValue: resolvesToSomeValue, collectLinkedAliases: collectLinkedAliases, getBlockScopedVariableId: getBlockScopedVariableId, getReferencedValueDeclaration: getReferencedValueDeclaration, @@ -22994,137 +23594,6 @@ var ts; anyArrayType = createArrayType(anyType); } // GRAMMAR CHECKING - function isReservedWordInStrictMode(node) { - // Check that originalKeywordKind is less than LastFutureReservedWord to see if an Identifier is a strict-mode reserved word - return (node.parserContextFlags & 1 /* StrictMode */) && - (102 /* FirstFutureReservedWord */ <= node.originalKeywordKind && node.originalKeywordKind <= 110 /* LastFutureReservedWord */); - } - function reportStrictModeGrammarErrorInClassDeclaration(identifier, message, arg0, arg1, arg2) { - // We are checking if this name is inside class declaration or class expression (which are under class definitions inside ES6 spec.) - // if so, we would like to give more explicit invalid usage error. - if (ts.getAncestor(identifier, 202 /* ClassDeclaration */) || ts.getAncestor(identifier, 175 /* ClassExpression */)) { - return grammarErrorOnNode(identifier, message, arg0); - } - return false; - } - function checkGrammarImportDeclarationNameInStrictMode(node) { - // Check if the import declaration used strict-mode reserved word in its names bindings - if (node.importClause) { - var impotClause = node.importClause; - if (impotClause.namedBindings) { - var nameBindings = impotClause.namedBindings; - if (nameBindings.kind === 212 /* NamespaceImport */) { - var name_15 = nameBindings.name; - if (isReservedWordInStrictMode(name_15)) { - var nameText = ts.declarationNameToString(name_15); - return grammarErrorOnNode(name_15, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - else if (nameBindings.kind === 213 /* NamedImports */) { - var reportError = false; - for (var _i = 0, _a = nameBindings.elements; _i < _a.length; _i++) { - var element = _a[_i]; - var name_16 = element.name; - if (isReservedWordInStrictMode(name_16)) { - var nameText = ts.declarationNameToString(name_16); - reportError = reportError || grammarErrorOnNode(name_16, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - return reportError; - } - } - } - return false; - } - function checkGrammarDeclarationNameInStrictMode(node) { - var name = node.name; - if (name && name.kind === 65 /* Identifier */ && isReservedWordInStrictMode(name)) { - var nameText = ts.declarationNameToString(name); - switch (node.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 201 /* FunctionDeclaration */: - case 129 /* TypeParameter */: - case 153 /* BindingElement */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: - return checkGrammarIdentifierInStrictMode(name); - case 202 /* ClassDeclaration */: - // Report an error if the class declaration uses strict-mode reserved word. - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText); - case 206 /* ModuleDeclaration */: - // Report an error if the module declaration uses strict-mode reserved word. - // TODO(yuisu): fix this when having external module in strict mode - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - case 209 /* ImportEqualsDeclaration */: - // TODO(yuisu): fix this when having external module in strict mode - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - return false; - } - function checkGrammarTypeReferenceInStrictMode(typeName) { - // Check if the type reference is using strict mode keyword - // Example: - // class C { - // foo(x: public){} // Error. - // } - if (typeName.kind === 65 /* Identifier */) { - checkGrammarTypeNameInStrictMode(typeName); - } - else if (typeName.kind === 127 /* QualifiedName */) { - // Walk from right to left and report a possible error at each Identifier in QualifiedName - // Example: - // x1: public.private.package // error at public and private - checkGrammarTypeNameInStrictMode(typeName.right); - checkGrammarTypeReferenceInStrictMode(typeName.left); - } - } - // This function will report an error for every identifier in property access expression - // whether it violates strict mode reserved words. - // Example: - // public // error at public - // public.private.package // error at public - // B.private.B // no error - function checkGrammarExpressionWithTypeArgumentsInStrictMode(expression) { - // Example: - // class C extends public // error at public - if (expression && expression.kind === 65 /* Identifier */) { - return checkGrammarIdentifierInStrictMode(expression); - } - else if (expression && expression.kind === 156 /* PropertyAccessExpression */) { - // Walk from left to right in PropertyAccessExpression until we are at the left most expression - // in PropertyAccessExpression. According to grammar production of MemberExpression, - // the left component expression is a PrimaryExpression (i.e. Identifier) while the other - // component after dots can be IdentifierName. - checkGrammarExpressionWithTypeArgumentsInStrictMode(expression.expression); - } - } - // The function takes an identifier itself or an expression which has SyntaxKind.Identifier. - function checkGrammarIdentifierInStrictMode(node, nameText) { - if (node && node.kind === 65 /* Identifier */ && isReservedWordInStrictMode(node)) { - if (!nameText) { - nameText = ts.declarationNameToString(node); - } - // TODO (yuisu): Fix when module is a strict mode - var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || - grammarErrorOnNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - return errorReport; - } - return false; - } - // The function takes an identifier when uses as a typeName in TypeReferenceNode - function checkGrammarTypeNameInStrictMode(node) { - if (node && node.kind === 65 /* Identifier */ && isReservedWordInStrictMode(node)) { - var nameText = ts.declarationNameToString(node); - // TODO (yuisu): Fix when module is a strict mode - var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || - grammarErrorOnNode(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode, nameText); - return errorReport; - } - return false; - } function checkGrammarDecorators(node) { if (!node.decorators) { return false; @@ -23135,7 +23604,7 @@ var ts; else if (languageVersion < 1 /* ES5 */) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher); } - else if (node.kind === 137 /* GetAccessor */ || node.kind === 138 /* SetAccessor */) { + else if (node.kind === 138 /* GetAccessor */ || node.kind === 139 /* SetAccessor */) { var accessors = ts.getAllAccessorDeclarations(node.parent.members, node); if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name); @@ -23145,33 +23614,33 @@ var ts; } function checkGrammarModifiers(node) { switch (node.kind) { - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: - case 206 /* ModuleDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 216 /* ExportDeclaration */: - case 215 /* ExportAssignment */: - case 130 /* Parameter */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 137 /* Constructor */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 142 /* IndexSignature */: + case 208 /* ModuleDeclaration */: + case 212 /* ImportDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 218 /* ExportDeclaration */: + case 217 /* ExportAssignment */: + case 131 /* Parameter */: break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 181 /* VariableStatement */: - case 201 /* FunctionDeclaration */: - case 204 /* TypeAliasDeclaration */: - if (node.modifiers && node.parent.kind !== 207 /* ModuleBlock */ && node.parent.kind !== 228 /* SourceFile */) { + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 183 /* VariableStatement */: + case 203 /* FunctionDeclaration */: + case 206 /* TypeAliasDeclaration */: + if (node.modifiers && node.parent.kind !== 209 /* ModuleBlock */ && node.parent.kind !== 230 /* SourceFile */) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); } break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: if (node.modifiers && (node.modifiers.length > 1 || node.modifiers[0].kind !== 70 /* ConstKeyword */) && - node.parent.kind !== 207 /* ModuleBlock */ && node.parent.kind !== 228 /* SourceFile */) { + node.parent.kind !== 209 /* ModuleBlock */ && node.parent.kind !== 230 /* SourceFile */) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); } break; @@ -23207,7 +23676,7 @@ var ts; else if (flags & 128 /* Static */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } - else if (node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + else if (node.parent.kind === 209 /* ModuleBlock */ || node.parent.kind === 230 /* SourceFile */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } flags |= ts.modifierToFlag(modifier.kind); @@ -23216,10 +23685,10 @@ var ts; if (flags & 128 /* Static */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); } - else if (node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + else if (node.parent.kind === 209 /* ModuleBlock */ || node.parent.kind === 230 /* SourceFile */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 131 /* Parameter */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } flags |= 128 /* Static */; @@ -23232,10 +23701,10 @@ var ts; else if (flags & 2 /* Ambient */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 204 /* ClassDeclaration */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 131 /* Parameter */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); } flags |= 1 /* Export */; @@ -23244,13 +23713,13 @@ var ts; if (flags & 2 /* Ambient */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 204 /* ClassDeclaration */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 131 /* Parameter */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); } - else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 207 /* ModuleBlock */) { + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 209 /* ModuleBlock */) { return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } flags |= 2 /* Ambient */; @@ -23258,7 +23727,7 @@ var ts; break; } } - if (node.kind === 136 /* Constructor */) { + if (node.kind === 137 /* Constructor */) { if (flags & 128 /* Static */) { return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } @@ -23269,10 +23738,10 @@ var ts; return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } } - else if ((node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) { + else if ((node.kind === 212 /* ImportDeclaration */ || node.kind === 211 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); } - else if (node.kind === 130 /* Parameter */ && (flags & 112 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) { + else if (node.kind === 131 /* Parameter */ && (flags & 112 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) { return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } } @@ -23336,7 +23805,7 @@ var ts; checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file); } function checkGrammarArrowFunction(node, file) { - if (node.kind === 164 /* ArrowFunction */) { + if (node.kind === 166 /* ArrowFunction */) { var arrowFunction = node; var startLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.pos).line; var endLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.end).line; @@ -23371,7 +23840,7 @@ var ts; if (!parameter.type) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation); } - if (parameter.type.kind !== 122 /* StringKeyword */ && parameter.type.kind !== 120 /* NumberKeyword */) { + if (parameter.type.kind !== 123 /* StringKeyword */ && parameter.type.kind !== 121 /* NumberKeyword */) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); } if (!node.type) { @@ -23404,7 +23873,7 @@ var ts; var sourceFile = ts.getSourceFileOfNode(node); for (var _i = 0; _i < arguments.length; _i++) { var arg = arguments[_i]; - if (arg.kind === 176 /* OmittedExpression */) { + if (arg.kind === 178 /* OmittedExpression */) { return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); } } @@ -23478,19 +23947,19 @@ var ts; } function checkGrammarComputedPropertyName(node) { // If node is not a computedPropertyName, just skip the grammar checking - if (node.kind !== 128 /* ComputedPropertyName */) { + if (node.kind !== 129 /* ComputedPropertyName */) { return false; } var computedPropertyName = node; - if (computedPropertyName.expression.kind === 170 /* BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 23 /* CommaToken */) { + if (computedPropertyName.expression.kind === 172 /* BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 23 /* CommaToken */) { return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); } } function checkGrammarForGenerator(node) { if (node.asteriskToken) { - ts.Debug.assert(node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */ || - node.kind === 135 /* MethodDeclaration */); + ts.Debug.assert(node.kind === 203 /* FunctionDeclaration */ || + node.kind === 165 /* FunctionExpression */ || + node.kind === 136 /* MethodDeclaration */); if (ts.isInAmbientContext(node)) { return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context); } @@ -23502,10 +23971,6 @@ var ts; } } } - function checkGrammarFunctionName(name) { - // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1)) - return checkGrammarEvalOrArgumentsInStrictMode(name, name); - } function checkGrammarForInvalidQuestionMark(node, questionToken, message) { if (questionToken) { return grammarErrorOnNode(questionToken, message); @@ -23517,14 +23982,13 @@ var ts; var GetAccessor = 2; var SetAccesor = 4; var GetOrSetAccessor = GetAccessor | SetAccesor; - var inStrictMode = (node.parserContextFlags & 1 /* StrictMode */) !== 0; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var prop = _a[_i]; - var name_17 = prop.name; - if (prop.kind === 176 /* OmittedExpression */ || - name_17.kind === 128 /* ComputedPropertyName */) { + var name_15 = prop.name; + if (prop.kind === 178 /* OmittedExpression */ || + name_15.kind === 129 /* ComputedPropertyName */) { // If the name is not a ComputedPropertyName, the grammar checking will skip it - checkGrammarComputedPropertyName(name_17); + checkGrammarComputedPropertyName(name_15); continue; } // ECMA-262 11.1.5 Object Initialiser @@ -23536,46 +24000,44 @@ var ts; // d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields var currentKind = void 0; - if (prop.kind === 225 /* PropertyAssignment */ || prop.kind === 226 /* ShorthandPropertyAssignment */) { + if (prop.kind === 227 /* PropertyAssignment */ || prop.kind === 228 /* ShorthandPropertyAssignment */) { // Grammar checking for computedPropertName and shorthandPropertyAssignment checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); - if (name_17.kind === 7 /* NumericLiteral */) { - checkGrammarNumericLiteral(name_17); + if (name_15.kind === 7 /* NumericLiteral */) { + checkGrammarNumericLiteral(name_15); } currentKind = Property; } - else if (prop.kind === 135 /* MethodDeclaration */) { + else if (prop.kind === 136 /* MethodDeclaration */) { currentKind = Property; } - else if (prop.kind === 137 /* GetAccessor */) { + else if (prop.kind === 138 /* GetAccessor */) { currentKind = GetAccessor; } - else if (prop.kind === 138 /* SetAccessor */) { + else if (prop.kind === 139 /* SetAccessor */) { currentKind = SetAccesor; } else { ts.Debug.fail("Unexpected syntax kind:" + prop.kind); } - if (!ts.hasProperty(seen, name_17.text)) { - seen[name_17.text] = currentKind; + if (!ts.hasProperty(seen, name_15.text)) { + seen[name_15.text] = currentKind; } else { - var existingKind = seen[name_17.text]; + var existingKind = seen[name_15.text]; if (currentKind === Property && existingKind === Property) { - if (inStrictMode) { - grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode); - } + continue; } else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) { if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) { - seen[name_17.text] = currentKind | existingKind; + seen[name_15.text] = currentKind | existingKind; } else { - return grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); + return grammarErrorOnNode(name_15, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); } } else { - return grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); + return grammarErrorOnNode(name_15, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); } } } @@ -23584,24 +24046,24 @@ var ts; if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; } - if (forInOrOfStatement.initializer.kind === 200 /* VariableDeclarationList */) { + if (forInOrOfStatement.initializer.kind === 202 /* VariableDeclarationList */) { var variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { if (variableList.declarations.length > 1) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 190 /* ForInStatement */ ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement; return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic); } var firstDeclaration = variableList.declarations[0]; if (firstDeclaration.initializer) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 190 /* ForInStatement */ ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer; return grammarErrorOnNode(firstDeclaration.name, diagnostic); } if (firstDeclaration.type) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 190 /* ForInStatement */ ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation; return grammarErrorOnNode(firstDeclaration, diagnostic); @@ -23624,10 +24086,10 @@ var ts; else if (accessor.typeParameters) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); } - else if (kind === 137 /* GetAccessor */ && accessor.parameters.length) { + else if (kind === 138 /* GetAccessor */ && accessor.parameters.length) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); } - else if (kind === 138 /* SetAccessor */) { + else if (kind === 139 /* SetAccessor */) { if (accessor.type) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); } @@ -23652,7 +24114,7 @@ var ts; } } function checkGrammarForNonSymbolComputedProperty(node, message) { - if (node.kind === 128 /* ComputedPropertyName */ && !ts.isWellKnownSymbolSyntactically(node.expression)) { + if (node.kind === 129 /* ComputedPropertyName */ && !ts.isWellKnownSymbolSyntactically(node.expression)) { return grammarErrorOnNode(node, message); } } @@ -23662,7 +24124,7 @@ var ts; checkGrammarForGenerator(node)) { return true; } - if (node.parent.kind === 155 /* ObjectLiteralExpression */) { + if (node.parent.kind === 157 /* ObjectLiteralExpression */) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -23670,7 +24132,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.kind === 204 /* ClassDeclaration */) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -23686,22 +24148,22 @@ var ts; return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol); } } - else if (node.parent.kind === 203 /* InterfaceDeclaration */) { + else if (node.parent.kind === 205 /* InterfaceDeclaration */) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol); } - else if (node.parent.kind === 146 /* TypeLiteral */) { + else if (node.parent.kind === 148 /* TypeLiteral */) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol); } } function isIterationStatement(node, lookInLabeledStatements) { switch (node.kind) { - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: return true; - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); } return false; @@ -23713,11 +24175,11 @@ var ts; return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); } switch (current.kind) { - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: if (node.label && current.label.text === node.label.text) { // found matching label - verify that label usage is correct // continue can only target labels that are on iteration statements - var isMisplacedContinueLabel = node.kind === 190 /* ContinueStatement */ + var isMisplacedContinueLabel = node.kind === 192 /* ContinueStatement */ && !isIterationStatement(current.statement, true); if (isMisplacedContinueLabel) { return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement); @@ -23725,8 +24187,8 @@ var ts; return false; } break; - case 194 /* SwitchStatement */: - if (node.kind === 191 /* BreakStatement */ && !node.label) { + case 196 /* SwitchStatement */: + if (node.kind === 193 /* BreakStatement */ && !node.label) { // unlabeled break within switch statement - ok return false; } @@ -23741,13 +24203,13 @@ var ts; current = current.parent; } if (node.label) { - var message = node.kind === 191 /* BreakStatement */ + var message = node.kind === 193 /* BreakStatement */ ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); } else { - var message = node.kind === 191 /* BreakStatement */ + var message = node.kind === 193 /* BreakStatement */ ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); @@ -23759,7 +24221,7 @@ var ts; if (node !== ts.lastOrUndefined(elements)) { return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern); } - if (node.name.kind === 152 /* ArrayBindingPattern */ || node.name.kind === 151 /* ObjectBindingPattern */) { + if (node.name.kind === 154 /* ArrayBindingPattern */ || node.name.kind === 153 /* ObjectBindingPattern */) { return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern); } if (node.initializer) { @@ -23767,12 +24229,9 @@ var ts; return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } } - // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code - // and its Identifier is eval or arguments - return checkGrammarEvalOrArgumentsInStrictMode(node, node.name); } function checkGrammarVariableDeclaration(node) { - if (node.parent.parent.kind !== 188 /* ForInStatement */ && node.parent.parent.kind !== 189 /* ForOfStatement */) { + if (node.parent.parent.kind !== 190 /* ForInStatement */ && node.parent.parent.kind !== 191 /* ForOfStatement */) { if (ts.isInAmbientContext(node)) { if (node.initializer) { // Error on equals token which immediate precedes the initializer @@ -23796,8 +24255,7 @@ var ts; // It is a Syntax Error if the BoundNames of ForDeclaration contains "let". // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code // and its Identifier is eval or arguments - return (checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name)) || - checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name); } function checkGrammarNameInLetOrConstDeclarations(name) { if (name.kind === 65 /* Identifier */) { @@ -23809,7 +24267,7 @@ var ts; var elements = name.elements; for (var _i = 0; _i < elements.length; _i++) { var element = elements[_i]; - if (element.kind !== 176 /* OmittedExpression */) { + if (element.kind !== 178 /* OmittedExpression */) { checkGrammarNameInLetOrConstDeclarations(element.name); } } @@ -23826,15 +24284,15 @@ var ts; } function allowLetAndConstDeclarations(parent) { switch (parent.kind) { - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 195 /* WithStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: return false; - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return allowLetAndConstDeclarations(parent.parent); } return true; @@ -23850,7 +24308,7 @@ var ts; } } function isIntegerLiteral(expression) { - if (expression.kind === 168 /* PrefixUnaryExpression */) { + if (expression.kind === 170 /* PrefixUnaryExpression */) { var unaryExpression = expression; if (unaryExpression.operator === 33 /* PlusToken */ || unaryExpression.operator === 34 /* MinusToken */) { expression = unaryExpression.operand; @@ -23879,7 +24337,7 @@ var ts; // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); } else if (inAmbientContext) { @@ -23921,26 +24379,6 @@ var ts; return true; } } - function checkGrammarEvalOrArgumentsInStrictMode(contextNode, name) { - if (name && name.kind === 65 /* Identifier */) { - var identifier = name; - if (contextNode && (contextNode.parserContextFlags & 1 /* StrictMode */) && isEvalOrArgumentsIdentifier(identifier)) { - var nameText = ts.declarationNameToString(identifier); - // We check first if the name is inside class declaration or class expression; if so give explicit message - // otherwise report generic error message. - // reportGrammarErrorInClassDeclaration only return true if grammar error is successfully reported and false otherwise - var reportErrorInClassDeclaration = reportStrictModeGrammarErrorInClassDeclaration(identifier, ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode, nameText); - if (!reportErrorInClassDeclaration) { - return grammarErrorOnNode(identifier, ts.Diagnostics.Invalid_use_of_0_in_strict_mode, nameText); - } - return reportErrorInClassDeclaration; - } - } - } - function isEvalOrArgumentsIdentifier(node) { - return node.kind === 65 /* Identifier */ && - (node.text === "eval" || node.text === "arguments"); - } function checkGrammarConstructorTypeParameters(node) { if (node.typeParameters) { return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration); @@ -23952,18 +24390,18 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.kind === 204 /* ClassDeclaration */) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 203 /* InterfaceDeclaration */) { + else if (node.parent.kind === 205 /* InterfaceDeclaration */) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 146 /* TypeLiteral */) { + else if (node.parent.kind === 148 /* TypeLiteral */) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { return true; } @@ -23983,11 +24421,11 @@ var ts; // export_opt ExternalImportDeclaration // export_opt AmbientDeclaration // - if (node.kind === 203 /* InterfaceDeclaration */ || - node.kind === 210 /* ImportDeclaration */ || - node.kind === 209 /* ImportEqualsDeclaration */ || - node.kind === 216 /* ExportDeclaration */ || - node.kind === 215 /* ExportAssignment */ || + if (node.kind === 205 /* InterfaceDeclaration */ || + node.kind === 212 /* ImportDeclaration */ || + node.kind === 211 /* ImportEqualsDeclaration */ || + node.kind === 218 /* ExportDeclaration */ || + node.kind === 217 /* ExportAssignment */ || (node.flags & 2 /* Ambient */) || (node.flags & (1 /* Export */ | 256 /* Default */))) { return false; @@ -23997,7 +24435,7 @@ var ts; function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { var decl = _a[_i]; - if (ts.isDeclaration(decl) || decl.kind === 181 /* VariableStatement */) { + if (ts.isDeclaration(decl) || decl.kind === 183 /* VariableStatement */) { if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { return true; } @@ -24023,7 +24461,7 @@ var ts; // to prevent noisyness. So use a bit on the block to indicate if // this has already been reported, and don't report if it has. // - if (node.parent.kind === 180 /* Block */ || node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + if (node.parent.kind === 182 /* Block */ || node.parent.kind === 209 /* ModuleBlock */ || node.parent.kind === 230 /* SourceFile */) { var links_1 = getNodeLinks(node.parent); // Check if the containing block ever report this error if (!links_1.hasReportedStatementInAmbientContext) { @@ -24036,13 +24474,8 @@ var ts; } function checkGrammarNumericLiteral(node) { // Grammar checking - if (node.flags & 16384 /* OctalLiteral */) { - if (node.parserContextFlags & 1 /* StrictMode */) { - return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode); - } - else if (languageVersion >= 1 /* ES5 */) { - return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); - } + if (node.flags & 16384 /* OctalLiteral */ && languageVersion >= 1 /* ES5 */) { + return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); } } function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) { @@ -24053,8 +24486,6 @@ var ts; return true; } } - initializeTypeChecker(); - return checker; } ts.createTypeChecker = createTypeChecker; })(ts || (ts = {})); @@ -24113,7 +24544,7 @@ var ts; var oldWriter = writer; ts.forEach(moduleElementDeclarationEmitInfo, function (aliasEmitInfo) { if (aliasEmitInfo.isVisible) { - ts.Debug.assert(aliasEmitInfo.node.kind === 210 /* ImportDeclaration */); + ts.Debug.assert(aliasEmitInfo.node.kind === 212 /* ImportDeclaration */); createAndSetNewTextWriterWithSymbolWriter(); ts.Debug.assert(aliasEmitInfo.indent === 0); writeImportDeclaration(aliasEmitInfo.node); @@ -24189,10 +24620,10 @@ var ts; var oldWriter = writer; ts.forEach(nodes, function (declaration) { var nodeToCheck; - if (declaration.kind === 199 /* VariableDeclaration */) { + if (declaration.kind === 201 /* VariableDeclaration */) { nodeToCheck = declaration.parent.parent; } - else if (declaration.kind === 213 /* NamedImports */ || declaration.kind === 214 /* ImportSpecifier */ || declaration.kind === 211 /* ImportClause */) { + else if (declaration.kind === 215 /* NamedImports */ || declaration.kind === 216 /* ImportSpecifier */ || declaration.kind === 213 /* ImportClause */) { ts.Debug.fail("We should be getting ImportDeclaration instead to write"); } else { @@ -24210,7 +24641,7 @@ var ts; // Writing of function bar would mark alias declaration foo as visible but we haven't yet visited that declaration so do nothing, // we would write alias foo declaration when we visit it since it would now be marked as visible if (moduleElementEmitInfo) { - if (moduleElementEmitInfo.node.kind === 210 /* ImportDeclaration */) { + if (moduleElementEmitInfo.node.kind === 212 /* ImportDeclaration */) { // we have to create asynchronous output only after we have collected complete information // because it is possible to enable multiple bindings as asynchronously visible moduleElementEmitInfo.isVisible = true; @@ -24220,12 +24651,12 @@ var ts; for (var declarationIndent = moduleElementEmitInfo.indent; declarationIndent; declarationIndent--) { increaseIndent(); } - if (nodeToCheck.kind === 206 /* ModuleDeclaration */) { + if (nodeToCheck.kind === 208 /* ModuleDeclaration */) { ts.Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined); asynchronousSubModuleDeclarationEmitInfo = []; } writeModuleElement(nodeToCheck); - if (nodeToCheck.kind === 206 /* ModuleDeclaration */) { + if (nodeToCheck.kind === 208 /* ModuleDeclaration */) { moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo; asynchronousSubModuleDeclarationEmitInfo = undefined; } @@ -24318,41 +24749,41 @@ var ts; function emitType(type) { switch (type.kind) { case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: + case 123 /* StringKeyword */: + case 121 /* NumberKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: case 99 /* VoidKeyword */: case 8 /* StringLiteral */: return writeTextOfNode(currentSourceFile, type); - case 177 /* ExpressionWithTypeArguments */: + case 179 /* ExpressionWithTypeArguments */: return emitExpressionWithTypeArguments(type); - case 142 /* TypeReference */: + case 144 /* TypeReference */: return emitTypeReference(type); - case 145 /* TypeQuery */: + case 147 /* TypeQuery */: return emitTypeQuery(type); - case 147 /* ArrayType */: + case 149 /* ArrayType */: return emitArrayType(type); - case 148 /* TupleType */: + case 150 /* TupleType */: return emitTupleType(type); - case 149 /* UnionType */: + case 151 /* UnionType */: return emitUnionType(type); - case 150 /* ParenthesizedType */: + case 152 /* ParenthesizedType */: return emitParenType(type); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return emitSignatureDeclarationWithJsDocComments(type); - case 146 /* TypeLiteral */: + case 148 /* TypeLiteral */: return emitTypeLiteral(type); case 65 /* Identifier */: return emitEntityName(type); - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: return emitEntityName(type); } function emitEntityName(entityName) { var visibilityResult = resolver.isEntityNameVisible(entityName, // Aliases can be written asynchronously so use correct enclosing declaration - entityName.parent.kind === 209 /* ImportEqualsDeclaration */ ? entityName.parent : enclosingDeclaration); + entityName.parent.kind === 211 /* ImportEqualsDeclaration */ ? entityName.parent : enclosingDeclaration); handleSymbolAccessibilityError(visibilityResult); writeEntityName(entityName); function writeEntityName(entityName) { @@ -24360,8 +24791,8 @@ var ts; writeTextOfNode(currentSourceFile, entityName); } else { - var left = entityName.kind === 127 /* QualifiedName */ ? entityName.left : entityName.expression; - var right = entityName.kind === 127 /* QualifiedName */ ? entityName.right : entityName.name; + var left = entityName.kind === 128 /* QualifiedName */ ? entityName.left : entityName.expression; + var right = entityName.kind === 128 /* QualifiedName */ ? entityName.right : entityName.name; writeEntityName(left); write("."); writeTextOfNode(currentSourceFile, right); @@ -24370,7 +24801,7 @@ var ts; } function emitExpressionWithTypeArguments(node) { if (ts.isSupportedExpressionWithTypeArguments(node)) { - ts.Debug.assert(node.expression.kind === 65 /* Identifier */ || node.expression.kind === 156 /* PropertyAccessExpression */); + ts.Debug.assert(node.expression.kind === 65 /* Identifier */ || node.expression.kind === 158 /* PropertyAccessExpression */); emitEntityName(node.expression); if (node.typeArguments) { write("<"); @@ -24436,9 +24867,9 @@ var ts; } var count = 0; while (true) { - var name_18 = baseName + "_" + (++count); - if (!ts.hasProperty(currentSourceFile.identifiers, name_18)) { - return name_18; + var name_16 = baseName + "_" + (++count); + if (!ts.hasProperty(currentSourceFile.identifiers, name_16)) { + return name_16; } } } @@ -24482,10 +24913,10 @@ var ts; if (isModuleElementVisible) { writeModuleElement(node); } - else if (node.kind === 209 /* ImportEqualsDeclaration */ || - (node.parent.kind === 228 /* SourceFile */ && ts.isExternalModule(currentSourceFile))) { + else if (node.kind === 211 /* ImportEqualsDeclaration */ || + (node.parent.kind === 230 /* SourceFile */ && ts.isExternalModule(currentSourceFile))) { var isVisible; - if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 228 /* SourceFile */) { + if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 230 /* SourceFile */) { // Import declaration of another module that is visited async so lets put it in right spot asynchronousSubModuleDeclarationEmitInfo.push({ node: node, @@ -24495,7 +24926,7 @@ var ts; }); } else { - if (node.kind === 210 /* ImportDeclaration */) { + if (node.kind === 212 /* ImportDeclaration */) { var importDeclaration = node; if (importDeclaration.importClause) { isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) || @@ -24513,23 +24944,23 @@ var ts; } function writeModuleElement(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return writeFunctionDeclaration(node); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return writeVariableStatement(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return writeInterfaceDeclaration(node); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return writeClassDeclaration(node); - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: return writeTypeAliasDeclaration(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return writeEnumDeclaration(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return writeModuleDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return writeImportEqualsDeclaration(node); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: return writeImportDeclaration(node); default: ts.Debug.fail("Unknown symbol kind"); @@ -24545,7 +24976,7 @@ var ts; if (node.flags & 256 /* Default */) { write("default "); } - else if (node.kind !== 203 /* InterfaceDeclaration */) { + else if (node.kind !== 205 /* InterfaceDeclaration */) { write("declare "); } } @@ -24591,7 +25022,7 @@ var ts; } function isVisibleNamedBinding(namedBindings) { if (namedBindings) { - if (namedBindings.kind === 212 /* NamespaceImport */) { + if (namedBindings.kind === 214 /* NamespaceImport */) { return resolver.isDeclarationVisible(namedBindings); } else { @@ -24619,7 +25050,7 @@ var ts; // If the default binding was emitted, write the separated write(", "); } - if (node.importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (node.importClause.namedBindings.kind === 214 /* NamespaceImport */) { write("* as "); writeTextOfNode(currentSourceFile, node.importClause.namedBindings.name); } @@ -24670,9 +25101,14 @@ var ts; function writeModuleDeclaration(node) { emitJsDocComments(node); emitModuleElementDeclarationFlags(node); - write("module "); + if (node.flags & 32768 /* Namespace */) { + write("namespace "); + } + else { + write("module "); + } writeTextOfNode(currentSourceFile, node.name); - while (node.body.kind !== 207 /* ModuleBlock */) { + while (node.body.kind !== 209 /* ModuleBlock */) { node = node.body; write("."); writeTextOfNode(currentSourceFile, node.name); @@ -24733,7 +25169,7 @@ var ts; writeLine(); } function isPrivateMethodTypeParameter(node) { - return node.parent.kind === 135 /* MethodDeclaration */ && (node.parent.flags & 32 /* Private */); + return node.parent.kind === 136 /* MethodDeclaration */ && (node.parent.flags & 32 /* Private */); } function emitTypeParameters(typeParameters) { function emitTypeParameter(node) { @@ -24744,15 +25180,15 @@ var ts; // If there is constraint present and this is not a type parameter of the private method emit the constraint if (node.constraint && !isPrivateMethodTypeParameter(node)) { write(" extends "); - if (node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - (node.parent.parent && node.parent.parent.kind === 146 /* TypeLiteral */)) { - ts.Debug.assert(node.parent.kind === 135 /* MethodDeclaration */ || - node.parent.kind === 134 /* MethodSignature */ || - node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - node.parent.kind === 139 /* CallSignature */ || - node.parent.kind === 140 /* ConstructSignature */); + if (node.parent.kind === 145 /* FunctionType */ || + node.parent.kind === 146 /* ConstructorType */ || + (node.parent.parent && node.parent.parent.kind === 148 /* TypeLiteral */)) { + ts.Debug.assert(node.parent.kind === 136 /* MethodDeclaration */ || + node.parent.kind === 135 /* MethodSignature */ || + node.parent.kind === 145 /* FunctionType */ || + node.parent.kind === 146 /* ConstructorType */ || + node.parent.kind === 140 /* CallSignature */ || + node.parent.kind === 141 /* ConstructSignature */); emitType(node.constraint); } else { @@ -24763,31 +25199,31 @@ var ts; // Type parameter constraints are named by user so we should always be able to name it var diagnosticMessage; switch (node.parent.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; break; - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; break; - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 139 /* CallSignature */: + case 140 /* CallSignature */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (node.parent.flags & 128 /* Static */) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.parent.kind === 204 /* ClassDeclaration */) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } break; - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -24818,7 +25254,7 @@ var ts; function getHeritageClauseVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; // Heritage clause is written by user so it can always be named - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.parent.kind === 204 /* ClassDeclaration */) { // Class or Interface implemented/extended is inaccessible diagnosticMessage = isImplementsList ? ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : @@ -24899,7 +25335,7 @@ var ts; function emitVariableDeclaration(node) { // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted // so there is no check needed to see if declaration is visible - if (node.kind !== 199 /* VariableDeclaration */ || resolver.isDeclarationVisible(node)) { + if (node.kind !== 201 /* VariableDeclaration */ || resolver.isDeclarationVisible(node)) { if (ts.isBindingPattern(node.name)) { emitBindingPattern(node.name); } @@ -24909,10 +25345,10 @@ var ts; // what we want, namely the name expression enclosed in brackets. writeTextOfNode(currentSourceFile, node.name); // If optional property emit ? - if ((node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) && ts.hasQuestionToken(node)) { + if ((node.kind === 134 /* PropertyDeclaration */ || node.kind === 133 /* PropertySignature */) && ts.hasQuestionToken(node)) { write("?"); } - if ((node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) && node.parent.kind === 146 /* TypeLiteral */) { + if ((node.kind === 134 /* PropertyDeclaration */ || node.kind === 133 /* PropertySignature */) && node.parent.kind === 148 /* TypeLiteral */) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.flags & 32 /* Private */)) { @@ -24921,14 +25357,14 @@ var ts; } } function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { - if (node.kind === 199 /* VariableDeclaration */) { + if (node.kind === 201 /* VariableDeclaration */) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1; } - else if (node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) { + else if (node.kind === 134 /* PropertyDeclaration */ || node.kind === 133 /* PropertySignature */) { // TODO(jfreeman): Deal with computed properties in error reporting. if (node.flags & 128 /* Static */) { return symbolAccesibilityResult.errorModuleName ? @@ -24937,7 +25373,7 @@ var ts; ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 204 /* ClassDeclaration */) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -24969,7 +25405,7 @@ var ts; var elements = []; for (var _i = 0, _a = bindingPattern.elements; _i < _a.length; _i++) { var element = _a[_i]; - if (element.kind !== 176 /* OmittedExpression */) { + if (element.kind !== 178 /* OmittedExpression */) { elements.push(element); } } @@ -25039,7 +25475,7 @@ var ts; var type = getTypeAnnotationFromAccessor(node); if (!type) { // couldn't get type for the first accessor, try the another one - var anotherAccessor = node.kind === 137 /* GetAccessor */ ? accessors.setAccessor : accessors.getAccessor; + var anotherAccessor = node.kind === 138 /* GetAccessor */ ? accessors.setAccessor : accessors.getAccessor; type = getTypeAnnotationFromAccessor(anotherAccessor); if (type) { accessorWithTypeAnnotation = anotherAccessor; @@ -25052,7 +25488,7 @@ var ts; } function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 137 /* GetAccessor */ + return accessor.kind === 138 /* GetAccessor */ ? accessor.type // Getter - return type : accessor.parameters.length > 0 ? accessor.parameters[0].type // Setter parameter type @@ -25061,7 +25497,7 @@ var ts; } function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (accessorWithTypeAnnotation.kind === 138 /* SetAccessor */) { + if (accessorWithTypeAnnotation.kind === 139 /* SetAccessor */) { // Setters have to have type named and cannot infer it so, the type should always be named if (accessorWithTypeAnnotation.parent.flags & 128 /* Static */) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? @@ -25111,17 +25547,17 @@ var ts; // so no need to verify if the declaration is visible if (!resolver.isImplementationOfOverload(node)) { emitJsDocComments(node); - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 203 /* FunctionDeclaration */) { emitModuleElementDeclarationFlags(node); } - else if (node.kind === 135 /* MethodDeclaration */) { + else if (node.kind === 136 /* MethodDeclaration */) { emitClassMemberDeclarationFlags(node); } - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 203 /* FunctionDeclaration */) { write("function "); writeTextOfNode(currentSourceFile, node.name); } - else if (node.kind === 136 /* Constructor */) { + else if (node.kind === 137 /* Constructor */) { write("constructor"); } else { @@ -25139,11 +25575,11 @@ var ts; } function emitSignatureDeclaration(node) { // Construct signature or constructor type write new Signature - if (node.kind === 140 /* ConstructSignature */ || node.kind === 144 /* ConstructorType */) { + if (node.kind === 141 /* ConstructSignature */ || node.kind === 146 /* ConstructorType */) { write("new "); } emitTypeParameters(node.typeParameters); - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 142 /* IndexSignature */) { write("["); } else { @@ -25153,22 +25589,22 @@ var ts; enclosingDeclaration = node; // Parameters emitCommaList(node.parameters, emitParameterDeclaration); - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 142 /* IndexSignature */) { write("]"); } else { write(")"); } // If this is not a constructor and is not private, emit the return type - var isFunctionTypeOrConstructorType = node.kind === 143 /* FunctionType */ || node.kind === 144 /* ConstructorType */; - if (isFunctionTypeOrConstructorType || node.parent.kind === 146 /* TypeLiteral */) { + var isFunctionTypeOrConstructorType = node.kind === 145 /* FunctionType */ || node.kind === 146 /* ConstructorType */; + if (isFunctionTypeOrConstructorType || node.parent.kind === 148 /* TypeLiteral */) { // Emit type literal signature return type only if specified if (node.type) { write(isFunctionTypeOrConstructorType ? " => " : ": "); emitType(node.type); } } - else if (node.kind !== 136 /* Constructor */ && !(node.flags & 32 /* Private */)) { + else if (node.kind !== 137 /* Constructor */ && !(node.flags & 32 /* Private */)) { writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); } enclosingDeclaration = prevEnclosingDeclaration; @@ -25179,26 +25615,26 @@ var ts; function getReturnTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.kind) { - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: // Interfaces cannot have return types that cannot be named diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 139 /* CallSignature */: + case 140 /* CallSignature */: // Interfaces cannot have return types that cannot be named diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: // Interfaces cannot have return types that cannot be named diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (node.flags & 128 /* Static */) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? @@ -25206,7 +25642,7 @@ var ts; ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0; } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 204 /* ClassDeclaration */) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : @@ -25220,7 +25656,7 @@ var ts; ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; } break; - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : @@ -25255,9 +25691,9 @@ var ts; write("?"); } decreaseIndent(); - if (node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - node.parent.parent.kind === 146 /* TypeLiteral */) { + if (node.parent.kind === 145 /* FunctionType */ || + node.parent.kind === 146 /* ConstructorType */ || + node.parent.parent.kind === 148 /* TypeLiteral */) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.parent.flags & 32 /* Private */)) { @@ -25273,24 +25709,24 @@ var ts; } function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { switch (node.parent.kind) { - case 136 /* Constructor */: + case 137 /* Constructor */: return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1; - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: // Interfaces cannot have parameter types that cannot be named return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; - case 139 /* CallSignature */: + case 140 /* CallSignature */: // Interfaces cannot have parameter types that cannot be named return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (node.parent.flags & 128 /* Static */) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? @@ -25298,7 +25734,7 @@ var ts; ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.parent.kind === 204 /* ClassDeclaration */) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -25311,7 +25747,7 @@ var ts; ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -25323,12 +25759,12 @@ var ts; } function emitBindingPattern(bindingPattern) { // We have to explicitly emit square bracket and bracket because these tokens are not store inside the node. - if (bindingPattern.kind === 151 /* ObjectBindingPattern */) { + if (bindingPattern.kind === 153 /* ObjectBindingPattern */) { write("{"); emitCommaList(bindingPattern.elements, emitBindingElement); write("}"); } - else if (bindingPattern.kind === 152 /* ArrayBindingPattern */) { + else if (bindingPattern.kind === 154 /* ArrayBindingPattern */) { write("["); var elements = bindingPattern.elements; emitCommaList(elements, emitBindingElement); @@ -25347,7 +25783,7 @@ var ts; typeName: bindingElement.name } : undefined; } - if (bindingElement.kind === 176 /* OmittedExpression */) { + if (bindingElement.kind === 178 /* OmittedExpression */) { // If bindingElement is an omittedExpression (i.e. containing elision), // we will emit blank space (although this may differ from users' original code, // it allows emitSeparatedList to write separator appropriately) @@ -25356,7 +25792,7 @@ var ts; // emit : function foo([ , x, , ]) {} write(" "); } - else if (bindingElement.kind === 153 /* BindingElement */) { + else if (bindingElement.kind === 155 /* BindingElement */) { if (bindingElement.propertyName) { // bindingElement has propertyName property in the following case: // { y: [a,b,c] ...} -> bindingPattern will have a property called propertyName for "y" @@ -25397,40 +25833,40 @@ var ts; } function emitNode(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 203 /* InterfaceDeclaration */: - case 202 /* ClassDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: + case 203 /* FunctionDeclaration */: + case 208 /* ModuleDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 205 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 207 /* EnumDeclaration */: return emitModuleElement(node, isModuleElementVisible(node)); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return emitModuleElement(node, isVariableStatementVisible(node)); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: // Import declaration without import clause is visible, otherwise it is not visible return emitModuleElement(node, !node.importClause); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return emitExportDeclaration(node); - case 136 /* Constructor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 137 /* Constructor */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return writeFunctionDeclaration(node); - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 141 /* IndexSignature */: + case 141 /* ConstructSignature */: + case 140 /* CallSignature */: + case 142 /* IndexSignature */: return emitSignatureDeclarationWithJsDocComments(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return emitAccessorDeclaration(node); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return emitPropertyDeclaration(node); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return emitEnumMemberDeclaration(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return emitExportAssignment(node); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return emitSourceFile(node); } } @@ -25491,7 +25927,7 @@ var ts; // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature function emitFiles(resolver, host, targetSourceFile) { // emit output for the __extends helper function - var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n __.prototype = b.prototype;\n d.prototype = new __();\n};"; + var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};"; // emit output for the __decorate helper function var decorateHelper = "\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") return Reflect.decorate(decorators, target, key, desc);\n switch (arguments.length) {\n case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);\n case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);\n case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);\n }\n};"; // emit output for the __metadata helper function @@ -25567,7 +26003,6 @@ var ts; var exportFunctionForFile; var generatedNameSet = {}; var nodeToGeneratedName = []; - var blockScopedVariableToGeneratedName; var computedPropertyNamesToGeneratedNames; var extendsEmitted = false; var decorateEmitted = false; @@ -25647,9 +26082,9 @@ var ts; tempFlags++; // Skip over 'i' and 'n' if (count !== 8 && count !== 13) { - var name_19 = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26); - if (isUniqueName(name_19)) { - return name_19; + var name_17 = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26); + if (isUniqueName(name_17)) { + return name_17; } } } @@ -25672,73 +26107,40 @@ var ts; i++; } } - function assignGeneratedName(node, name) { - nodeToGeneratedName[ts.getNodeId(node)] = ts.unescapeIdentifier(name); - } - function generateNameForFunctionOrClassDeclaration(node) { - if (!node.name) { - assignGeneratedName(node, makeUniqueName("default")); - } - } function generateNameForModuleOrEnum(node) { - if (node.name.kind === 65 /* Identifier */) { - var name_20 = node.name.text; - // Use module/enum name itself if it is unique, otherwise make a unique variation - assignGeneratedName(node, isUniqueLocalName(name_20, node) ? name_20 : makeUniqueName(name_20)); - } + var name = node.name.text; + // Use module/enum name itself if it is unique, otherwise make a unique variation + return isUniqueLocalName(name, node) ? name : makeUniqueName(name); } function generateNameForImportOrExportDeclaration(node) { var expr = ts.getExternalModuleName(node); var baseName = expr.kind === 8 /* StringLiteral */ ? ts.escapeIdentifier(ts.makeIdentifierFromModuleName(expr.text)) : "module"; - assignGeneratedName(node, makeUniqueName(baseName)); + return makeUniqueName(baseName); } - function generateNameForImportDeclaration(node) { - if (node.importClause) { - generateNameForImportOrExportDeclaration(node); - } - } - function generateNameForExportDeclaration(node) { - if (node.moduleSpecifier) { - generateNameForImportOrExportDeclaration(node); - } - } - function generateNameForExportAssignment(node) { - if (node.expression && node.expression.kind !== 65 /* Identifier */) { - assignGeneratedName(node, makeUniqueName("default")); - } + function generateNameForExportDefault() { + return makeUniqueName("default"); } function generateNameForNode(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: - generateNameForFunctionOrClassDeclaration(node); - break; - case 206 /* ModuleDeclaration */: - generateNameForModuleOrEnum(node); - generateNameForNode(node.body); - break; - case 205 /* EnumDeclaration */: - generateNameForModuleOrEnum(node); - break; - case 210 /* ImportDeclaration */: - generateNameForImportDeclaration(node); - break; - case 216 /* ExportDeclaration */: - generateNameForExportDeclaration(node); - break; - case 215 /* ExportAssignment */: - generateNameForExportAssignment(node); - break; + case 65 /* Identifier */: + return makeUniqueName(node.text); + case 208 /* ModuleDeclaration */: + case 207 /* EnumDeclaration */: + return generateNameForModuleOrEnum(node); + case 212 /* ImportDeclaration */: + case 218 /* ExportDeclaration */: + return generateNameForImportOrExportDeclaration(node); + case 203 /* FunctionDeclaration */: + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + case 217 /* ExportAssignment */: + return generateNameForExportDefault(); } } function getGeneratedNameForNode(node) { - var nodeId = ts.getNodeId(node); - if (!nodeToGeneratedName[nodeId]) { - generateNameForNode(node); - } - return nodeToGeneratedName[nodeId]; + var id = ts.getNodeId(node); + return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = ts.unescapeIdentifier(generateNameForNode(node))); } function initializeEmitterWithSourceMaps() { var sourceMapDir; // The directory in which sourcemap will be @@ -25767,7 +26169,7 @@ var ts; } var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; // Line/Comma delimiters - if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) { + if (lastEncodedSourceMapSpan.emittedLine === lastRecordedSourceMapSpan.emittedLine) { // Emit comma to separate the entry if (sourceMapData.sourceMapMappings) { sourceMapData.sourceMapMappings += ","; @@ -25836,8 +26238,8 @@ var ts; var emittedColumn = writer.getColumn(); // If this location wasn't recorded or the location in source is going backwards, record the span if (!lastRecordedSourceMapSpan || - lastRecordedSourceMapSpan.emittedLine != emittedLine || - lastRecordedSourceMapSpan.emittedColumn != emittedColumn || + lastRecordedSourceMapSpan.emittedLine !== emittedLine || + lastRecordedSourceMapSpan.emittedColumn !== emittedColumn || (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex && (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line || (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) { @@ -25903,8 +26305,8 @@ var ts; // Child scopes are always shown with a dot (even if they have no name), // unless it is a computed property. Then it is shown with brackets, // but the brackets are included in the name. - var name_21 = node.name; - if (!name_21 || name_21.kind !== 128 /* ComputedPropertyName */) { + var name_18 = node.name; + if (!name_18 || name_18.kind !== 129 /* ComputedPropertyName */) { scopeName = "." + scopeName; } scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; @@ -25922,21 +26324,21 @@ var ts; // The scope was already given a name use it recordScopeNameStart(scopeName); } - else if (node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */ || - node.kind === 135 /* MethodDeclaration */ || - node.kind === 134 /* MethodSignature */ || - node.kind === 137 /* GetAccessor */ || - node.kind === 138 /* SetAccessor */ || - node.kind === 206 /* ModuleDeclaration */ || - node.kind === 202 /* ClassDeclaration */ || - node.kind === 205 /* EnumDeclaration */) { + else if (node.kind === 203 /* FunctionDeclaration */ || + node.kind === 165 /* FunctionExpression */ || + node.kind === 136 /* MethodDeclaration */ || + node.kind === 135 /* MethodSignature */ || + node.kind === 138 /* GetAccessor */ || + node.kind === 139 /* SetAccessor */ || + node.kind === 208 /* ModuleDeclaration */ || + node.kind === 204 /* ClassDeclaration */ || + node.kind === 207 /* EnumDeclaration */) { // Declaration and has associated name use it if (node.name) { - var name_22 = node.name; + var name_19 = node.name; // For computed property names, the text will include the brackets - scopeName = name_22.kind === 128 /* ComputedPropertyName */ - ? ts.getTextOfNode(name_22) + scopeName = name_19.kind === 129 /* ComputedPropertyName */ + ? ts.getTextOfNode(name_19) : node.name.text; } recordScopeNameStart(scopeName); @@ -26040,19 +26442,19 @@ var ts; else { sourceMapDir = ts.getDirectoryPath(ts.normalizePath(jsFilePath)); } - function emitNodeWithSourceMap(node, allowGeneratedIdentifiers) { + function emitNodeWithSourceMap(node) { if (node) { if (ts.nodeIsSynthesized(node)) { - return emitNodeWithoutSourceMap(node, false); + return emitNodeWithoutSourceMap(node); } - if (node.kind != 228 /* SourceFile */) { + if (node.kind !== 230 /* SourceFile */) { recordEmitNodeStartSpan(node); - emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers); + emitNodeWithoutSourceMap(node); recordEmitNodeEndSpan(node); } else { recordNewSourceFileStart(node); - emitNodeWithoutSourceMap(node, false); + emitNodeWithoutSourceMap(node); } } } @@ -26308,10 +26710,10 @@ var ts; write("("); emit(tempVariable); // Now we emit the expressions - if (node.template.kind === 172 /* TemplateExpression */) { + if (node.template.kind === 174 /* TemplateExpression */) { ts.forEach(node.template.templateSpans, function (templateSpan) { write(", "); - var needsParens = templateSpan.expression.kind === 170 /* BinaryExpression */ + var needsParens = templateSpan.expression.kind === 172 /* BinaryExpression */ && templateSpan.expression.operatorToken.kind === 23 /* CommaToken */; emitParenthesizedIf(templateSpan.expression, needsParens); }); @@ -26346,7 +26748,7 @@ var ts; // ("abc" + 1) << (2 + "") // rather than // "abc" + (1 << 2) + "" - var needsParens = templateSpan.expression.kind !== 162 /* ParenthesizedExpression */ + var needsParens = templateSpan.expression.kind !== 164 /* ParenthesizedExpression */ && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1 /* GreaterThan */; if (i > 0 || headEmitted) { // If this is the first span and the head was not emitted, then this templateSpan's @@ -26388,11 +26790,11 @@ var ts; } function templateNeedsParens(template, parent) { switch (parent.kind) { - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return parent.expression === template; - case 160 /* TaggedTemplateExpression */: - case 162 /* ParenthesizedExpression */: + case 162 /* TaggedTemplateExpression */: + case 164 /* ParenthesizedExpression */: return false; default: return comparePrecedenceToBinaryPlus(parent) !== -1 /* LessThan */; @@ -26413,7 +26815,7 @@ var ts; // TODO (drosen): Note that we need to account for the upcoming 'yield' and // spread ('...') unary operators that are anticipated for ES6. switch (expression.kind) { - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: switch (expression.operatorToken.kind) { case 35 /* AsteriskToken */: case 36 /* SlashToken */: @@ -26425,8 +26827,8 @@ var ts; default: return -1 /* LessThan */; } - case 173 /* YieldExpression */: - case 171 /* ConditionalExpression */: + case 175 /* YieldExpression */: + case 173 /* ConditionalExpression */: return -1 /* LessThan */; default: return 1 /* GreaterThan */; @@ -26441,11 +26843,11 @@ var ts; // In a sense, it does not actually emit identifiers as much as it declares a name for a specific property. // For example, this is utilized when feeding in a result to Object.defineProperty. function emitExpressionForPropertyName(node) { - ts.Debug.assert(node.kind !== 153 /* BindingElement */); + ts.Debug.assert(node.kind !== 155 /* BindingElement */); if (node.kind === 8 /* StringLiteral */) { emitLiteral(node); } - else if (node.kind === 128 /* ComputedPropertyName */) { + else if (node.kind === 129 /* ComputedPropertyName */) { // if this is a decorated computed property, we will need to capture the result // of the property expression so that we can apply decorators later. This is to ensure // we don't introduce unintended side effects: @@ -26486,75 +26888,126 @@ var ts; write("\""); } } - function isNotExpressionIdentifier(node) { + function isExpressionIdentifier(node) { var parent = node.parent; switch (parent.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 201 /* FunctionDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - return parent.name === node; - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: - return parent.name === node || parent.propertyName === node; - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 215 /* ExportAssignment */: - return false; - case 195 /* LabeledStatement */: - return node.parent.label === node; + case 156 /* ArrayLiteralExpression */: + case 172 /* BinaryExpression */: + case 160 /* CallExpression */: + case 223 /* CaseClause */: + case 129 /* ComputedPropertyName */: + case 173 /* ConditionalExpression */: + case 132 /* Decorator */: + case 167 /* DeleteExpression */: + case 187 /* DoStatement */: + case 159 /* ElementAccessExpression */: + case 217 /* ExportAssignment */: + case 185 /* ExpressionStatement */: + case 179 /* ExpressionWithTypeArguments */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 186 /* IfStatement */: + case 161 /* NewExpression */: + case 164 /* ParenthesizedExpression */: + case 171 /* PostfixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: + case 194 /* ReturnStatement */: + case 228 /* ShorthandPropertyAssignment */: + case 176 /* SpreadElementExpression */: + case 196 /* SwitchStatement */: + case 162 /* TaggedTemplateExpression */: + case 180 /* TemplateSpan */: + case 198 /* ThrowStatement */: + case 163 /* TypeAssertionExpression */: + case 168 /* TypeOfExpression */: + case 169 /* VoidExpression */: + case 188 /* WhileStatement */: + case 195 /* WithStatement */: + case 175 /* YieldExpression */: + return true; + case 155 /* BindingElement */: + case 229 /* EnumMember */: + case 131 /* Parameter */: + case 227 /* PropertyAssignment */: + case 134 /* PropertyDeclaration */: + case 201 /* VariableDeclaration */: + return parent.initializer === node; + case 158 /* PropertyAccessExpression */: + return parent.expression === node; + case 166 /* ArrowFunction */: + case 165 /* FunctionExpression */: + return parent.body === node; + case 211 /* ImportEqualsDeclaration */: + return parent.moduleReference === node; + case 128 /* QualifiedName */: + return parent.left === node; } + return false; } function emitExpressionIdentifier(node) { - var substitution = resolver.getExpressionNameSubstitution(node, getGeneratedNameForNode); - if (substitution) { - write(substitution); + var container = resolver.getReferencedExportContainer(node); + if (container) { + if (container.kind === 230 /* SourceFile */) { + // Identifier references module export + if (languageVersion < 2 /* ES6 */ && compilerOptions.module !== 4 /* System */) { + write("exports."); + } + } + else { + // Identifier references namespace export + write(getGeneratedNameForNode(container)); + write("."); + } } - else { - writeTextOfNode(currentSourceFile, node); - } - } - function getGeneratedNameForIdentifier(node) { - if (ts.nodeIsSynthesized(node) || !blockScopedVariableToGeneratedName) { - return undefined; - } - var variableId = resolver.getBlockScopedVariableId(node); - if (variableId === undefined) { - return undefined; - } - return blockScopedVariableToGeneratedName[variableId]; - } - function emitIdentifier(node, allowGeneratedIdentifiers) { - if (allowGeneratedIdentifiers) { - var generatedName = getGeneratedNameForIdentifier(node); - if (generatedName) { - write(generatedName); + else if (languageVersion < 2 /* ES6 */) { + var declaration = resolver.getReferencedImportDeclaration(node); + if (declaration) { + if (declaration.kind === 213 /* ImportClause */) { + // Identifier references default import + write(getGeneratedNameForNode(declaration.parent)); + write(languageVersion === 0 /* ES3 */ ? '["default"]' : ".default"); + return; + } + else if (declaration.kind === 216 /* ImportSpecifier */) { + // Identifier references named import + write(getGeneratedNameForNode(declaration.parent.parent.parent)); + write("."); + writeTextOfNode(currentSourceFile, declaration.propertyName || declaration.name); + return; + } + } + declaration = resolver.getReferencedNestedRedeclaration(node); + if (declaration) { + write(getGeneratedNameForNode(declaration.name)); return; } } + writeTextOfNode(currentSourceFile, node); + } + function isNameOfNestedRedeclaration(node) { + if (languageVersion < 2 /* ES6 */) { + var parent_7 = node.parent; + switch (parent_7.kind) { + case 155 /* BindingElement */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 201 /* VariableDeclaration */: + return parent_7.name === node && resolver.isNestedRedeclaration(parent_7); + } + } + return false; + } + function emitIdentifier(node) { if (!node.parent) { write(node.text); } - else if (!isNotExpressionIdentifier(node)) { + else if (isExpressionIdentifier(node)) { emitExpressionIdentifier(node); } + else if (isNameOfNestedRedeclaration(node)) { + write(getGeneratedNameForNode(node)); + } else { writeTextOfNode(currentSourceFile, node); } @@ -26595,7 +27048,7 @@ var ts; } function emitBindingElement(node) { if (node.propertyName) { - emit(node.propertyName, false); + emit(node.propertyName); write(": "); } if (node.dotDotDotToken) { @@ -26626,11 +27079,11 @@ var ts; function needsParenthesisForPropertyAccessOrInvocation(node) { switch (node.kind) { case 65 /* Identifier */: - case 154 /* ArrayLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 162 /* ParenthesizedExpression */: + case 156 /* ArrayLiteralExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 160 /* CallExpression */: + case 164 /* ParenthesizedExpression */: // This list is not exhaustive and only includes those cases that are relevant // to the check in emitArrayLiteral. More cases can be added as needed. return false; @@ -26650,17 +27103,17 @@ var ts; write(", "); } var e = elements[pos]; - if (e.kind === 174 /* SpreadElementExpression */) { + if (e.kind === 176 /* SpreadElementExpression */) { e = e.expression; emitParenthesizedIf(e, group === 0 && needsParenthesisForPropertyAccessOrInvocation(e)); pos++; - if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 154 /* ArrayLiteralExpression */) { + if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 156 /* ArrayLiteralExpression */) { write(".slice()"); } } else { var i = pos; - while (i < length && elements[i].kind !== 174 /* SpreadElementExpression */) { + while (i < length && elements[i].kind !== 176 /* SpreadElementExpression */) { i++; } write("["); @@ -26683,7 +27136,7 @@ var ts; } } function isSpreadElementExpression(node) { - return node.kind === 174 /* SpreadElementExpression */; + return node.kind === 176 /* SpreadElementExpression */; } function emitArrayLiteral(node) { var elements = node.elements; @@ -26753,7 +27206,7 @@ var ts; writeComma(); var property = properties[i]; emitStart(property); - if (property.kind === 137 /* GetAccessor */ || property.kind === 138 /* SetAccessor */) { + if (property.kind === 138 /* GetAccessor */ || property.kind === 139 /* SetAccessor */) { // TODO (drosen): Reconcile with 'emitMemberFunctions'. var accessors = ts.getAllAccessorDeclarations(node.properties, property); if (property !== accessors.firstAccessor) { @@ -26805,13 +27258,13 @@ var ts; emitMemberAccessForPropertyName(property.name); emitEnd(property.name); write(" = "); - if (property.kind === 225 /* PropertyAssignment */) { + if (property.kind === 227 /* PropertyAssignment */) { emit(property.initializer); } - else if (property.kind === 226 /* ShorthandPropertyAssignment */) { + else if (property.kind === 228 /* ShorthandPropertyAssignment */) { emitExpressionIdentifier(property.name); } - else if (property.kind === 135 /* MethodDeclaration */) { + else if (property.kind === 136 /* MethodDeclaration */) { emitFunctionDeclaration(property); } else { @@ -26845,7 +27298,7 @@ var ts; // Everything until that point can be emitted as part of the initial object literal. var numInitialNonComputedProperties = numProperties; for (var i = 0, n = properties.length; i < n; i++) { - if (properties[i].name.kind === 128 /* ComputedPropertyName */) { + if (properties[i].name.kind === 129 /* ComputedPropertyName */) { numInitialNonComputedProperties = i; break; } @@ -26861,21 +27314,21 @@ var ts; emitObjectLiteralBody(node, properties.length); } function createBinaryExpression(left, operator, right, startsOnNewLine) { - var result = ts.createSynthesizedNode(170 /* BinaryExpression */, startsOnNewLine); + var result = ts.createSynthesizedNode(172 /* BinaryExpression */, startsOnNewLine); result.operatorToken = ts.createSynthesizedNode(operator); result.left = left; result.right = right; return result; } function createPropertyAccessExpression(expression, name) { - var result = ts.createSynthesizedNode(156 /* PropertyAccessExpression */); + var result = ts.createSynthesizedNode(158 /* PropertyAccessExpression */); result.expression = parenthesizeForAccess(expression); result.dotToken = ts.createSynthesizedNode(20 /* DotToken */); result.name = name; return result; } function createElementAccessExpression(expression, argumentExpression) { - var result = ts.createSynthesizedNode(157 /* ElementAccessExpression */); + var result = ts.createSynthesizedNode(159 /* ElementAccessExpression */); result.expression = parenthesizeForAccess(expression); result.argumentExpression = argumentExpression; return result; @@ -26883,7 +27336,7 @@ var ts; function parenthesizeForAccess(expr) { // When diagnosing whether the expression needs parentheses, the decision should be based // on the innermost expression in a chain of nested type assertions. - while (expr.kind === 161 /* TypeAssertionExpression */) { + while (expr.kind === 163 /* TypeAssertionExpression */) { expr = expr.expression; } // isLeftHandSideExpression is almost the correct criterion for when it is not necessary @@ -26895,11 +27348,11 @@ var ts; // 1.x -> not the same as (1).x // if (ts.isLeftHandSideExpression(expr) && - expr.kind !== 159 /* NewExpression */ && + expr.kind !== 161 /* NewExpression */ && expr.kind !== 7 /* NumericLiteral */) { return expr; } - var node = ts.createSynthesizedNode(162 /* ParenthesizedExpression */); + var node = ts.createSynthesizedNode(164 /* ParenthesizedExpression */); node.expression = expr; return node; } @@ -26912,46 +27365,39 @@ var ts; if (languageVersion >= 2 /* ES6 */ && node.asteriskToken) { write("*"); } - emit(node.name, false); + emit(node.name); if (languageVersion < 2 /* ES6 */) { write(": function "); } emitSignatureAndBody(node); } function emitPropertyAssignment(node) { - emit(node.name, false); + emit(node.name); write(": "); emit(node.initializer); } + // Return true if identifier resolves to an exported member of a namespace + function isNamespaceExportReference(node) { + var container = resolver.getReferencedExportContainer(node); + return container && container.kind !== 230 /* SourceFile */; + } function emitShorthandPropertyAssignment(node) { - emit(node.name, false); - // If short-hand property has a prefix, then regardless of the target version, we will emit it as normal property assignment. For example: - // module m { - // export let y; - // } - // module m { - // export let obj = { y }; - // } - // The short-hand property in obj need to emit as such ... = { y : m.y } regardless of the TargetScript version - if (languageVersion < 2 /* ES6 */) { + // The name property of a short-hand property assignment is considered an expression position, so here + // we manually emit the identifier to avoid rewriting. + writeTextOfNode(currentSourceFile, node.name); + // If emitting pre-ES6 code, or if the name requires rewriting when resolved as an expression identifier, + // we emit a normal property assignment. For example: + // module m { + // export let y; + // } + // module m { + // let obj = { y }; + // } + // Here we need to emit obj = { y : m.y } regardless of the output target. + if (languageVersion < 2 /* ES6 */ || isNamespaceExportReference(node.name)) { // Emit identifier as an identifier write(": "); - var generatedName = getGeneratedNameForIdentifier(node.name); - if (generatedName) { - write(generatedName); - } - else { - // Even though this is stored as identifier treat it as an expression - // Short-hand, { x }, is equivalent of normal form { x: x } - emitExpressionIdentifier(node.name); - } - } - else if (resolver.getExpressionNameSubstitution(node.name, getGeneratedNameForNode)) { - // Emit identifier as an identifier - write(": "); - // Even though this is stored as identifier treat it as an expression - // Short-hand, { x }, is equivalent of normal form { x: x } - emitExpressionIdentifier(node.name); + emit(node.name); } } function tryEmitConstantValue(node) { @@ -26963,7 +27409,7 @@ var ts; if (constantValue !== undefined) { write(constantValue.toString()); if (!compilerOptions.removeComments) { - var propertyName = node.kind === 156 /* PropertyAccessExpression */ ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + var propertyName = node.kind === 158 /* PropertyAccessExpression */ ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); write(" /* " + propertyName + " */"); } return true; @@ -26997,7 +27443,7 @@ var ts; var indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, node.dotToken); write("."); var indentedAfterDot = indentIfOnDifferentLines(node, node.dotToken, node.name); - emit(node.name, false); + emit(node.name); decreaseIndentIf(indentedBeforeDot, indentedAfterDot); } function emitQualifiedName(node) { @@ -27015,10 +27461,10 @@ var ts; write("]"); } function hasSpreadElement(elements) { - return ts.forEach(elements, function (e) { return e.kind === 174 /* SpreadElementExpression */; }); + return ts.forEach(elements, function (e) { return e.kind === 176 /* SpreadElementExpression */; }); } function skipParentheses(node) { - while (node.kind === 162 /* ParenthesizedExpression */ || node.kind === 161 /* TypeAssertionExpression */) { + while (node.kind === 164 /* ParenthesizedExpression */ || node.kind === 163 /* TypeAssertionExpression */) { node = node.expression; } return node; @@ -27039,13 +27485,13 @@ var ts; function emitCallWithSpread(node) { var target; var expr = skipParentheses(node.expression); - if (expr.kind === 156 /* PropertyAccessExpression */) { + if (expr.kind === 158 /* PropertyAccessExpression */) { // Target will be emitted as "this" argument target = emitCallTarget(expr.expression); write("."); emit(expr.name); } - else if (expr.kind === 157 /* ElementAccessExpression */) { + else if (expr.kind === 159 /* ElementAccessExpression */) { // Target will be emitted as "this" argument target = emitCallTarget(expr.expression); write("["); @@ -27090,7 +27536,7 @@ var ts; } else { emit(node.expression); - superCall = node.expression.kind === 156 /* PropertyAccessExpression */ && node.expression.expression.kind === 91 /* SuperKeyword */; + superCall = node.expression.kind === 158 /* PropertyAccessExpression */ && node.expression.expression.kind === 91 /* SuperKeyword */; } if (superCall && languageVersion < 2 /* ES6 */) { write(".call("); @@ -27109,23 +27555,21 @@ var ts; } function emitNewExpression(node) { write("new "); - // Spread operator logic can be supported in new expressions in ES5 using a combination + // Spread operator logic is supported in new expressions in ES5 using a combination // of Function.prototype.bind() and Function.prototype.apply(). // // Example: // - // var arguments = [1, 2, 3, 4, 5]; - // new Array(...arguments); + // var args = [1, 2, 3, 4, 5]; + // new Array(...args); // - // Could be transpiled into ES5: + // is compiled into the following ES5: // - // var arguments = [1, 2, 3, 4, 5]; - // new (Array.bind.apply(Array, [void 0].concat(arguments))); + // var args = [1, 2, 3, 4, 5]; + // new (Array.bind.apply(Array, [void 0].concat(args))); // - // `[void 0]` is the first argument which represents `thisArg` to the bind method above. - // And `thisArg` will be set to the return value of the constructor when instantiated - // with the new operator — regardless of any value we set `thisArg` to. Thus, we set it - // to an undefined, `void 0`. + // The 'thisArg' to 'bind' is ignored when invoking the result of 'bind' with 'new', + // Thus, we set it to undefined ('void 0'). if (languageVersion === 1 /* ES5 */ && node.arguments && hasSpreadElement(node.arguments)) { @@ -27161,12 +27605,12 @@ var ts; // If the node is synthesized, it means the emitter put the parentheses there, // not the user. If we didn't want them, the emitter would not have put them // there. - if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 164 /* ArrowFunction */) { - if (node.expression.kind === 161 /* TypeAssertionExpression */) { + if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 166 /* ArrowFunction */) { + if (node.expression.kind === 163 /* TypeAssertionExpression */) { var operand = node.expression.expression; // Make sure we consider all nested cast expressions, e.g.: // (-A).x; - while (operand.kind == 161 /* TypeAssertionExpression */) { + while (operand.kind === 163 /* TypeAssertionExpression */) { operand = operand.expression; } // We have an expression of the form: (SubExpr) @@ -27177,14 +27621,14 @@ var ts; // (typeof A).toString() should be emitted as (typeof A).toString() and not typeof A.toString() // new (A()) should be emitted as new (A()) and not new A() // (function foo() { })() should be emitted as an IIF (function foo(){})() and not declaration function foo(){} () - if (operand.kind !== 168 /* PrefixUnaryExpression */ && - operand.kind !== 167 /* VoidExpression */ && - operand.kind !== 166 /* TypeOfExpression */ && - operand.kind !== 165 /* DeleteExpression */ && - operand.kind !== 169 /* PostfixUnaryExpression */ && - operand.kind !== 159 /* NewExpression */ && - !(operand.kind === 158 /* CallExpression */ && node.parent.kind === 159 /* NewExpression */) && - !(operand.kind === 163 /* FunctionExpression */ && node.parent.kind === 158 /* CallExpression */)) { + if (operand.kind !== 170 /* PrefixUnaryExpression */ && + operand.kind !== 169 /* VoidExpression */ && + operand.kind !== 168 /* TypeOfExpression */ && + operand.kind !== 167 /* DeleteExpression */ && + operand.kind !== 171 /* PostfixUnaryExpression */ && + operand.kind !== 161 /* NewExpression */ && + !(operand.kind === 160 /* CallExpression */ && node.parent.kind === 161 /* NewExpression */) && + !(operand.kind === 165 /* FunctionExpression */ && node.parent.kind === 160 /* CallExpression */)) { emit(operand); return; } @@ -27213,7 +27657,7 @@ var ts; if (!isCurrentFileSystemExternalModule() || node.kind !== 65 /* Identifier */ || ts.nodeIsSynthesized(node)) { return false; } - var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 199 /* VariableDeclaration */ || node.parent.kind === 153 /* BindingElement */); + var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 201 /* VariableDeclaration */ || node.parent.kind === 155 /* BindingElement */); var targetDeclaration = isVariableDeclarationOrBindingElement ? node.parent : resolver.getReferencedValueDeclaration(node); @@ -27243,7 +27687,7 @@ var ts; // the resulting expression a prefix increment operation. And in the second, it will make the resulting // expression a prefix increment whose operand is a plus expression - (++(+x)) // The same is true of minus of course. - if (node.operand.kind === 168 /* PrefixUnaryExpression */) { + if (node.operand.kind === 170 /* PrefixUnaryExpression */) { var operand = node.operand; if (node.operator === 33 /* PlusToken */ && (operand.operator === 33 /* PlusToken */ || operand.operator === 38 /* PlusPlusToken */)) { write(" "); @@ -27299,10 +27743,10 @@ var ts; } var current = node; while (current) { - if (current.kind === 228 /* SourceFile */) { + if (current.kind === 230 /* SourceFile */) { return !isExported || ((ts.getCombinedNodeFlags(node) & 1 /* Export */) !== 0); } - else if (ts.isFunctionLike(current) || current.kind === 207 /* ModuleBlock */) { + else if (ts.isFunctionLike(current) || current.kind === 209 /* ModuleBlock */) { return false; } else { @@ -27312,8 +27756,8 @@ var ts; } function emitBinaryExpression(node) { if (languageVersion < 2 /* ES6 */ && node.operatorToken.kind === 53 /* EqualsToken */ && - (node.left.kind === 155 /* ObjectLiteralExpression */ || node.left.kind === 154 /* ArrayLiteralExpression */)) { - emitDestructuring(node, node.parent.kind === 183 /* ExpressionStatement */); + (node.left.kind === 157 /* ObjectLiteralExpression */ || node.left.kind === 156 /* ArrayLiteralExpression */)) { + emitDestructuring(node, node.parent.kind === 185 /* ExpressionStatement */); } else { var exportChanged = node.operatorToken.kind >= 53 /* FirstAssignment */ && @@ -27365,7 +27809,7 @@ var ts; } } function isSingleLineEmptyBlock(node) { - if (node && node.kind === 180 /* Block */) { + if (node && node.kind === 182 /* Block */) { var block = node; return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); } @@ -27380,12 +27824,12 @@ var ts; emitToken(14 /* OpenBraceToken */, node.pos); increaseIndent(); scopeEmitStart(node.parent); - if (node.kind === 207 /* ModuleBlock */) { - ts.Debug.assert(node.parent.kind === 206 /* ModuleDeclaration */); + if (node.kind === 209 /* ModuleBlock */) { + ts.Debug.assert(node.parent.kind === 208 /* ModuleDeclaration */); emitCaptureThisForNodeIfNecessary(node.parent); } emitLines(node.statements); - if (node.kind === 207 /* ModuleBlock */) { + if (node.kind === 209 /* ModuleBlock */) { emitTempDeclarations(true); } decreaseIndent(); @@ -27394,7 +27838,7 @@ var ts; scopeEmitEnd(); } function emitEmbeddedStatement(node) { - if (node.kind === 180 /* Block */) { + if (node.kind === 182 /* Block */) { write(" "); emit(node); } @@ -27406,7 +27850,7 @@ var ts; } } function emitExpressionStatement(node) { - emitParenthesizedIf(node.expression, node.expression.kind === 164 /* ArrowFunction */); + emitParenthesizedIf(node.expression, node.expression.kind === 166 /* ArrowFunction */); write(";"); } function emitIfStatement(node) { @@ -27419,7 +27863,7 @@ var ts; if (node.elseStatement) { writeLine(); emitToken(76 /* ElseKeyword */, node.thenStatement.end); - if (node.elseStatement.kind === 184 /* IfStatement */) { + if (node.elseStatement.kind === 186 /* IfStatement */) { write(" "); emit(node.elseStatement); } @@ -27431,7 +27875,7 @@ var ts; function emitDoStatement(node) { write("do"); emitEmbeddedStatement(node.statement); - if (node.statement.kind === 180 /* Block */) { + if (node.statement.kind === 182 /* Block */) { write(" "); } else { @@ -27506,7 +27950,7 @@ var ts; var endPos = emitToken(82 /* ForKeyword */, node.pos); write(" "); endPos = emitToken(16 /* OpenParenToken */, endPos); - if (node.initializer && node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer && node.initializer.kind === 202 /* VariableDeclarationList */) { var variableDeclarationList = node.initializer; var startIsEmitted = tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); if (startIsEmitted) { @@ -27527,13 +27971,13 @@ var ts; emitEmbeddedStatement(node.statement); } function emitForInOrForOfStatement(node) { - if (languageVersion < 2 /* ES6 */ && node.kind === 189 /* ForOfStatement */) { + if (languageVersion < 2 /* ES6 */ && node.kind === 191 /* ForOfStatement */) { return emitDownLevelForOfStatement(node); } var endPos = emitToken(82 /* ForKeyword */, node.pos); write(" "); endPos = emitToken(16 /* OpenParenToken */, endPos); - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); @@ -27543,7 +27987,7 @@ var ts; else { emit(node.initializer); } - if (node.kind === 188 /* ForInStatement */) { + if (node.kind === 190 /* ForInStatement */) { write(" in "); } else { @@ -27628,7 +28072,7 @@ var ts; // let v = _a[_i]; var rhsIterationValue = createElementAccessExpression(rhsReference, counter); emitStart(node.initializer); - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { write("var "); var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length > 0) { @@ -27658,7 +28102,7 @@ var ts; // Initializer is an expression. Emit the expression in the body, so that it's // evaluated on every iteration. var assignmentExpression = createBinaryExpression(node.initializer, 53 /* EqualsToken */, rhsIterationValue, false); - if (node.initializer.kind === 154 /* ArrayLiteralExpression */ || node.initializer.kind === 155 /* ObjectLiteralExpression */) { + if (node.initializer.kind === 156 /* ArrayLiteralExpression */ || node.initializer.kind === 157 /* ObjectLiteralExpression */) { // This is a destructuring pattern, so call emitDestructuring instead of emit. Calling emit will not work, because it will cause // the BinaryExpression to be passed in instead of the expression statement, which will cause emitDestructuring to crash. emitDestructuring(assignmentExpression, true, undefined); @@ -27669,7 +28113,7 @@ var ts; } emitEnd(node.initializer); write(";"); - if (node.statement.kind === 180 /* Block */) { + if (node.statement.kind === 182 /* Block */) { emitLines(node.statement.statements); } else { @@ -27681,7 +28125,7 @@ var ts; write("}"); } function emitBreakOrContinueStatement(node) { - emitToken(node.kind === 191 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */, node.pos); + emitToken(node.kind === 193 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */, node.pos); emitOptional(" ", node.label); write(";"); } @@ -27726,7 +28170,7 @@ var ts; ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); } function emitCaseOrDefaultClause(node) { - if (node.kind === 221 /* CaseClause */) { + if (node.kind === 223 /* CaseClause */) { write("case "); emit(node.expression); write(":"); @@ -27781,7 +28225,7 @@ var ts; function getContainingModule(node) { do { node = node.parent; - } while (node && node.kind !== 206 /* ModuleDeclaration */); + } while (node && node.kind !== 208 /* ModuleDeclaration */); return node; } function emitContainingModuleName(node) { @@ -27806,7 +28250,7 @@ var ts; function createVoidZero() { var zero = ts.createSynthesizedNode(7 /* NumericLiteral */); zero.text = "0"; - var result = ts.createSynthesizedNode(167 /* VoidExpression */); + var result = ts.createSynthesizedNode(169 /* VoidExpression */); result.expression = zero; return result; } @@ -27882,15 +28326,15 @@ var ts; // Also temporary variables should be explicitly allocated for source level declarations when module target is system // because actual variable declarations are hoisted var canDefineTempVariablesInPlace = false; - if (root.kind === 199 /* VariableDeclaration */) { + if (root.kind === 201 /* VariableDeclaration */) { var isExported = ts.getCombinedNodeFlags(root) & 1 /* Export */; var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root); canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind; } - else if (root.kind === 130 /* Parameter */) { + else if (root.kind === 131 /* Parameter */) { canDefineTempVariablesInPlace = true; } - if (root.kind === 170 /* BinaryExpression */) { + if (root.kind === 172 /* BinaryExpression */) { emitAssignmentExpression(root); } else { @@ -27901,8 +28345,7 @@ var ts; if (emitCount++) { write(", "); } - renameNonTopLevelLetAndConst(name); - var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 199 /* VariableDeclaration */ || name.parent.kind === 153 /* BindingElement */); + var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 201 /* VariableDeclaration */ || name.parent.kind === 155 /* BindingElement */); var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name); if (exportChanged) { write(exportFunctionForFile + "(\""); @@ -27937,14 +28380,14 @@ var ts; // we need to generate a temporary variable value = ensureIdentifier(value); // Return the expression 'value === void 0 ? defaultValue : value' - var equals = ts.createSynthesizedNode(170 /* BinaryExpression */); + var equals = ts.createSynthesizedNode(172 /* BinaryExpression */); equals.left = value; equals.operatorToken = ts.createSynthesizedNode(30 /* EqualsEqualsEqualsToken */); equals.right = createVoidZero(); return createConditionalExpression(equals, defaultValue, value); } function createConditionalExpression(condition, whenTrue, whenFalse) { - var cond = ts.createSynthesizedNode(171 /* ConditionalExpression */); + var cond = ts.createSynthesizedNode(173 /* ConditionalExpression */); cond.condition = condition; cond.questionToken = ts.createSynthesizedNode(50 /* QuestionToken */); cond.whenTrue = whenTrue; @@ -27958,13 +28401,17 @@ var ts; return node; } function createPropertyAccessForDestructuringProperty(object, propName) { - if (propName.kind !== 65 /* Identifier */) { - return createElementAccessExpression(object, propName); + // We create a synthetic copy of the identifier in order to avoid the rewriting that might + // otherwise occur when the identifier is emitted. + var syntheticName = ts.createSynthesizedNode(propName.kind); + syntheticName.text = propName.text; + if (syntheticName.kind !== 65 /* Identifier */) { + return createElementAccessExpression(object, syntheticName); } - return createPropertyAccessExpression(object, propName); + return createPropertyAccessExpression(object, syntheticName); } function createSliceCall(value, sliceIndex) { - var call = ts.createSynthesizedNode(158 /* CallExpression */); + var call = ts.createSynthesizedNode(160 /* CallExpression */); var sliceIdentifier = ts.createSynthesizedNode(65 /* Identifier */); sliceIdentifier.text = "slice"; call.expression = createPropertyAccessExpression(value, sliceIdentifier); @@ -27981,9 +28428,8 @@ var ts; } for (var _a = 0; _a < properties.length; _a++) { var p = properties[_a]; - if (p.kind === 225 /* PropertyAssignment */ || p.kind === 226 /* ShorthandPropertyAssignment */) { - // TODO(andersh): Computed property support - var propName = (p.name); + if (p.kind === 227 /* PropertyAssignment */ || p.kind === 228 /* ShorthandPropertyAssignment */) { + var propName = p.name; emitDestructuringAssignment(p.initializer || propName, createPropertyAccessForDestructuringProperty(value, propName)); } } @@ -27997,8 +28443,8 @@ var ts; } for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176 /* OmittedExpression */) { - if (e.kind !== 174 /* SpreadElementExpression */) { + if (e.kind !== 178 /* OmittedExpression */) { + if (e.kind !== 176 /* SpreadElementExpression */) { emitDestructuringAssignment(e, createElementAccessExpression(value, createNumericLiteral(i))); } else if (i === elements.length - 1) { @@ -28008,14 +28454,14 @@ var ts; } } function emitDestructuringAssignment(target, value) { - if (target.kind === 170 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { + if (target.kind === 172 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { value = createDefaultValueCheck(value, target.right); target = target.left; } - if (target.kind === 155 /* ObjectLiteralExpression */) { + if (target.kind === 157 /* ObjectLiteralExpression */) { emitObjectLiteralAssignment(target, value); } - else if (target.kind === 154 /* ArrayLiteralExpression */) { + else if (target.kind === 156 /* ArrayLiteralExpression */) { emitArrayLiteralAssignment(target, value); } else { @@ -28029,14 +28475,14 @@ var ts; emitDestructuringAssignment(target, value); } else { - if (root.parent.kind !== 162 /* ParenthesizedExpression */) { + if (root.parent.kind !== 164 /* ParenthesizedExpression */) { write("("); } value = ensureIdentifier(value); emitDestructuringAssignment(target, value); write(", "); emit(value); - if (root.parent.kind !== 162 /* ParenthesizedExpression */) { + if (root.parent.kind !== 164 /* ParenthesizedExpression */) { write(")"); } } @@ -28060,12 +28506,12 @@ var ts; } for (var i = 0; i < elements.length; i++) { var element = elements[i]; - if (pattern.kind === 151 /* ObjectBindingPattern */) { + if (pattern.kind === 153 /* ObjectBindingPattern */) { // Rewrite element to a declaration with an initializer that fetches property var propName = element.propertyName || element.name; emitBindingElement(element, createPropertyAccessForDestructuringProperty(value, propName)); } - else if (element.kind !== 176 /* OmittedExpression */) { + else if (element.kind !== 178 /* OmittedExpression */) { if (!element.dotDotDotToken) { // Rewrite element to a declaration that accesses array element at index i emitBindingElement(element, createElementAccessExpression(value, createNumericLiteral(i))); @@ -28092,7 +28538,6 @@ var ts; } } else { - renameNonTopLevelLetAndConst(node.name); var initializer = node.initializer; if (!initializer && languageVersion < 2 /* ES6 */) { // downlevel emit for non-initialized let bindings defined in loops @@ -28105,8 +28550,8 @@ var ts; (getCombinedFlagsForIdentifier(node.name) & 4096 /* Let */); // NOTE: default initialization should not be added to let bindings in for-in\for-of statements if (isUninitializedLet && - node.parent.parent.kind !== 188 /* ForInStatement */ && - node.parent.parent.kind !== 189 /* ForOfStatement */) { + node.parent.parent.kind !== 190 /* ForInStatement */ && + node.parent.parent.kind !== 191 /* ForOfStatement */) { initializer = createVoidZero(); } } @@ -28124,7 +28569,7 @@ var ts; } } function emitExportVariableAssignments(node) { - if (node.kind === 176 /* OmittedExpression */) { + if (node.kind === 178 /* OmittedExpression */) { return; } var name = node.name; @@ -28136,56 +28581,15 @@ var ts; } } function getCombinedFlagsForIdentifier(node) { - if (!node.parent || (node.parent.kind !== 199 /* VariableDeclaration */ && node.parent.kind !== 153 /* BindingElement */)) { + if (!node.parent || (node.parent.kind !== 201 /* VariableDeclaration */ && node.parent.kind !== 155 /* BindingElement */)) { return 0; } return ts.getCombinedNodeFlags(node.parent); } - function renameNonTopLevelLetAndConst(node) { - // do not rename if - // - language version is ES6+ - // - node is synthesized - // - node is not identifier (can happen when tree is malformed) - // - node is definitely not name of variable declaration. - // it still can be part of parameter declaration, this check will be done next - if (languageVersion >= 2 /* ES6 */ || - ts.nodeIsSynthesized(node) || - node.kind !== 65 /* Identifier */ || - (node.parent.kind !== 199 /* VariableDeclaration */ && node.parent.kind !== 153 /* BindingElement */)) { - return; - } - var combinedFlags = getCombinedFlagsForIdentifier(node); - if (((combinedFlags & 12288 /* BlockScoped */) === 0) || combinedFlags & 1 /* Export */) { - // do not rename exported or non-block scoped variables - return; - } - // here it is known that node is a block scoped variable - var list = ts.getAncestor(node, 200 /* VariableDeclarationList */); - if (list.parent.kind === 181 /* VariableStatement */) { - var isSourceFileLevelBinding = list.parent.parent.kind === 228 /* SourceFile */; - var isModuleLevelBinding = list.parent.parent.kind === 207 /* ModuleBlock */; - var isFunctionLevelBinding = list.parent.parent.kind === 180 /* Block */ && ts.isFunctionLike(list.parent.parent.parent); - if (isSourceFileLevelBinding || isModuleLevelBinding || isFunctionLevelBinding) { - return; - } - } - var blockScopeContainer = ts.getEnclosingBlockScopeContainer(node); - var parent = blockScopeContainer.kind === 228 /* SourceFile */ - ? blockScopeContainer - : blockScopeContainer.parent; - if (resolver.resolvesToSomeValue(parent, node.text)) { - var variableId = resolver.getBlockScopedVariableId(node); - if (!blockScopedVariableToGeneratedName) { - blockScopedVariableToGeneratedName = []; - } - var generatedName = makeUniqueName(node.text); - blockScopedVariableToGeneratedName[variableId] = generatedName; - } - } function isES6ExportedDeclaration(node) { return !!(node.flags & 1 /* Export */) && languageVersion >= 2 /* ES6 */ && - node.parent.kind === 228 /* SourceFile */; + node.parent.kind === 230 /* SourceFile */; } function emitVariableStatement(node) { var startIsEmitted = false; @@ -28236,12 +28640,12 @@ var ts; function emitParameter(node) { if (languageVersion < 2 /* ES6 */) { if (ts.isBindingPattern(node.name)) { - var name_23 = createTempVariable(0 /* Auto */); + var name_20 = createTempVariable(0 /* Auto */); if (!tempParameters) { tempParameters = []; } - tempParameters.push(name_23); - emit(name_23); + tempParameters.push(name_20); + emit(name_20); } else { emit(node.name); @@ -28332,12 +28736,12 @@ var ts; } } function emitAccessor(node) { - write(node.kind === 137 /* GetAccessor */ ? "get " : "set "); - emit(node.name, false); + write(node.kind === 138 /* GetAccessor */ ? "get " : "set "); + emit(node.name); emitSignatureAndBody(node); } function shouldEmitAsArrowFunction(node) { - return node.kind === 164 /* ArrowFunction */ && languageVersion >= 2 /* ES6 */; + return node.kind === 166 /* ArrowFunction */ && languageVersion >= 2 /* ES6 */; } function emitDeclarationName(node) { if (node.name) { @@ -28348,11 +28752,11 @@ var ts; } } function shouldEmitFunctionName(node) { - if (node.kind === 163 /* FunctionExpression */) { + if (node.kind === 165 /* FunctionExpression */) { // Emit name if one is present return !!node.name; } - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 203 /* FunctionDeclaration */) { // Emit name if one is present, or emit generated name in down-level case (for export default case) return !!node.name || languageVersion < 2 /* ES6 */; } @@ -28361,7 +28765,7 @@ var ts; if (ts.nodeIsMissing(node.body)) { return emitOnlyPinnedOrTripleSlashComments(node); } - if (node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { + if (node.kind !== 136 /* MethodDeclaration */ && node.kind !== 135 /* MethodSignature */) { // Methods will emit the comments as part of emitting method declaration emitLeadingComments(node); } @@ -28384,10 +28788,10 @@ var ts; emitDeclarationName(node); } emitSignatureAndBody(node); - if (languageVersion < 2 /* ES6 */ && node.kind === 201 /* FunctionDeclaration */ && node.parent === currentSourceFile && node.name) { + if (languageVersion < 2 /* ES6 */ && node.kind === 203 /* FunctionDeclaration */ && node.parent === currentSourceFile && node.name) { emitExportMemberAssignments(node.name); } - if (node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { + if (node.kind !== 136 /* MethodDeclaration */ && node.kind !== 135 /* MethodSignature */) { emitTrailingComments(node); } } @@ -28438,7 +28842,7 @@ var ts; // in that case. write(" { }"); } - else if (node.body.kind === 180 /* Block */) { + else if (node.body.kind === 182 /* Block */) { emitBlockFunctionBody(node, node.body); } else { @@ -28469,10 +28873,10 @@ var ts; write(" "); // Unwrap all type assertions. var current = body; - while (current.kind === 161 /* TypeAssertionExpression */) { + while (current.kind === 163 /* TypeAssertionExpression */) { current = current.expression; } - emitParenthesizedIf(body, current.kind === 155 /* ObjectLiteralExpression */); + emitParenthesizedIf(body, current.kind === 157 /* ObjectLiteralExpression */); } function emitDownLevelExpressionFunctionBody(node, body) { write(" {"); @@ -28548,9 +28952,9 @@ var ts; function findInitialSuperCall(ctor) { if (ctor.body) { var statement = ctor.body.statements[0]; - if (statement && statement.kind === 183 /* ExpressionStatement */) { + if (statement && statement.kind === 185 /* ExpressionStatement */) { var expr = statement.expression; - if (expr && expr.kind === 158 /* CallExpression */) { + if (expr && expr.kind === 160 /* CallExpression */) { var func = expr.expression; if (func && func.kind === 91 /* SuperKeyword */) { return statement; @@ -28582,7 +28986,7 @@ var ts; emitNodeWithoutSourceMap(memberName); write("]"); } - else if (memberName.kind === 128 /* ComputedPropertyName */) { + else if (memberName.kind === 129 /* ComputedPropertyName */) { emitComputedPropertyName(memberName); } else { @@ -28594,7 +28998,7 @@ var ts; var properties = []; for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if (member.kind === 133 /* PropertyDeclaration */ && isStatic === ((member.flags & 128 /* Static */) !== 0) && member.initializer) { + if (member.kind === 134 /* PropertyDeclaration */ && isStatic === ((member.flags & 128 /* Static */) !== 0) && member.initializer) { properties.push(member); } } @@ -28634,11 +29038,11 @@ var ts; } function emitMemberFunctionsForES5AndLower(node) { ts.forEach(node.members, function (member) { - if (member.kind === 179 /* SemicolonClassElement */) { + if (member.kind === 181 /* SemicolonClassElement */) { writeLine(); write(";"); } - else if (member.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */) { + else if (member.kind === 136 /* MethodDeclaration */ || node.kind === 135 /* MethodSignature */) { if (!member.body) { return emitOnlyPinnedOrTripleSlashComments(member); } @@ -28657,7 +29061,7 @@ var ts; write(";"); emitTrailingComments(member); } - else if (member.kind === 137 /* GetAccessor */ || member.kind === 138 /* SetAccessor */) { + else if (member.kind === 138 /* GetAccessor */ || member.kind === 139 /* SetAccessor */) { var accessors = ts.getAllAccessorDeclarations(node.members, member); if (member === accessors.firstAccessor) { writeLine(); @@ -28707,22 +29111,22 @@ var ts; function emitMemberFunctionsForES6AndHigher(node) { for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if ((member.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */) && !member.body) { + if ((member.kind === 136 /* MethodDeclaration */ || node.kind === 135 /* MethodSignature */) && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } - else if (member.kind === 135 /* MethodDeclaration */ || - member.kind === 137 /* GetAccessor */ || - member.kind === 138 /* SetAccessor */) { + else if (member.kind === 136 /* MethodDeclaration */ || + member.kind === 138 /* GetAccessor */ || + member.kind === 139 /* SetAccessor */) { writeLine(); emitLeadingComments(member); emitStart(member); if (member.flags & 128 /* Static */) { write("static "); } - if (member.kind === 137 /* GetAccessor */) { + if (member.kind === 138 /* GetAccessor */) { write("get "); } - else if (member.kind === 138 /* SetAccessor */) { + else if (member.kind === 139 /* SetAccessor */) { write("set "); } if (member.asteriskToken) { @@ -28733,7 +29137,7 @@ var ts; emitEnd(member); emitTrailingComments(member); } - else if (member.kind === 179 /* SemicolonClassElement */) { + else if (member.kind === 181 /* SemicolonClassElement */) { writeLine(); write(";"); } @@ -28758,11 +29162,11 @@ var ts; var hasInstancePropertyWithInitializer = false; // Emit the constructor overload pinned comments ts.forEach(node.members, function (member) { - if (member.kind === 136 /* Constructor */ && !member.body) { + if (member.kind === 137 /* Constructor */ && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } // Check if there is any non-static property assignment - if (member.kind === 133 /* PropertyDeclaration */ && member.initializer && (member.flags & 128 /* Static */) === 0) { + if (member.kind === 134 /* PropertyDeclaration */ && member.initializer && (member.flags & 128 /* Static */) === 0) { hasInstancePropertyWithInitializer = true; } }); @@ -28870,7 +29274,7 @@ var ts; } function emitClassLikeDeclarationForES6AndHigher(node) { var thisNodeIsDecorated = ts.nodeIsDecorated(node); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { if (thisNodeIsDecorated) { // To preserve the correct runtime semantics when decorators are applied to the class, // the emit needs to follow one of the following rules: @@ -28950,7 +29354,7 @@ var ts; // This keeps the expression as an expression, while ensuring that the static parts // of it have been initialized by the time it is used. var staticProperties = getInitializedProperties(node, true); - var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 175 /* ClassExpression */; + var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 177 /* ClassExpression */; var tempVariable; if (isClassExpressionWithStaticProperties) { tempVariable = createAndRecordTempVariable(0 /* Auto */); @@ -29034,7 +29438,7 @@ var ts; } } function emitClassLikeDeclarationBelowES6(node) { - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { // source file level classes in system modules are hoisted so 'var's for them are already defined if (!shouldHoistDeclarationInSystemJsModule(node)) { write("var "); @@ -29093,11 +29497,11 @@ var ts; emit(baseTypeNode.expression); } write(")"); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { write(";"); } emitEnd(node); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { emitExportMemberAssignment(node); } if (languageVersion < 2 /* ES6 */ && node.parent === currentSourceFile && node.name) { @@ -29189,7 +29593,7 @@ var ts; else { decorators = member.decorators; // we only decorate the parameters here if this is a method - if (member.kind === 135 /* MethodDeclaration */) { + if (member.kind === 136 /* MethodDeclaration */) { functionLikeMember = member; } } @@ -29227,7 +29631,7 @@ var ts; // writeLine(); emitStart(member); - if (member.kind !== 133 /* PropertyDeclaration */) { + if (member.kind !== 134 /* PropertyDeclaration */) { write("Object.defineProperty("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -29257,7 +29661,7 @@ var ts; write(", "); emitExpressionForPropertyName(member.name); emitEnd(member.name); - if (member.kind !== 133 /* PropertyDeclaration */) { + if (member.kind !== 134 /* PropertyDeclaration */) { write(", Object.getOwnPropertyDescriptor("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -29299,10 +29703,10 @@ var ts; // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata // compiler option is set. switch (node.kind) { - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 133 /* PropertyDeclaration */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 134 /* PropertyDeclaration */: return true; } return false; @@ -29312,7 +29716,7 @@ var ts; // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata // compiler option is set. switch (node.kind) { - case 135 /* MethodDeclaration */: + case 136 /* MethodDeclaration */: return true; } return false; @@ -29322,9 +29726,9 @@ var ts; // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata // compiler option is set. switch (node.kind) { - case 202 /* ClassDeclaration */: - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 204 /* ClassDeclaration */: + case 136 /* MethodDeclaration */: + case 139 /* SetAccessor */: return true; } return false; @@ -29335,7 +29739,7 @@ var ts; var argumentsWritten = 0; if (compilerOptions.emitDecoratorMetadata) { if (shouldEmitTypeMetadata(node)) { - var serializedType = resolver.serializeTypeOfNode(node, getGeneratedNameForNode); + var serializedType = resolver.serializeTypeOfNode(node); if (serializedType) { if (writeComma) { write(", "); @@ -29348,7 +29752,7 @@ var ts; } } if (shouldEmitParamTypesMetadata(node)) { - var serializedTypes = resolver.serializeParameterTypesOfNode(node, getGeneratedNameForNode); + var serializedTypes = resolver.serializeParameterTypesOfNode(node); if (serializedTypes) { if (writeComma || argumentsWritten) { write(", "); @@ -29366,7 +29770,7 @@ var ts; } } if (shouldEmitReturnTypeMetadata(node)) { - var serializedType = resolver.serializeReturnTypeOfNode(node, getGeneratedNameForNode); + var serializedType = resolver.serializeReturnTypeOfNode(node); if (serializedType) { if (writeComma || argumentsWritten) { write(", "); @@ -29500,7 +29904,7 @@ var ts; } } function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { - if (moduleDeclaration.body.kind === 206 /* ModuleDeclaration */) { + if (moduleDeclaration.body.kind === 208 /* ModuleDeclaration */) { var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); return recursiveInnerModule || moduleDeclaration.body; } @@ -29536,7 +29940,7 @@ var ts; write(getGeneratedNameForNode(node)); emitEnd(node.name); write(") "); - if (node.body.kind === 207 /* ModuleBlock */) { + if (node.body.kind === 209 /* ModuleBlock */) { var saveTempFlags = tempFlags; var saveTempVariables = tempVariables; tempFlags = 0; @@ -29594,16 +29998,16 @@ var ts; } } function getNamespaceDeclarationNode(node) { - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 211 /* ImportEqualsDeclaration */) { return node; } var importClause = node.importClause; - if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 214 /* NamespaceImport */) { return importClause.namedBindings; } } function isDefaultImport(node) { - return node.kind === 210 /* ImportDeclaration */ && node.importClause && !!node.importClause.name; + return node.kind === 212 /* ImportDeclaration */ && node.importClause && !!node.importClause.name; } function emitExportImportAssignments(node) { if (ts.isAliasSymbolDeclaration(node) && resolver.isValueAliasDeclaration(node)) { @@ -29631,7 +30035,7 @@ var ts; if (shouldEmitNamedBindings) { emitLeadingComments(node.importClause.namedBindings); emitStart(node.importClause.namedBindings); - if (node.importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (node.importClause.namedBindings.kind === 214 /* NamespaceImport */) { write("* as "); emit(node.importClause.namedBindings.name); } @@ -29657,7 +30061,7 @@ var ts; } function emitExternalImportDeclaration(node) { if (ts.contains(externalImports, node)) { - var isExportedImport = node.kind === 209 /* ImportEqualsDeclaration */ && (node.flags & 1 /* Export */) !== 0; + var isExportedImport = node.kind === 211 /* ImportEqualsDeclaration */ && (node.flags & 1 /* Export */) !== 0; var namespaceDeclaration = getNamespaceDeclarationNode(node); if (compilerOptions.module !== 2 /* AMD */) { emitLeadingComments(node); @@ -29676,7 +30080,7 @@ var ts; // import { x, y } from "foo" // import d, * as x from "foo" // import d, { x, y } from "foo" - var isNakedImport = 210 /* ImportDeclaration */ && !node.importClause; + var isNakedImport = 212 /* ImportDeclaration */ && !node.importClause; if (!isNakedImport) { write("var "); write(getGeneratedNameForNode(node)); @@ -29840,8 +30244,8 @@ var ts; write("export default "); var expression = node.expression; emit(expression); - if (expression.kind !== 201 /* FunctionDeclaration */ && - expression.kind !== 202 /* ClassDeclaration */) { + if (expression.kind !== 203 /* FunctionDeclaration */ && + expression.kind !== 204 /* ClassDeclaration */) { write(";"); } emitEnd(node); @@ -29877,7 +30281,7 @@ var ts; for (var _a = 0, _b = sourceFile.statements; _a < _b.length; _a++) { var node = _b[_a]; switch (node.kind) { - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: if (!node.importClause || resolver.isReferencedAliasDeclaration(node.importClause, true)) { // import "mod" @@ -29887,13 +30291,13 @@ var ts; externalImports.push(node); } break; - case 209 /* ImportEqualsDeclaration */: - if (node.moduleReference.kind === 220 /* ExternalModuleReference */ && resolver.isReferencedAliasDeclaration(node)) { + case 211 /* ImportEqualsDeclaration */: + if (node.moduleReference.kind === 222 /* ExternalModuleReference */ && resolver.isReferencedAliasDeclaration(node)) { // import x = require("mod") where x is referenced externalImports.push(node); } break; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: if (node.moduleSpecifier) { if (!node.exportClause) { // export * from "mod" @@ -29909,12 +30313,12 @@ var ts; // export { x, y } for (var _c = 0, _d = node.exportClause.elements; _c < _d.length; _c++) { var specifier = _d[_c]; - var name_24 = (specifier.propertyName || specifier.name).text; - (exportSpecifiers[name_24] || (exportSpecifiers[name_24] = [])).push(specifier); + var name_21 = (specifier.propertyName || specifier.name).text; + (exportSpecifiers[name_21] || (exportSpecifiers[name_21] = [])).push(specifier); } } break; - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: if (node.isExportEquals && !exportEquals) { // export = x exportEquals = node; @@ -29935,13 +30339,16 @@ var ts; write("}"); } } - function getLocalNameForExternalImport(importNode) { - var namespaceDeclaration = getNamespaceDeclarationNode(importNode); - if (namespaceDeclaration && !isDefaultImport(importNode)) { + function getLocalNameForExternalImport(node) { + var namespaceDeclaration = getNamespaceDeclarationNode(node); + if (namespaceDeclaration && !isDefaultImport(node)) { return ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, namespaceDeclaration.name); } - else { - return getGeneratedNameForNode(importNode); + if (node.kind === 212 /* ImportDeclaration */ && node.importClause) { + return getGeneratedNameForNode(node); + } + if (node.kind === 218 /* ExportDeclaration */ && node.moduleSpecifier) { + return getGeneratedNameForNode(node); } } function getExternalModuleNameText(importNode) { @@ -29960,8 +30367,8 @@ var ts; for (var _a = 0; _a < externalImports.length; _a++) { var importNode = externalImports[_a]; // do not create variable declaration for exports and imports that lack import clause - var skipNode = importNode.kind === 216 /* ExportDeclaration */ || - (importNode.kind === 210 /* ImportDeclaration */ && !importNode.importClause); + var skipNode = importNode.kind === 218 /* ExportDeclaration */ || + (importNode.kind === 212 /* ImportDeclaration */ && !importNode.importClause); if (skipNode) { continue; } @@ -29994,7 +30401,7 @@ var ts; var hasExportDeclarationWithExportClause = false; for (var _a = 0; _a < externalImports.length; _a++) { var externalImport = externalImports[_a]; - if (externalImport.kind === 216 /* ExportDeclaration */ && externalImport.exportClause) { + if (externalImport.kind === 218 /* ExportDeclaration */ && externalImport.exportClause) { hasExportDeclarationWithExportClause = true; break; } @@ -30026,7 +30433,7 @@ var ts; } for (var _d = 0; _d < externalImports.length; _d++) { var externalImport = externalImports[_d]; - if (externalImport.kind !== 216 /* ExportDeclaration */) { + if (externalImport.kind !== 218 /* ExportDeclaration */) { continue; } var exportDecl = externalImport; @@ -30110,12 +30517,12 @@ var ts; var seen = {}; for (var i = 0; i < hoistedVars.length; ++i) { var local = hoistedVars[i]; - var name_25 = local.kind === 65 /* Identifier */ + var name_22 = local.kind === 65 /* Identifier */ ? local : local.name; - if (name_25) { + if (name_22) { // do not emit duplicate entries (in case of declaration merging) in the list of hoisted variables - var text = ts.unescapeIdentifier(name_25.text); + var text = ts.unescapeIdentifier(name_22.text); if (ts.hasProperty(seen, text)) { continue; } @@ -30126,7 +30533,7 @@ var ts; if (i !== 0) { write(", "); } - if (local.kind === 202 /* ClassDeclaration */ || local.kind === 206 /* ModuleDeclaration */ || local.kind === 205 /* EnumDeclaration */) { + if (local.kind === 204 /* ClassDeclaration */ || local.kind === 208 /* ModuleDeclaration */ || local.kind === 207 /* EnumDeclaration */) { emitDeclarationName(local); } else { @@ -30160,21 +30567,21 @@ var ts; if (node.flags & 2 /* Ambient */) { return; } - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 203 /* FunctionDeclaration */) { if (!hoistedFunctionDeclarations) { hoistedFunctionDeclarations = []; } hoistedFunctionDeclarations.push(node); return; } - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { if (!hoistedVars) { hoistedVars = []; } hoistedVars.push(node); return; } - if (node.kind === 205 /* EnumDeclaration */) { + if (node.kind === 207 /* EnumDeclaration */) { if (shouldEmitEnumDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; @@ -30183,7 +30590,7 @@ var ts; } return; } - if (node.kind === 206 /* ModuleDeclaration */) { + if (node.kind === 208 /* ModuleDeclaration */) { if (shouldEmitModuleDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; @@ -30192,17 +30599,17 @@ var ts; } return; } - if (node.kind === 199 /* VariableDeclaration */ || node.kind === 153 /* BindingElement */) { + if (node.kind === 201 /* VariableDeclaration */ || node.kind === 155 /* BindingElement */) { if (shouldHoistVariable(node, false)) { - var name_26 = node.name; - if (name_26.kind === 65 /* Identifier */) { + var name_23 = node.name; + if (name_23.kind === 65 /* Identifier */) { if (!hoistedVars) { hoistedVars = []; } - hoistedVars.push(name_26); + hoistedVars.push(name_23); } else { - ts.forEachChild(name_26, visit); + ts.forEachChild(name_23, visit); } } return; @@ -30226,7 +30633,7 @@ var ts; // if block scoped variables are nested in some another block then // no other functions can use them except ones that are defined at least in the same block return (ts.getCombinedNodeFlags(node) & 12288 /* BlockScoped */) === 0 || - ts.getEnclosingBlockScopeContainer(node).kind === 228 /* SourceFile */; + ts.getEnclosingBlockScopeContainer(node).kind === 230 /* SourceFile */; } function isCurrentFileSystemExternalModule() { return compilerOptions.module === 4 /* System */ && ts.isExternalModule(currentSourceFile); @@ -30279,10 +30686,10 @@ var ts; emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(true); decreaseIndent(); writeLine(); write("}"); // return + emitTempDeclarations(true); } function emitSetters(exportStarFunction) { write("setters:["); @@ -30297,21 +30704,21 @@ var ts; var parameterName = "_" + importVariableName; write("function (" + parameterName + ") {"); switch (importNode.kind) { - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: if (!importNode.importClause) { // 'import "..."' case // module is imported only for side-effects, setter body will be empty break; } // fall-through - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: ts.Debug.assert(importVariableName !== ""); increaseIndent(); writeLine(); // save import into the local write(importVariableName + " = " + parameterName + ";"); writeLine(); - var defaultName = importNode.kind === 210 /* ImportDeclaration */ + var defaultName = importNode.kind === 212 /* ImportDeclaration */ ? importNode.importClause.name : importNode.name; if (defaultName) { @@ -30323,10 +30730,10 @@ var ts; emitExportMemberAssignments(defaultName); writeLine(); } - if (importNode.kind === 210 /* ImportDeclaration */ && + if (importNode.kind === 212 /* ImportDeclaration */ && importNode.importClause.namedBindings) { var namedBindings = importNode.importClause.namedBindings; - if (namedBindings.kind === 212 /* NamespaceImport */) { + if (namedBindings.kind === 214 /* NamespaceImport */) { // emit re-export for namespace // import * as n from 'foo' // export {n} @@ -30346,7 +30753,7 @@ var ts; } decreaseIndent(); break; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: ts.Debug.assert(importVariableName !== ""); increaseIndent(); if (importNode.exportClause) { @@ -30389,10 +30796,10 @@ var ts; // - imports/exports are not emitted for system modules // - function declarations are not emitted because they were already hoisted switch (statement.kind) { - case 216 /* ExportDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 201 /* FunctionDeclaration */: + case 218 /* ExportDeclaration */: + case 212 /* ImportDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 203 /* FunctionDeclaration */: continue; } writeLine(); @@ -30415,7 +30822,11 @@ var ts; ts.Debug.assert(!exportFunctionForFile); // make sure that name of 'exports' function does not conflict with existing identifiers exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); + } + write("["); for (var i = 0; i < externalImports.length; ++i) { var text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -30495,8 +30906,8 @@ var ts; collectExternalModuleInfo(node); writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, true); write(") {"); @@ -30634,7 +31045,7 @@ var ts; } emitLeadingComments(node.endOfFileToken); } - function emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers) { + function emitNodeWithoutSourceMap(node) { if (!node) { return; } @@ -30645,7 +31056,7 @@ var ts; if (emitComments) { emitLeadingComments(node); } - emitJavaScriptWorker(node, allowGeneratedIdentifiers); + emitJavaScriptWorker(node); if (emitComments) { emitTrailingComments(node); } @@ -30654,20 +31065,20 @@ var ts; switch (node.kind) { // All of these entities are emitted in a specialized fashion. As such, we allow // the specialized methods for each to handle the comments on the nodes. - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 215 /* ExportAssignment */: + case 205 /* InterfaceDeclaration */: + case 203 /* FunctionDeclaration */: + case 212 /* ImportDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 217 /* ExportAssignment */: return false; - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return shouldEmitLeadingAndTrailingCommentsForVariableStatement(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: // Only emit the leading/trailing comments for a module if we're actually // emitting the module as well. return shouldEmitModuleDeclaration(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: // Only emit the leading/trailing comments for an enum if we're actually // emitting the module as well. return shouldEmitEnumDeclaration(node); @@ -30676,9 +31087,9 @@ var ts; // then we don't want to emit comments when we emit the body. It will have already // been taken care of when we emitted the 'return' statement for the function // expression body. - if (node.kind !== 180 /* Block */ && + if (node.kind !== 182 /* Block */ && node.parent && - node.parent.kind === 164 /* ArrowFunction */ && + node.parent.kind === 166 /* ArrowFunction */ && node.parent.body === node && compilerOptions.target <= 1 /* ES5 */) { return false; @@ -30686,19 +31097,18 @@ var ts; // Emit comments for everything else. return true; } - function emitJavaScriptWorker(node, allowGeneratedIdentifiers) { - if (allowGeneratedIdentifiers === void 0) { allowGeneratedIdentifiers = true; } + function emitJavaScriptWorker(node) { // Check if the node can be emitted regardless of the ScriptTarget switch (node.kind) { case 65 /* Identifier */: - return emitIdentifier(node, allowGeneratedIdentifiers); - case 130 /* Parameter */: + return emitIdentifier(node); + case 131 /* Parameter */: return emitParameter(node); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return emitMethod(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return emitAccessor(node); case 93 /* ThisKeyword */: return emitThis(node); @@ -30718,131 +31128,131 @@ var ts; case 12 /* TemplateMiddle */: case 13 /* TemplateTail */: return emitLiteral(node); - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: return emitTemplateExpression(node); - case 178 /* TemplateSpan */: + case 180 /* TemplateSpan */: return emitTemplateSpan(node); - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: return emitQualifiedName(node); - case 151 /* ObjectBindingPattern */: + case 153 /* ObjectBindingPattern */: return emitObjectBindingPattern(node); - case 152 /* ArrayBindingPattern */: + case 154 /* ArrayBindingPattern */: return emitArrayBindingPattern(node); - case 153 /* BindingElement */: + case 155 /* BindingElement */: return emitBindingElement(node); - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return emitArrayLiteral(node); - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return emitObjectLiteral(node); - case 225 /* PropertyAssignment */: + case 227 /* PropertyAssignment */: return emitPropertyAssignment(node); - case 226 /* ShorthandPropertyAssignment */: + case 228 /* ShorthandPropertyAssignment */: return emitShorthandPropertyAssignment(node); - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: return emitComputedPropertyName(node); - case 156 /* PropertyAccessExpression */: + case 158 /* PropertyAccessExpression */: return emitPropertyAccess(node); - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: return emitIndexedAccess(node); - case 158 /* CallExpression */: + case 160 /* CallExpression */: return emitCallExpression(node); - case 159 /* NewExpression */: + case 161 /* NewExpression */: return emitNewExpression(node); - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: return emitTaggedTemplateExpression(node); - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return emit(node.expression); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return emitParenExpression(node); - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: return emitFunctionDeclaration(node); - case 165 /* DeleteExpression */: + case 167 /* DeleteExpression */: return emitDeleteExpression(node); - case 166 /* TypeOfExpression */: + case 168 /* TypeOfExpression */: return emitTypeOfExpression(node); - case 167 /* VoidExpression */: + case 169 /* VoidExpression */: return emitVoidExpression(node); - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: return emitPrefixUnaryExpression(node); - case 169 /* PostfixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: return emitPostfixUnaryExpression(node); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return emitBinaryExpression(node); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return emitConditionalExpression(node); - case 174 /* SpreadElementExpression */: + case 176 /* SpreadElementExpression */: return emitSpreadElementExpression(node); - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: return emitYieldExpression(node); - case 176 /* OmittedExpression */: + case 178 /* OmittedExpression */: return; - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return emitBlock(node); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return emitVariableStatement(node); - case 182 /* EmptyStatement */: + case 184 /* EmptyStatement */: return write(";"); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: return emitExpressionStatement(node); - case 184 /* IfStatement */: + case 186 /* IfStatement */: return emitIfStatement(node); - case 185 /* DoStatement */: + case 187 /* DoStatement */: return emitDoStatement(node); - case 186 /* WhileStatement */: + case 188 /* WhileStatement */: return emitWhileStatement(node); - case 187 /* ForStatement */: + case 189 /* ForStatement */: return emitForStatement(node); - case 189 /* ForOfStatement */: - case 188 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 190 /* ForInStatement */: return emitForInOrForOfStatement(node); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 193 /* BreakStatement */: return emitBreakOrContinueStatement(node); - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: return emitReturnStatement(node); - case 193 /* WithStatement */: + case 195 /* WithStatement */: return emitWithStatement(node); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: return emitSwitchStatement(node); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: return emitCaseOrDefaultClause(node); - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return emitLabelledStatement(node); - case 196 /* ThrowStatement */: + case 198 /* ThrowStatement */: return emitThrowStatement(node); - case 197 /* TryStatement */: + case 199 /* TryStatement */: return emitTryStatement(node); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return emitCatchClause(node); - case 198 /* DebuggerStatement */: + case 200 /* DebuggerStatement */: return emitDebuggerStatement(node); - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: return emitVariableDeclaration(node); - case 175 /* ClassExpression */: + case 177 /* ClassExpression */: return emitClassExpression(node); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return emitClassDeclaration(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return emitInterfaceDeclaration(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return emitEnumDeclaration(node); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return emitEnumMember(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return emitModuleDeclaration(node); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: return emitImportDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return emitImportEqualsDeclaration(node); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return emitExportDeclaration(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return emitExportAssignment(node); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return emitSourceFileNode(node); } } @@ -30874,7 +31284,7 @@ var ts; function getLeadingCommentsToEmit(node) { // Emit the leading comments only if the parent's pos doesn't match because parent should take care of emitting these comments if (node.parent) { - if (node.parent.kind === 228 /* SourceFile */ || node.pos !== node.parent.pos) { + if (node.parent.kind === 230 /* SourceFile */ || node.pos !== node.parent.pos) { if (hasDetachedComments(node.pos)) { // get comments without detached comments return getLeadingCommentsWithoutDetachedComments(); @@ -30889,7 +31299,7 @@ var ts; function getTrailingCommentsToEmit(node) { // Emit the trailing comments only if the parent's pos doesn't match because parent should take care of emitting these comments if (node.parent) { - if (node.parent.kind === 228 /* SourceFile */ || node.end !== node.parent.end) { + if (node.parent.kind === 230 /* SourceFile */ || node.end !== node.parent.end) { return ts.getTrailingCommentRanges(currentSourceFile.text, node.end); } } @@ -31086,7 +31496,7 @@ var ts; } ts.createCompilerHost = createCompilerHost; function getPreEmitDiagnostics(program, sourceFile) { - var diagnostics = program.getSyntacticDiagnostics(sourceFile).concat(program.getGlobalDiagnostics()).concat(program.getSemanticDiagnostics(sourceFile)); + var diagnostics = program.getOptionsDiagnostics().concat(program.getSyntacticDiagnostics(sourceFile), program.getGlobalDiagnostics(), program.getSemanticDiagnostics(sourceFile)); if (program.getCompilerOptions().declaration) { diagnostics.concat(program.getDeclarationDiagnostics(sourceFile)); } @@ -31119,16 +31529,21 @@ var ts; function createProgram(rootNames, options, host) { var program; var files = []; - var filesByName = {}; var diagnostics = ts.createDiagnosticCollection(); - var seenNoDefaultLib = options.noLib; var commonSourceDirectory; var diagnosticsProducingTypeChecker; var noDiagnosticsTypeChecker; + var classifiableNames; + var skipDefaultLib = options.noLib; var start = new Date().getTime(); host = host || createCompilerHost(options); + var filesByName = ts.createFileMap(function (fileName) { return host.getCanonicalFileName(fileName); }); ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); - if (!seenNoDefaultLib) { + // Do not process the default library if: + // - The '--noLib' flag is used. + // - A 'no-default-lib' reference comment is encountered in + // processing the root files. + if (!skipDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); } verifyCompilerOptions(); @@ -31138,11 +31553,12 @@ var ts; getSourceFiles: function () { return files; }, getCompilerOptions: function () { return options; }, getSyntacticDiagnostics: getSyntacticDiagnostics, + getOptionsDiagnostics: getOptionsDiagnostics, getGlobalDiagnostics: getGlobalDiagnostics, getSemanticDiagnostics: getSemanticDiagnostics, getDeclarationDiagnostics: getDeclarationDiagnostics, - getCompilerOptionsDiagnostics: getCompilerOptionsDiagnostics, getTypeChecker: getTypeChecker, + getClassifiableNames: getClassifiableNames, getDiagnosticsProducingTypeChecker: getDiagnosticsProducingTypeChecker, getCommonSourceDirectory: function () { return commonSourceDirectory; }, emit: emit, @@ -31153,6 +31569,18 @@ var ts; getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); } }; return program; + function getClassifiableNames() { + if (!classifiableNames) { + // Initialize a checker so that all our files are bound. + getTypeChecker(); + classifiableNames = {}; + for (var _i = 0; _i < files.length; _i++) { + var sourceFile = files[_i]; + ts.copyMap(sourceFile.classifiableNames, classifiableNames); + } + } + return classifiableNames; + } function getEmitHost(writeFileCallback) { return { getCanonicalFileName: function (fileName) { return host.getCanonicalFileName(fileName); }, @@ -31192,8 +31620,7 @@ var ts; return emitResult; } function getSourceFile(fileName) { - fileName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile, getDiagnostics) { if (sourceFile) { @@ -31233,16 +31660,14 @@ var ts; return ts.getDeclarationDiagnostics(getEmitHost(writeFile), resolver, sourceFile); } } - function getCompilerOptionsDiagnostics() { + function getOptionsDiagnostics() { var allDiagnostics = []; ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); return ts.sortAndDeduplicateDiagnostics(allDiagnostics); } function getGlobalDiagnostics() { - var typeChecker = getDiagnosticsProducingTypeChecker(); var allDiagnostics = []; - ts.addRange(allDiagnostics, typeChecker.getGlobalDiagnostics()); - ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); + ts.addRange(allDiagnostics, getDiagnosticsProducingTypeChecker().getGlobalDiagnostics()); return ts.sortAndDeduplicateDiagnostics(allDiagnostics); } function hasExtension(fileName) { @@ -31276,14 +31701,17 @@ var ts; } } else { - if (options.allowNonTsExtensions && !findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd)) { - diagnostic = ts.Diagnostics.File_0_not_found; - diagnosticArgument = [fileName]; - } - else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, isDefaultLib, refFile, refPos, refEnd); })) { - diagnostic = ts.Diagnostics.File_0_not_found; - fileName += ".ts"; - diagnosticArgument = [fileName]; + var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd); + if (!nonTsFile) { + if (options.allowNonTsExtensions) { + diagnostic = ts.Diagnostics.File_0_not_found; + diagnosticArgument = [fileName]; + } + else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, isDefaultLib, refFile, refPos, refEnd); })) { + diagnostic = ts.Diagnostics.File_0_not_found; + fileName += ".ts"; + diagnosticArgument = [fileName]; + } } } if (diagnostic) { @@ -31298,18 +31726,18 @@ var ts; // Get source file from normalized fileName function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - if (ts.hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { // We've already looked for this file, use cached result return getSourceFileFromCache(fileName, canonicalName, false); } else { var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } // We haven't looked for this file, do so now and cache result - var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } @@ -31317,16 +31745,18 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { - seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; + skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib; // Set the source file for normalized absolute path - filesByName[canonicalAbsolutePath] = file; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); processReferencedFiles(file, basePath); processImportedModules(file, basePath); } if (isDefaultLib) { + file.isDefaultLib = true; files.unshift(file); } else { @@ -31336,7 +31766,7 @@ var ts; return file; } function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { - var file = filesByName[canonicalName]; + var file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { @@ -31354,7 +31784,7 @@ var ts; } function processImportedModules(file, basePath) { ts.forEach(file.statements, function (node) { - if (node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */ || node.kind === 216 /* ExportDeclaration */) { + if (node.kind === 212 /* ImportDeclaration */ || node.kind === 211 /* ImportEqualsDeclaration */ || node.kind === 218 /* ExportDeclaration */) { var moduleNameExpr = ts.getExternalModuleName(node); if (moduleNameExpr && moduleNameExpr.kind === 8 /* StringLiteral */) { var moduleNameText = moduleNameExpr.text; @@ -31375,7 +31805,7 @@ var ts; } } } - else if (node.kind === 206 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */ && (node.flags & 2 /* Ambient */ || ts.isDeclarationFile(file))) { + else if (node.kind === 208 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */ && (node.flags & 2 /* Ambient */ || ts.isDeclarationFile(file))) { // TypeScript 1.0 spec (April 2014): 12.1.6 // An AmbientExternalModuleDeclaration declares an external module. // This type of declaration is permitted only in the global module. @@ -31656,9 +32086,14 @@ var ts; name: "noResolve", type: "boolean" }, + { + name: "skipDefaultLibCheck", + type: "boolean" + }, { name: "out", type: "string", + isFilePath: true, description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file, paramType: ts.Diagnostics.FILE }, @@ -32033,7 +32468,7 @@ var ts; } } function autoCollapse(node) { - return ts.isFunctionBlock(node) && node.parent.kind !== 164 /* ArrowFunction */; + return ts.isFunctionBlock(node) && node.parent.kind !== 166 /* ArrowFunction */; } var depth = 0; var maxDepth = 20; @@ -32045,30 +32480,30 @@ var ts; addOutliningForLeadingCommentsForNode(n); } switch (n.kind) { - case 180 /* Block */: + case 182 /* Block */: if (!ts.isFunctionBlock(n)) { - var parent_7 = n.parent; + var parent_8 = n.parent; var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); // Check if the block is standalone, or 'attached' to some parent statement. // If the latter, we want to collaps the block, but consider its hint span // to be the entire span of the parent. - if (parent_7.kind === 185 /* DoStatement */ || - parent_7.kind === 188 /* ForInStatement */ || - parent_7.kind === 189 /* ForOfStatement */ || - parent_7.kind === 187 /* ForStatement */ || - parent_7.kind === 184 /* IfStatement */ || - parent_7.kind === 186 /* WhileStatement */ || - parent_7.kind === 193 /* WithStatement */ || - parent_7.kind === 224 /* CatchClause */) { - addOutliningSpan(parent_7, openBrace, closeBrace, autoCollapse(n)); + if (parent_8.kind === 187 /* DoStatement */ || + parent_8.kind === 190 /* ForInStatement */ || + parent_8.kind === 191 /* ForOfStatement */ || + parent_8.kind === 189 /* ForStatement */ || + parent_8.kind === 186 /* IfStatement */ || + parent_8.kind === 188 /* WhileStatement */ || + parent_8.kind === 195 /* WithStatement */ || + parent_8.kind === 226 /* CatchClause */) { + addOutliningSpan(parent_8, openBrace, closeBrace, autoCollapse(n)); break; } - if (parent_7.kind === 197 /* TryStatement */) { + if (parent_8.kind === 199 /* TryStatement */) { // Could be the try-block, or the finally-block. - var tryStatement = parent_7; + var tryStatement = parent_8; if (tryStatement.tryBlock === n) { - addOutliningSpan(parent_7, openBrace, closeBrace, autoCollapse(n)); + addOutliningSpan(parent_8, openBrace, closeBrace, autoCollapse(n)); break; } else if (tryStatement.finallyBlock === n) { @@ -32091,23 +32526,23 @@ var ts; break; } // Fallthrough. - case 207 /* ModuleBlock */: { + case 209 /* ModuleBlock */: { var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n)); break; } - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 155 /* ObjectLiteralExpression */: - case 208 /* CaseBlock */: { + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 157 /* ObjectLiteralExpression */: + case 210 /* CaseBlock */: { var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); addOutliningSpan(n, openBrace, closeBrace, autoCollapse(n)); break; } - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: var openBracket = ts.findChildOfKind(n, 18 /* OpenBracketToken */, sourceFile); var closeBracket = ts.findChildOfKind(n, 19 /* CloseBracketToken */, sourceFile); addOutliningSpan(n, openBracket, closeBracket, autoCollapse(n)); @@ -32135,12 +32570,12 @@ var ts; ts.forEach(program.getSourceFiles(), function (sourceFile) { cancellationToken.throwIfCancellationRequested(); var nameToDeclarations = sourceFile.getNamedDeclarations(); - for (var name_27 in nameToDeclarations) { - var declarations = ts.getProperty(nameToDeclarations, name_27); + for (var name_24 in nameToDeclarations) { + var declarations = ts.getProperty(nameToDeclarations, name_24); if (declarations) { // First do a quick check to see if the name of the declaration matches the // last portion of the (possibly) dotted name they're searching for. - var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name_27); + var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name_24); if (!matches) { continue; } @@ -32153,14 +32588,14 @@ var ts; if (!containers) { return undefined; } - matches = patternMatcher.getMatches(containers, name_27); + matches = patternMatcher.getMatches(containers, name_24); if (!matches) { continue; } } var fileName = sourceFile.fileName; var matchKind = bestMatchKind(matches); - rawItems.push({ name: name_27, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); + rawItems.push({ name: name_24, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); } } } @@ -32198,7 +32633,7 @@ var ts; if (text !== undefined) { containers.unshift(text); } - else if (declaration.name.kind === 128 /* ComputedPropertyName */) { + else if (declaration.name.kind === 129 /* ComputedPropertyName */) { return tryAddComputedPropertyName(declaration.name.expression, containers, true); } else { @@ -32219,7 +32654,7 @@ var ts; } return true; } - if (expression.kind === 156 /* PropertyAccessExpression */) { + if (expression.kind === 158 /* PropertyAccessExpression */) { var propertyAccess = expression; if (includeLastPortion) { containers.unshift(propertyAccess.name.text); @@ -32232,7 +32667,7 @@ var ts; var containers = []; // First, if we started with a computed property name, then add all but the last // portion into the container array. - if (declaration.name.kind === 128 /* ComputedPropertyName */) { + if (declaration.name.kind === 129 /* ComputedPropertyName */) { if (!tryAddComputedPropertyName(declaration.name.expression, containers, false)) { return undefined; } @@ -32308,17 +32743,17 @@ var ts; var current = node.parent; while (current) { switch (current.kind) { - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: // If we have a module declared as A.B.C, it is more "intuitive" // to say it only has a single layer of depth do { current = current.parent; - } while (current.kind === 206 /* ModuleDeclaration */); + } while (current.kind === 208 /* ModuleDeclaration */); // fall through - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 205 /* InterfaceDeclaration */: + case 203 /* FunctionDeclaration */: indent++; } current = current.parent; @@ -32329,21 +32764,21 @@ var ts; var childNodes = []; function visit(node) { switch (node.kind) { - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: ts.forEach(node.declarationList.declarations, visit); break; - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: ts.forEach(node.elements, visit); break; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: // Handle named exports case e.g.: // export {a, b as B} from "mod"; if (node.exportClause) { ts.forEach(node.exportClause.elements, visit); } break; - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: var importClause = node.importClause; if (importClause) { // Handle default import case e.g.: @@ -32355,7 +32790,7 @@ var ts; // import * as NS from "mod"; // import {a, b as B} from "mod"; if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 214 /* NamespaceImport */) { childNodes.push(importClause.namedBindings); } else { @@ -32364,21 +32799,21 @@ var ts; } } break; - case 153 /* BindingElement */: - case 199 /* VariableDeclaration */: + case 155 /* BindingElement */: + case 201 /* VariableDeclaration */: if (ts.isBindingPattern(node.name)) { visit(node.name); break; } // Fall through - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 201 /* FunctionDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 205 /* InterfaceDeclaration */: + case 208 /* ModuleDeclaration */: + case 203 /* FunctionDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 216 /* ImportSpecifier */: + case 220 /* ExportSpecifier */: childNodes.push(node); break; } @@ -32426,17 +32861,17 @@ var ts; for (var _i = 0; _i < nodes.length; _i++) { var node = nodes[_i]; switch (node.kind) { - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 205 /* InterfaceDeclaration */: topLevelNodes.push(node); break; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: var moduleDeclaration = node; topLevelNodes.push(node); addTopLevelNodes(getInnermostModule(moduleDeclaration).body.statements, topLevelNodes); break; - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: var functionDeclaration = node; if (isTopLevelFunctionDeclaration(functionDeclaration)) { topLevelNodes.push(node); @@ -32447,12 +32882,12 @@ var ts; } } function isTopLevelFunctionDeclaration(functionDeclaration) { - if (functionDeclaration.kind === 201 /* FunctionDeclaration */) { + if (functionDeclaration.kind === 203 /* FunctionDeclaration */) { // A function declaration is 'top level' if it contains any function declarations // within it. - if (functionDeclaration.body && functionDeclaration.body.kind === 180 /* Block */) { + if (functionDeclaration.body && functionDeclaration.body.kind === 182 /* Block */) { // Proper function declarations can only have identifier names - if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 201 /* FunctionDeclaration */ && !isEmpty(s.name.text); })) { + if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 203 /* FunctionDeclaration */ && !isEmpty(s.name.text); })) { return true; } // Or if it is not parented by another function. i.e all functions @@ -32512,7 +32947,7 @@ var ts; } function createChildItem(node) { switch (node.kind) { - case 130 /* Parameter */: + case 131 /* Parameter */: if (ts.isBindingPattern(node.name)) { break; } @@ -32520,36 +32955,36 @@ var ts; return undefined; } return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); - case 137 /* GetAccessor */: + case 138 /* GetAccessor */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); - case 138 /* SetAccessor */: + case 139 /* SetAccessor */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 139 /* CallSignature */: + case 140 /* CallSignature */: return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.functionElement); - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: var variableDeclarationNode; - var name_28; - if (node.kind === 153 /* BindingElement */) { - name_28 = node.name; + var name_25; + if (node.kind === 155 /* BindingElement */) { + name_25 = node.name; variableDeclarationNode = node; // binding elements are added only for variable declarations // bubble up to the containing variable declaration - while (variableDeclarationNode && variableDeclarationNode.kind !== 199 /* VariableDeclaration */) { + while (variableDeclarationNode && variableDeclarationNode.kind !== 201 /* VariableDeclaration */) { variableDeclarationNode = variableDeclarationNode.parent; } ts.Debug.assert(variableDeclarationNode !== undefined); @@ -32557,24 +32992,24 @@ var ts; else { ts.Debug.assert(!ts.isBindingPattern(node.name)); variableDeclarationNode = node; - name_28 = node.name; + name_25 = node.name; } if (ts.isConst(variableDeclarationNode)) { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.constElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.constElement); } else if (ts.isLet(variableDeclarationNode)) { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.letElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.letElement); } else { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.variableElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.variableElement); } - case 136 /* Constructor */: + case 137 /* Constructor */: return createItem(node, "constructor", ts.ScriptElementKind.constructorImplementationElement); - case 218 /* ExportSpecifier */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: + case 220 /* ExportSpecifier */: + case 216 /* ImportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 213 /* ImportClause */: + case 214 /* NamespaceImport */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.alias); } return undefined; @@ -32604,17 +33039,17 @@ var ts; } function createTopLevelItem(node) { switch (node.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: return createSourceFileItem(node); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return createClassItem(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return createEnumItem(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return createIterfaceItem(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return createModuleItem(node); - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return createFunctionItem(node); } return undefined; @@ -32626,7 +33061,7 @@ var ts; // Otherwise, we need to aggregate each identifier to build up the qualified name. var result = []; result.push(moduleDeclaration.name.text); - while (moduleDeclaration.body && moduleDeclaration.body.kind === 206 /* ModuleDeclaration */) { + while (moduleDeclaration.body && moduleDeclaration.body.kind === 208 /* ModuleDeclaration */) { moduleDeclaration = moduleDeclaration.body; result.push(moduleDeclaration.name.text); } @@ -32638,7 +33073,7 @@ var ts; return getNavigationBarItem(moduleName, ts.ScriptElementKind.moduleElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } function createFunctionItem(node) { - if (node.body && node.body.kind === 180 /* Block */) { + if (node.body && node.body.kind === 182 /* Block */) { var childItems = getItemsWorker(sortNodes(node.body.statements), createChildItem); return getNavigationBarItem(!node.name ? "default" : node.name.text, ts.ScriptElementKind.functionElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } @@ -32659,7 +33094,7 @@ var ts; var childItems; if (node.members) { var constructor = ts.forEach(node.members, function (member) { - return member.kind === 136 /* Constructor */ && member; + return member.kind === 137 /* Constructor */ && member; }); // Add the constructor parameters in as children of the class (for property parameters). // Note that *all non-binding pattern named* parameters will be added to the nodes array, but parameters that @@ -32683,7 +33118,7 @@ var ts; } } function removeComputedProperties(node) { - return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 128 /* ComputedPropertyName */; }); + return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 129 /* ComputedPropertyName */; }); } /** * Like removeComputedProperties, but retains the properties with well known symbol names @@ -32692,13 +33127,13 @@ var ts; return ts.filter(node.members, function (member) { return !ts.hasDynamicName(member); }); } function getInnermostModule(node) { - while (node.body.kind === 206 /* ModuleDeclaration */) { + while (node.body.kind === 208 /* ModuleDeclaration */) { node = node.body; } return node; } function getNodeSpan(node) { - return node.kind === 228 /* SourceFile */ + return node.kind === 230 /* SourceFile */ ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); } @@ -33213,7 +33648,7 @@ var ts; var hasTransitionFromUpperToLower = transitionFromUpperToLower(identifier, word, i, wordStart); if (charIsPunctuation(identifier.charCodeAt(i - 1)) || charIsPunctuation(identifier.charCodeAt(i)) || - lastIsDigit != currentIsDigit || + lastIsDigit !== currentIsDigit || hasTransitionFromLowerToUpper || hasTransitionFromUpperToLower) { if (!isAllPunctuation(identifier, wordStart, i)) { @@ -33274,7 +33709,7 @@ var ts; // 3) HTMLDocument -> HTML, Document // // etc. - if (index != wordStart && + if (index !== wordStart && index + 1 < identifier.length) { var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index)); var nextIsLower = isLowerCaseLetter(identifier.charCodeAt(index + 1)); @@ -33493,7 +33928,7 @@ var ts; } return createSignatureHelpItems(candidates, resolvedSignature, argumentInfo); function createJavaScriptSignatureHelpItems(argumentInfo) { - if (argumentInfo.invocation.kind !== 158 /* CallExpression */) { + if (argumentInfo.invocation.kind !== 160 /* CallExpression */) { return undefined; } // See if we can find some symbol with the call expression name that has call signatures. @@ -33501,7 +33936,7 @@ var ts; var expression = callExpression.expression; var name = expression.kind === 65 /* Identifier */ ? expression - : expression.kind === 156 /* PropertyAccessExpression */ + : expression.kind === 158 /* PropertyAccessExpression */ ? expression.name : undefined; if (!name || !name.text) { @@ -33534,7 +33969,7 @@ var ts; * in the argument of an invocation; returns undefined otherwise. */ function getImmediatelyContainingArgumentInfo(node) { - if (node.parent.kind === 158 /* CallExpression */ || node.parent.kind === 159 /* NewExpression */) { + if (node.parent.kind === 160 /* CallExpression */ || node.parent.kind === 161 /* NewExpression */) { var callExpression = node.parent; // There are 3 cases to handle: // 1. The token introduces a list, and should begin a sig help session @@ -33587,25 +34022,25 @@ var ts; }; } } - else if (node.kind === 10 /* NoSubstitutionTemplateLiteral */ && node.parent.kind === 160 /* TaggedTemplateExpression */) { + else if (node.kind === 10 /* NoSubstitutionTemplateLiteral */ && node.parent.kind === 162 /* TaggedTemplateExpression */) { // Check if we're actually inside the template; // otherwise we'll fall out and return undefined. if (ts.isInsideTemplateLiteral(node, position)) { return getArgumentListInfoForTemplate(node.parent, 0); } } - else if (node.kind === 11 /* TemplateHead */ && node.parent.parent.kind === 160 /* TaggedTemplateExpression */) { + else if (node.kind === 11 /* TemplateHead */ && node.parent.parent.kind === 162 /* TaggedTemplateExpression */) { var templateExpression = node.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 172 /* TemplateExpression */); + ts.Debug.assert(templateExpression.kind === 174 /* TemplateExpression */); var argumentIndex = ts.isInsideTemplateLiteral(node, position) ? 0 : 1; return getArgumentListInfoForTemplate(tagExpression, argumentIndex); } - else if (node.parent.kind === 178 /* TemplateSpan */ && node.parent.parent.parent.kind === 160 /* TaggedTemplateExpression */) { + else if (node.parent.kind === 180 /* TemplateSpan */ && node.parent.parent.parent.kind === 162 /* TaggedTemplateExpression */) { var templateSpan = node.parent; var templateExpression = templateSpan.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 172 /* TemplateExpression */); + ts.Debug.assert(templateExpression.kind === 174 /* TemplateExpression */); // If we're just after a template tail, don't show signature help. if (node.kind === 13 /* TemplateTail */ && !ts.isInsideTemplateLiteral(node, position)) { return undefined; @@ -33723,7 +34158,7 @@ var ts; // // This is because a Missing node has no width. However, what we actually want is to include trivia // leading up to the next token in case the user is about to type in a TemplateMiddle or TemplateTail. - if (template.kind === 172 /* TemplateExpression */) { + if (template.kind === 174 /* TemplateExpression */) { var lastSpan = ts.lastOrUndefined(template.templateSpans); if (lastSpan.literal.getFullWidth() === 0) { applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, false); @@ -33732,7 +34167,7 @@ var ts; return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); } function getContainingArgumentInfo(node) { - for (var n = node; n.kind !== 228 /* SourceFile */; n = n.parent) { + for (var n = node; n.kind !== 230 /* SourceFile */; n = n.parent) { if (ts.isFunctionBlock(n)) { return undefined; } @@ -33933,40 +34368,40 @@ var ts; return false; } switch (n.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 155 /* ObjectLiteralExpression */: - case 151 /* ObjectBindingPattern */: - case 146 /* TypeLiteral */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 208 /* CaseBlock */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 157 /* ObjectLiteralExpression */: + case 153 /* ObjectBindingPattern */: + case 148 /* TypeLiteral */: + case 182 /* Block */: + case 209 /* ModuleBlock */: + case 210 /* CaseBlock */: return nodeEndsWith(n, 15 /* CloseBraceToken */, sourceFile); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return isCompletedNode(n.block, sourceFile); - case 159 /* NewExpression */: + case 161 /* NewExpression */: if (!n.arguments) { return true; } // fall through - case 158 /* CallExpression */: - case 162 /* ParenthesizedExpression */: - case 150 /* ParenthesizedType */: + case 160 /* CallExpression */: + case 164 /* ParenthesizedExpression */: + case 152 /* ParenthesizedType */: return nodeEndsWith(n, 17 /* CloseParenToken */, sourceFile); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return isCompletedNode(n.type, sourceFile); - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 164 /* ArrowFunction */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 141 /* ConstructSignature */: + case 140 /* CallSignature */: + case 166 /* ArrowFunction */: if (n.body) { return isCompletedNode(n.body, sourceFile); } @@ -33976,63 +34411,63 @@ var ts; // Even though type parameters can be unclosed, we can get away with // having at least a closing paren. return hasChildOfKind(n, 17 /* CloseParenToken */, sourceFile); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return n.body && isCompletedNode(n.body, sourceFile); - case 184 /* IfStatement */: + case 186 /* IfStatement */: if (n.elseStatement) { return isCompletedNode(n.elseStatement, sourceFile); } return isCompletedNode(n.thenStatement, sourceFile); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: return isCompletedNode(n.expression, sourceFile); - case 154 /* ArrayLiteralExpression */: - case 152 /* ArrayBindingPattern */: - case 157 /* ElementAccessExpression */: - case 128 /* ComputedPropertyName */: - case 148 /* TupleType */: + case 156 /* ArrayLiteralExpression */: + case 154 /* ArrayBindingPattern */: + case 159 /* ElementAccessExpression */: + case 129 /* ComputedPropertyName */: + case 150 /* TupleType */: return nodeEndsWith(n, 19 /* CloseBracketToken */, sourceFile); - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: if (n.type) { return isCompletedNode(n.type, sourceFile); } return hasChildOfKind(n, 19 /* CloseBracketToken */, sourceFile); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: // there is no such thing as terminator token for CaseClause/DefaultClause so for simplicitly always consider them non-completed return false; - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 188 /* WhileStatement */: return isCompletedNode(n.statement, sourceFile); - case 185 /* DoStatement */: + case 187 /* DoStatement */: // rough approximation: if DoStatement has While keyword - then if node is completed is checking the presence of ')'; var hasWhileKeyword = findChildOfKind(n, 100 /* WhileKeyword */, sourceFile); if (hasWhileKeyword) { return nodeEndsWith(n, 17 /* CloseParenToken */, sourceFile); } return isCompletedNode(n.statement, sourceFile); - case 145 /* TypeQuery */: + case 147 /* TypeQuery */: return isCompletedNode(n.exprName, sourceFile); - case 166 /* TypeOfExpression */: - case 165 /* DeleteExpression */: - case 167 /* VoidExpression */: - case 173 /* YieldExpression */: - case 174 /* SpreadElementExpression */: + case 168 /* TypeOfExpression */: + case 167 /* DeleteExpression */: + case 169 /* VoidExpression */: + case 175 /* YieldExpression */: + case 176 /* SpreadElementExpression */: var unaryWordExpression = n; return isCompletedNode(unaryWordExpression.expression, sourceFile); - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: return isCompletedNode(n.template, sourceFile); - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: var lastSpan = ts.lastOrUndefined(n.templateSpans); return isCompletedNode(lastSpan, sourceFile); - case 178 /* TemplateSpan */: + case 180 /* TemplateSpan */: return ts.nodeIsPresent(n.literal); - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: return isCompletedNode(n.operand, sourceFile); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return isCompletedNode(n.right, sourceFile); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return isCompletedNode(n.whenFalse, sourceFile); default: return true; @@ -34088,7 +34523,7 @@ var ts; // for the position of the relevant node (or comma). var syntaxList = ts.forEach(node.parent.getChildren(), function (c) { // find syntax list that covers the span of the node - if (c.kind === 251 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) { + if (c.kind === 253 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) { return c; } }); @@ -34222,7 +34657,7 @@ var ts; } } } - ts.Debug.assert(startNode !== undefined || n.kind === 228 /* SourceFile */); + ts.Debug.assert(startNode !== undefined || n.kind === 230 /* SourceFile */); // Here we know that none of child token nodes embrace the position, // the only known case is when position is at the end of the file. // Try to find the rightmost token in the file without filtering. @@ -34266,17 +34701,17 @@ var ts; } ts.getNodeModifiers = getNodeModifiers; function getTypeArgumentOrTypeParameterList(node) { - if (node.kind === 142 /* TypeReference */ || node.kind === 158 /* CallExpression */) { + if (node.kind === 144 /* TypeReference */ || node.kind === 160 /* CallExpression */) { return node.typeArguments; } - if (ts.isFunctionLike(node) || node.kind === 202 /* ClassDeclaration */ || node.kind === 203 /* InterfaceDeclaration */) { + if (ts.isFunctionLike(node) || node.kind === 204 /* ClassDeclaration */ || node.kind === 205 /* InterfaceDeclaration */) { return node.typeParameters; } return undefined; } ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList; function isToken(n) { - return n.kind >= 0 /* FirstToken */ && n.kind <= 126 /* LastToken */; + return n.kind >= 0 /* FirstToken */ && n.kind <= 127 /* LastToken */; } ts.isToken = isToken; function isWord(kind) { @@ -34331,7 +34766,7 @@ var ts; var ts; (function (ts) { function isFirstDeclarationOfSymbolParameter(symbol) { - return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 130 /* Parameter */; + return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 131 /* Parameter */; } ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter; var displayPartWriter = getDisplayPartWriter(); @@ -34744,7 +35179,7 @@ var ts; if (this.tokensAreOnSameLine === undefined) { var startLine = this.sourceFile.getLineAndCharacterOfPosition(this.currentTokenSpan.pos).line; var endLine = this.sourceFile.getLineAndCharacterOfPosition(this.nextTokenSpan.pos).line; - this.tokensAreOnSameLine = (startLine == endLine); + this.tokensAreOnSameLine = (startLine === endLine); } return this.tokensAreOnSameLine; }; @@ -34763,7 +35198,7 @@ var ts; FormattingContext.prototype.NodeIsOnOneLine = function (node) { var startLine = this.sourceFile.getLineAndCharacterOfPosition(node.getStart(this.sourceFile)).line; var endLine = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line; - return startLine == endLine; + return startLine === endLine; }; FormattingContext.prototype.BlockIsOnOneLine = function (node) { var openBrace = ts.findChildOfKind(node, 14 /* OpenBraceToken */, this.sourceFile); @@ -34923,7 +35358,7 @@ var ts; this.customContextChecks = funcs; } RuleOperationContext.prototype.IsAny = function () { - return this == RuleOperationContext.Any; + return this === RuleOperationContext.Any; }; RuleOperationContext.prototype.InContext = function (context) { if (this.IsAny()) { @@ -35029,7 +35464,7 @@ var ts; this.SpaceAfterTryFinally = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([96 /* TryKeyword */, 81 /* FinallyKeyword */]), 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); // get x() {} // set x(val) {} - this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116 /* GetKeyword */, 121 /* SetKeyword */]), 65 /* Identifier */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */)); + this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116 /* GetKeyword */, 122 /* SetKeyword */]), 65 /* Identifier */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */)); // Special case for binary operators (that are keywords). For these we have to add a space and shouldn't follow any user options. this.SpaceBeforeBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryKeywordOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); this.SpaceAfterBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryKeywordOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); @@ -35037,9 +35472,9 @@ var ts; // Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses this.NoSpaceAfterConstructor = new formatting.Rule(formatting.RuleDescriptor.create1(114 /* ConstructorKeyword */, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); // Use of module as a function call. e.g.: import m2 = module("m2"); - this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([117 /* ModuleKeyword */, 119 /* RequireKeyword */]), 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); + this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([118 /* ModuleKeyword */, 120 /* RequireKeyword */]), 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); // Add a space around certain TypeScript keywords - this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([69 /* ClassKeyword */, 115 /* DeclareKeyword */, 77 /* EnumKeyword */, 78 /* ExportKeyword */, 79 /* ExtendsKeyword */, 116 /* GetKeyword */, 102 /* ImplementsKeyword */, 85 /* ImportKeyword */, 103 /* InterfaceKeyword */, 117 /* ModuleKeyword */, 118 /* NamespaceKeyword */, 106 /* PrivateKeyword */, 108 /* PublicKeyword */, 121 /* SetKeyword */, 109 /* StaticKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); + this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([69 /* ClassKeyword */, 115 /* DeclareKeyword */, 77 /* EnumKeyword */, 78 /* ExportKeyword */, 79 /* ExtendsKeyword */, 116 /* GetKeyword */, 102 /* ImplementsKeyword */, 85 /* ImportKeyword */, 103 /* InterfaceKeyword */, 118 /* ModuleKeyword */, 119 /* NamespaceKeyword */, 106 /* PrivateKeyword */, 108 /* PublicKeyword */, 122 /* SetKeyword */, 109 /* StaticKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); this.SpaceBeforeCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([79 /* ExtendsKeyword */, 102 /* ImplementsKeyword */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { this.SpaceAfterModuleName = new formatting.Rule(formatting.RuleDescriptor.create1(8 /* StringLiteral */, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsModuleDeclContext), 2 /* Space */)); @@ -35059,7 +35494,7 @@ var ts; // decorators this.SpaceBeforeAt = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 52 /* AtToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); this.NoSpaceAfterAt = new formatting.Rule(formatting.RuleDescriptor.create3(52 /* AtToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([65 /* Identifier */, 78 /* ExportKeyword */, 73 /* DefaultKeyword */, 69 /* ClassKeyword */, 109 /* StaticKeyword */, 108 /* PublicKeyword */, 106 /* PrivateKeyword */, 107 /* ProtectedKeyword */, 116 /* GetKeyword */, 121 /* SetKeyword */, 18 /* OpenBracketToken */, 35 /* AsteriskToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2 /* Space */)); + this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([65 /* Identifier */, 78 /* ExportKeyword */, 73 /* DefaultKeyword */, 69 /* ClassKeyword */, 109 /* StaticKeyword */, 108 /* PublicKeyword */, 106 /* PrivateKeyword */, 107 /* ProtectedKeyword */, 116 /* GetKeyword */, 122 /* SetKeyword */, 18 /* OpenBracketToken */, 35 /* AsteriskToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2 /* Space */)); this.NoSpaceBetweenFunctionKeywordAndStar = new formatting.Rule(formatting.RuleDescriptor.create1(83 /* FunctionKeyword */, 35 /* AsteriskToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), 8 /* Delete */)); this.SpaceAfterStarInGeneratorDeclaration = new formatting.Rule(formatting.RuleDescriptor.create3(35 /* AsteriskToken */, formatting.Shared.TokenRange.FromTokens([65 /* Identifier */, 16 /* OpenParenToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), 2 /* Space */)); this.NoSpaceBetweenYieldKeywordAndStar = new formatting.Rule(formatting.RuleDescriptor.create1(110 /* YieldKeyword */, 35 /* AsteriskToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), 8 /* Delete */)); @@ -35155,9 +35590,9 @@ var ts; } Rules.prototype.getRuleName = function (rule) { var o = this; - for (var name_29 in o) { - if (o[name_29] === rule) { - return name_29; + for (var name_26 in o) { + if (o[name_26] === rule) { + return name_26; } } throw new Error("Unknown rule"); @@ -35166,36 +35601,37 @@ var ts; /// Contexts /// Rules.IsForContext = function (context) { - return context.contextNode.kind === 187 /* ForStatement */; + return context.contextNode.kind === 189 /* ForStatement */; }; Rules.IsNotForContext = function (context) { return !Rules.IsForContext(context); }; Rules.IsBinaryOpContext = function (context) { switch (context.contextNode.kind) { - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: + case 172 /* BinaryExpression */: + case 173 /* ConditionalExpression */: + case 143 /* TypePredicate */: return true; // equals in binding elements: function foo([[x, y] = [1, 2]]) - case 153 /* BindingElement */: + case 155 /* BindingElement */: // equals in type X = ... - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: // equal in import a = module('a'); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: // equal in let a = 0; - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: // equal in p = 0; - case 130 /* Parameter */: - case 227 /* EnumMember */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 131 /* Parameter */: + case 229 /* EnumMember */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return context.currentTokenSpan.kind === 53 /* EqualsToken */ || context.nextTokenSpan.kind === 53 /* EqualsToken */; // "in" keyword in for (let x in []) { } - case 188 /* ForInStatement */: + case 190 /* ForInStatement */: return context.currentTokenSpan.kind === 86 /* InKeyword */ || context.nextTokenSpan.kind === 86 /* InKeyword */; // Technically, "of" is not a binary operator, but format it the same way as "in" - case 189 /* ForOfStatement */: - return context.currentTokenSpan.kind === 126 /* OfKeyword */ || context.nextTokenSpan.kind === 126 /* OfKeyword */; + case 191 /* ForOfStatement */: + return context.currentTokenSpan.kind === 127 /* OfKeyword */ || context.nextTokenSpan.kind === 127 /* OfKeyword */; } return false; }; @@ -35203,7 +35639,7 @@ var ts; return !Rules.IsBinaryOpContext(context); }; Rules.IsConditionalOperatorContext = function (context) { - return context.contextNode.kind === 171 /* ConditionalExpression */; + return context.contextNode.kind === 173 /* ConditionalExpression */; }; Rules.IsSameLineTokenOrBeforeMultilineBlockContext = function (context) { //// This check is mainly used inside SpaceBeforeOpenBraceInControl and SpaceBeforeOpenBraceInFunction. @@ -35247,92 +35683,92 @@ var ts; return true; } switch (node.kind) { - case 180 /* Block */: - case 208 /* CaseBlock */: - case 155 /* ObjectLiteralExpression */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 210 /* CaseBlock */: + case 157 /* ObjectLiteralExpression */: + case 209 /* ModuleBlock */: return true; } return false; }; Rules.IsFunctionDeclContext = function (context) { switch (context.contextNode.kind) { - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: //case SyntaxKind.MemberFunctionDeclaration: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: ///case SyntaxKind.MethodSignature: - case 139 /* CallSignature */: - case 163 /* FunctionExpression */: - case 136 /* Constructor */: - case 164 /* ArrowFunction */: + case 140 /* CallSignature */: + case 165 /* FunctionExpression */: + case 137 /* Constructor */: + case 166 /* ArrowFunction */: //case SyntaxKind.ConstructorDeclaration: //case SyntaxKind.SimpleArrowFunctionExpression: //case SyntaxKind.ParenthesizedArrowFunctionExpression: - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return true; } return false; }; Rules.IsFunctionDeclarationOrFunctionExpressionContext = function (context) { - return context.contextNode.kind === 201 /* FunctionDeclaration */ || context.contextNode.kind === 163 /* FunctionExpression */; + return context.contextNode.kind === 203 /* FunctionDeclaration */ || context.contextNode.kind === 165 /* FunctionExpression */; }; Rules.IsTypeScriptDeclWithBlockContext = function (context) { return Rules.NodeIsTypeScriptDeclWithBlockContext(context.contextNode); }; Rules.NodeIsTypeScriptDeclWithBlockContext = function (node) { switch (node.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 146 /* TypeLiteral */: - case 206 /* ModuleDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 148 /* TypeLiteral */: + case 208 /* ModuleDeclaration */: return true; } return false; }; Rules.IsAfterCodeBlockContext = function (context) { switch (context.currentTokenParent.kind) { - case 202 /* ClassDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - case 180 /* Block */: - case 224 /* CatchClause */: - case 207 /* ModuleBlock */: - case 194 /* SwitchStatement */: + case 204 /* ClassDeclaration */: + case 208 /* ModuleDeclaration */: + case 207 /* EnumDeclaration */: + case 182 /* Block */: + case 226 /* CatchClause */: + case 209 /* ModuleBlock */: + case 196 /* SwitchStatement */: return true; } return false; }; Rules.IsControlDeclContext = function (context) { switch (context.contextNode.kind) { - case 184 /* IfStatement */: - case 194 /* SwitchStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: - case 197 /* TryStatement */: - case 185 /* DoStatement */: - case 193 /* WithStatement */: + case 186 /* IfStatement */: + case 196 /* SwitchStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 188 /* WhileStatement */: + case 199 /* TryStatement */: + case 187 /* DoStatement */: + case 195 /* WithStatement */: // TODO // case SyntaxKind.ElseClause: - case 224 /* CatchClause */: + case 226 /* CatchClause */: return true; default: return false; } }; Rules.IsObjectContext = function (context) { - return context.contextNode.kind === 155 /* ObjectLiteralExpression */; + return context.contextNode.kind === 157 /* ObjectLiteralExpression */; }; Rules.IsFunctionCallContext = function (context) { - return context.contextNode.kind === 158 /* CallExpression */; + return context.contextNode.kind === 160 /* CallExpression */; }; Rules.IsNewContext = function (context) { - return context.contextNode.kind === 159 /* NewExpression */; + return context.contextNode.kind === 161 /* NewExpression */; }; Rules.IsFunctionCallOrNewContext = function (context) { return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context); @@ -35356,38 +35792,38 @@ var ts; while (ts.isExpression(node)) { node = node.parent; } - return node.kind === 131 /* Decorator */; + return node.kind === 132 /* Decorator */; }; Rules.IsStartOfVariableDeclarationList = function (context) { - return context.currentTokenParent.kind === 200 /* VariableDeclarationList */ && + return context.currentTokenParent.kind === 202 /* VariableDeclarationList */ && context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos; }; Rules.IsNotFormatOnEnter = function (context) { - return context.formattingRequestKind != 2 /* FormatOnEnter */; + return context.formattingRequestKind !== 2 /* FormatOnEnter */; }; Rules.IsModuleDeclContext = function (context) { - return context.contextNode.kind === 206 /* ModuleDeclaration */; + return context.contextNode.kind === 208 /* ModuleDeclaration */; }; Rules.IsObjectTypeContext = function (context) { - return context.contextNode.kind === 146 /* TypeLiteral */; // && context.contextNode.parent.kind !== SyntaxKind.InterfaceDeclaration; + return context.contextNode.kind === 148 /* TypeLiteral */; // && context.contextNode.parent.kind !== SyntaxKind.InterfaceDeclaration; }; Rules.IsTypeArgumentOrParameter = function (token, parent) { if (token.kind !== 24 /* LessThanToken */ && token.kind !== 25 /* GreaterThanToken */) { return false; } switch (parent.kind) { - case 142 /* TypeReference */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 144 /* TypeReference */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return true; default: return false; @@ -35398,10 +35834,10 @@ var ts; Rules.IsTypeArgumentOrParameter(context.nextTokenSpan, context.nextTokenParent); }; Rules.IsVoidOpContext = function (context) { - return context.currentTokenSpan.kind === 99 /* VoidKeyword */ && context.currentTokenParent.kind === 167 /* VoidExpression */; + return context.currentTokenSpan.kind === 99 /* VoidKeyword */ && context.currentTokenParent.kind === 169 /* VoidExpression */; }; Rules.IsYieldOrYieldStarWithOperand = function (context) { - return context.contextNode.kind === 173 /* YieldExpression */ && context.contextNode.expression !== undefined; + return context.contextNode.kind === 175 /* YieldExpression */ && context.contextNode.expression !== undefined; }; return Rules; })(); @@ -35425,7 +35861,7 @@ var ts; return result; }; RulesMap.prototype.Initialize = function (rules) { - this.mapRowLength = 126 /* LastToken */ + 1; + this.mapRowLength = 127 /* LastToken */ + 1; this.map = new Array(this.mapRowLength * this.mapRowLength); //new Array(this.mapRowLength * this.mapRowLength); // This array is used only during construction of the rulesbucket in the map var rulesBucketConstructionStateList = new Array(this.map.length); //new Array(this.map.length); @@ -35445,13 +35881,13 @@ var ts; }; RulesMap.prototype.FillRule = function (rule, rulesBucketConstructionStateList) { var _this = this; - var specificRule = rule.Descriptor.LeftTokenRange != formatting.Shared.TokenRange.Any && - rule.Descriptor.RightTokenRange != formatting.Shared.TokenRange.Any; + var specificRule = rule.Descriptor.LeftTokenRange !== formatting.Shared.TokenRange.Any && + rule.Descriptor.RightTokenRange !== formatting.Shared.TokenRange.Any; rule.Descriptor.LeftTokenRange.GetTokens().forEach(function (left) { rule.Descriptor.RightTokenRange.GetTokens().forEach(function (right) { var rulesBucketIndex = _this.GetRuleBucketIndex(left, right); var rulesBucket = _this.map[rulesBucketIndex]; - if (rulesBucket == undefined) { + if (rulesBucket === undefined) { rulesBucket = _this.map[rulesBucketIndex] = new RulesBucket(); } rulesBucket.AddRule(rule, specificRule, rulesBucketConstructionStateList, rulesBucketIndex); @@ -35518,7 +35954,7 @@ var ts; RulesBucketConstructionState.prototype.IncreaseInsertionIndex = function (maskPosition) { var value = (this.rulesInsertionIndexBitmap >> maskPosition) & Mask; value++; - ts.Debug.assert((value & Mask) == value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules."); + ts.Debug.assert((value & Mask) === value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules."); var temp = this.rulesInsertionIndexBitmap & ~(Mask << maskPosition); temp |= value << maskPosition; this.rulesInsertionIndexBitmap = temp; @@ -35535,7 +35971,7 @@ var ts; }; RulesBucket.prototype.AddRule = function (rule, specificTokens, constructionState, rulesBucketIndex) { var position; - if (rule.Operation.Action == 1 /* Ignore */) { + if (rule.Operation.Action === 1 /* Ignore */) { position = specificTokens ? RulesPosition.IgnoreRulesSpecific : RulesPosition.IgnoreRulesAny; @@ -35610,7 +36046,7 @@ var ts; return [this.token]; }; TokenSingleValueAccess.prototype.Contains = function (tokenValue) { - return tokenValue == this.token; + return tokenValue === this.token; }; return TokenSingleValueAccess; })(); @@ -35620,7 +36056,7 @@ var ts; } TokenAllAccess.prototype.GetTokens = function () { var result = []; - for (var token = 0 /* FirstToken */; token <= 126 /* LastToken */; token++) { + for (var token = 0 /* FirstToken */; token <= 127 /* LastToken */; token++) { result.push(token); } return result; @@ -35662,9 +36098,9 @@ var ts; }; TokenRange.Any = TokenRange.AllTokens(); TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3 /* MultiLineCommentTrivia */])); - TokenRange.Keywords = TokenRange.FromRange(66 /* FirstKeyword */, 126 /* LastKeyword */); + TokenRange.Keywords = TokenRange.FromRange(66 /* FirstKeyword */, 127 /* LastKeyword */); TokenRange.BinaryOperators = TokenRange.FromRange(24 /* FirstBinaryOperator */, 64 /* LastBinaryOperator */); - TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([86 /* InKeyword */, 87 /* InstanceOfKeyword */, 126 /* OfKeyword */]); + TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([86 /* InKeyword */, 87 /* InstanceOfKeyword */, 127 /* OfKeyword */, 117 /* IsKeyword */]); TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([38 /* PlusPlusToken */, 39 /* MinusMinusToken */, 47 /* TildeToken */, 46 /* ExclamationToken */]); TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([7 /* NumericLiteral */, 65 /* Identifier */, 16 /* OpenParenToken */, 18 /* OpenBracketToken */, 14 /* OpenBraceToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 16 /* OpenParenToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); @@ -35672,7 +36108,7 @@ var ts; TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 16 /* OpenParenToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 17 /* CloseParenToken */, 19 /* CloseBracketToken */, 88 /* NewKeyword */]); TokenRange.Comments = TokenRange.FromTokens([2 /* SingleLineCommentTrivia */, 3 /* MultiLineCommentTrivia */]); - TokenRange.TypeNames = TokenRange.FromTokens([65 /* Identifier */, 120 /* NumberKeyword */, 122 /* StringKeyword */, 113 /* BooleanKeyword */, 123 /* SymbolKeyword */, 99 /* VoidKeyword */, 112 /* AnyKeyword */]); + TokenRange.TypeNames = TokenRange.FromTokens([65 /* Identifier */, 121 /* NumberKeyword */, 123 /* StringKeyword */, 113 /* BooleanKeyword */, 124 /* SymbolKeyword */, 99 /* VoidKeyword */, 112 /* AnyKeyword */]); return TokenRange; })(); Shared.TokenRange = TokenRange; @@ -35711,6 +36147,7 @@ var ts; return this.rulesMap; }; RulesProvider.prototype.ensureUpToDate = function (options) { + // TODO: Should this be '==='? if (this.options == null || !ts.compareDataObjects(this.options, options)) { var activeRules = this.createActiveRules(options); var rulesMap = formatting.RulesMap.create(activeRules); @@ -35875,17 +36312,17 @@ var ts; // i.e. parent is class declaration with the list of members and node is one of members. function isListElement(parent, node) { switch (parent.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: return ts.rangeContainsRange(parent.members, node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: var body = parent.body; - return body && body.kind === 180 /* Block */ && ts.rangeContainsRange(body.statements, node); - case 228 /* SourceFile */: - case 180 /* Block */: - case 207 /* ModuleBlock */: + return body && body.kind === 182 /* Block */ && ts.rangeContainsRange(body.statements, node); + case 230 /* SourceFile */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return ts.rangeContainsRange(parent.statements, node); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return ts.rangeContainsRange(parent.block.statements, node); } return false; @@ -36058,9 +36495,9 @@ var ts; // - source file // - switch\default clauses if (isSomeBlock(parent.kind) || - parent.kind === 228 /* SourceFile */ || - parent.kind === 221 /* CaseClause */ || - parent.kind === 222 /* DefaultClause */) { + parent.kind === 230 /* SourceFile */ || + parent.kind === 223 /* CaseClause */ || + parent.kind === 224 /* DefaultClause */) { indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(); } else { @@ -36096,19 +36533,19 @@ var ts; return node.modifiers[0].kind; } switch (node.kind) { - case 202 /* ClassDeclaration */: return 69 /* ClassKeyword */; - case 203 /* InterfaceDeclaration */: return 103 /* InterfaceKeyword */; - case 201 /* FunctionDeclaration */: return 83 /* FunctionKeyword */; - case 205 /* EnumDeclaration */: return 205 /* EnumDeclaration */; - case 137 /* GetAccessor */: return 116 /* GetKeyword */; - case 138 /* SetAccessor */: return 121 /* SetKeyword */; - case 135 /* MethodDeclaration */: + case 204 /* ClassDeclaration */: return 69 /* ClassKeyword */; + case 205 /* InterfaceDeclaration */: return 103 /* InterfaceKeyword */; + case 203 /* FunctionDeclaration */: return 83 /* FunctionKeyword */; + case 207 /* EnumDeclaration */: return 207 /* EnumDeclaration */; + case 138 /* GetAccessor */: return 116 /* GetKeyword */; + case 139 /* SetAccessor */: return 122 /* SetKeyword */; + case 136 /* MethodDeclaration */: if (node.asteriskToken) { return 35 /* AsteriskToken */; } // fall-through - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 131 /* Parameter */: return node.name.kind; } } @@ -36241,7 +36678,7 @@ var ts; consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation); return inheritedIndentation; } - var effectiveParentStartLine = child.kind === 131 /* Decorator */ ? childStartLine : undecoratedParentStartLine; + var effectiveParentStartLine = child.kind === 132 /* Decorator */ ? childStartLine : undecoratedParentStartLine; var childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine); processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta); childContextNode = node; @@ -36564,20 +37001,20 @@ var ts; } function isSomeBlock(kind) { switch (kind) { - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return true; } return false; } function getOpenTokenForList(node, list) { switch (node.kind) { - case 136 /* Constructor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 164 /* ArrowFunction */: + case 137 /* Constructor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 166 /* ArrowFunction */: if (node.typeParameters === list) { return 24 /* LessThanToken */; } @@ -36585,8 +37022,8 @@ var ts; return 16 /* OpenParenToken */; } break; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: if (node.typeArguments === list) { return 24 /* LessThanToken */; } @@ -36594,7 +37031,7 @@ var ts; return 16 /* OpenParenToken */; } break; - case 142 /* TypeReference */: + case 144 /* TypeReference */: if (node.typeArguments === list) { return 24 /* LessThanToken */; } @@ -36693,7 +37130,7 @@ var ts; return 0; } var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; - if (precedingToken.kind === 23 /* CommaToken */ && precedingToken.parent.kind !== 170 /* BinaryExpression */) { + if (precedingToken.kind === 23 /* CommaToken */ && precedingToken.parent.kind !== 172 /* BinaryExpression */) { // previous token is comma that separates items in list - find the previous item and try to derive indentation from it var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); if (actualIndentation !== -1 /* Unknown */) { @@ -36804,7 +37241,7 @@ var ts; // - parent is SourceFile - by default immediate children of SourceFile are not indented except when user indents them manually // - parent and child are not on the same line var useActualIndentation = (ts.isDeclaration(current) || ts.isStatement(current)) && - (parent.kind === 228 /* SourceFile */ || !parentAndChildShareLine); + (parent.kind === 230 /* SourceFile */ || !parentAndChildShareLine); if (!useActualIndentation) { return -1 /* Unknown */; } @@ -36837,7 +37274,7 @@ var ts; return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); } function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) { - if (parent.kind === 184 /* IfStatement */ && parent.elseStatement === child) { + if (parent.kind === 186 /* IfStatement */ && parent.elseStatement === child) { var elseKeyword = ts.findChildOfKind(parent, 76 /* ElseKeyword */, sourceFile); ts.Debug.assert(elseKeyword !== undefined); var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line; @@ -36849,23 +37286,23 @@ var ts; function getContainingList(node, sourceFile) { if (node.parent) { switch (node.parent.kind) { - case 142 /* TypeReference */: + case 144 /* TypeReference */: if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, node.getStart(sourceFile), node.getEnd())) { return node.parent.typeArguments; } break; - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return node.parent.properties; - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return node.parent.elements; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: { + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: { var start = node.getStart(sourceFile); if (node.parent.typeParameters && ts.rangeContainsStartEnd(node.parent.typeParameters, start, node.getEnd())) { @@ -36876,8 +37313,8 @@ var ts; } break; } - case 159 /* NewExpression */: - case 158 /* CallExpression */: { + case 161 /* NewExpression */: + case 160 /* CallExpression */: { var start = node.getStart(sourceFile); if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, start, node.getEnd())) { @@ -36956,28 +37393,28 @@ var ts; SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn; function nodeContentIsAlwaysIndented(kind) { switch (kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 154 /* ArrayLiteralExpression */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 155 /* ObjectLiteralExpression */: - case 146 /* TypeLiteral */: - case 148 /* TupleType */: - case 208 /* CaseBlock */: - case 222 /* DefaultClause */: - case 221 /* CaseClause */: - case 162 /* ParenthesizedExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 181 /* VariableStatement */: - case 199 /* VariableDeclaration */: - case 215 /* ExportAssignment */: - case 192 /* ReturnStatement */: - case 171 /* ConditionalExpression */: - case 152 /* ArrayBindingPattern */: - case 151 /* ObjectBindingPattern */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 156 /* ArrayLiteralExpression */: + case 182 /* Block */: + case 209 /* ModuleBlock */: + case 157 /* ObjectLiteralExpression */: + case 148 /* TypeLiteral */: + case 150 /* TupleType */: + case 210 /* CaseBlock */: + case 224 /* DefaultClause */: + case 223 /* CaseClause */: + case 164 /* ParenthesizedExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 183 /* VariableStatement */: + case 201 /* VariableDeclaration */: + case 217 /* ExportAssignment */: + case 194 /* ReturnStatement */: + case 173 /* ConditionalExpression */: + case 154 /* ArrayBindingPattern */: + case 153 /* ObjectBindingPattern */: return true; } return false; @@ -36987,22 +37424,22 @@ var ts; return true; } switch (parent) { - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 184 /* IfStatement */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 164 /* ArrowFunction */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - return child !== 180 /* Block */; + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 189 /* ForStatement */: + case 186 /* IfStatement */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 140 /* CallSignature */: + case 166 /* ArrowFunction */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + return child !== 182 /* Block */; default: return false; } @@ -37015,8 +37452,7 @@ var ts; var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; /// /// @@ -37085,7 +37521,7 @@ var ts; return this.getEnd() - this.getStart(sourceFile); }; NodeObject.prototype.getFullWidth = function () { - return this.end - this.getFullStart(); + return this.end - this.pos; }; NodeObject.prototype.getLeadingTriviaWidth = function (sourceFile) { return this.getStart(sourceFile) - this.pos; @@ -37107,7 +37543,7 @@ var ts; return pos; }; NodeObject.prototype.createSyntaxList = function (nodes) { - var list = createNode(251 /* SyntaxList */, nodes.pos, nodes.end, 1024 /* Synthetic */, this); + var list = createNode(253 /* SyntaxList */, nodes.pos, nodes.end, 1024 /* Synthetic */, this); list._children = []; var pos = nodes.pos; for (var _i = 0; _i < nodes.length; _i++) { @@ -37126,7 +37562,7 @@ var ts; NodeObject.prototype.createChildren = function (sourceFile) { var _this = this; var children; - if (this.kind >= 127 /* FirstNode */) { + if (this.kind >= 128 /* FirstNode */) { scanner.setText((sourceFile || this.getSourceFile()).text); children = []; var pos = this.pos; @@ -37171,7 +37607,7 @@ var ts; var children = this.getChildren(); for (var _i = 0; _i < children.length; _i++) { var child = children[_i]; - if (child.kind < 127 /* FirstNode */) { + if (child.kind < 128 /* FirstNode */) { return child; } return child.getFirstToken(sourceFile); @@ -37181,7 +37617,7 @@ var ts; var children = this.getChildren(sourceFile); for (var i = children.length - 1; i >= 0; i--) { var child = children[i]; - if (child.kind < 127 /* FirstNode */) { + if (child.kind < 128 /* FirstNode */) { return child; } return child.getLastToken(sourceFile); @@ -37234,7 +37670,7 @@ var ts; if (ts.indexOf(declarations, declaration) === indexOfDeclaration) { var sourceFileOfDeclaration = ts.getSourceFileOfNode(declaration); // If it is parameter - try and get the jsDoc comment with @param tag from function declaration's jsDoc comments - if (canUseParsedParamTagComments && declaration.kind === 130 /* Parameter */) { + if (canUseParsedParamTagComments && declaration.kind === 131 /* Parameter */) { ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedParamJsDocComment) { @@ -37243,15 +37679,15 @@ var ts; }); } // If this is left side of dotted module declaration, there is no doc comments associated with this node - if (declaration.kind === 206 /* ModuleDeclaration */ && declaration.body.kind === 206 /* ModuleDeclaration */) { + if (declaration.kind === 208 /* ModuleDeclaration */ && declaration.body.kind === 208 /* ModuleDeclaration */) { return; } // If this is dotted module name, get the doc comments from the parent - while (declaration.kind === 206 /* ModuleDeclaration */ && declaration.parent.kind === 206 /* ModuleDeclaration */) { + while (declaration.kind === 208 /* ModuleDeclaration */ && declaration.parent.kind === 208 /* ModuleDeclaration */) { declaration = declaration.parent; } // Get the cleaned js doc comment text from the declaration - ts.forEach(getJsDocCommentTextRange(declaration.kind === 199 /* VariableDeclaration */ ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { + ts.forEach(getJsDocCommentTextRange(declaration.kind === 201 /* VariableDeclaration */ ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedJsDocComment) { jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment); @@ -37590,9 +38026,9 @@ var ts; if (result_2 !== undefined) { return result_2; } - if (declaration.name.kind === 128 /* ComputedPropertyName */) { + if (declaration.name.kind === 129 /* ComputedPropertyName */) { var expr = declaration.name.expression; - if (expr.kind === 156 /* PropertyAccessExpression */) { + if (expr.kind === 158 /* PropertyAccessExpression */) { return expr.name.text; } return getTextOfIdentifierOrLiteral(expr); @@ -37612,9 +38048,9 @@ var ts; } function visit(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: var functionDeclaration = node; var declarationName = getDeclarationName(functionDeclaration); if (declarationName) { @@ -37634,60 +38070,60 @@ var ts; ts.forEachChild(node, visit); } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 218 /* ExportSpecifier */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 146 /* TypeLiteral */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 207 /* EnumDeclaration */: + case 208 /* ModuleDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 220 /* ExportSpecifier */: + case 216 /* ImportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 213 /* ImportClause */: + case 214 /* NamespaceImport */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 148 /* TypeLiteral */: addDeclaration(node); // fall through - case 136 /* Constructor */: - case 181 /* VariableStatement */: - case 200 /* VariableDeclarationList */: - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 207 /* ModuleBlock */: + case 137 /* Constructor */: + case 183 /* VariableStatement */: + case 202 /* VariableDeclarationList */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: + case 209 /* ModuleBlock */: ts.forEachChild(node, visit); break; - case 180 /* Block */: + case 182 /* Block */: if (ts.isFunctionBlock(node)) { ts.forEachChild(node, visit); } break; - case 130 /* Parameter */: + case 131 /* Parameter */: // Only consider properties defined as constructor parameters if (!(node.flags & 112 /* AccessibilityModifier */)) { break; } // fall through - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: if (ts.isBindingPattern(node.name)) { ts.forEachChild(node.name, visit); break; } - case 227 /* EnumMember */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 229 /* EnumMember */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: addDeclaration(node); break; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: // Handle named exports case e.g.: // export {a, b as B} from "mod"; if (node.exportClause) { ts.forEach(node.exportClause.elements, visit); } break; - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: var importClause = node.importClause; if (importClause) { // Handle default import case e.g.: @@ -37699,7 +38135,7 @@ var ts; // import * as NS from "mod"; // import {a, b as B} from "mod"; if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 214 /* NamespaceImport */) { addDeclaration(importClause.namedBindings); } else { @@ -37900,16 +38336,16 @@ var ts; } return ts.forEach(symbol.declarations, function (declaration) { // Function expressions are local - if (declaration.kind === 163 /* FunctionExpression */) { + if (declaration.kind === 165 /* FunctionExpression */) { return true; } - if (declaration.kind !== 199 /* VariableDeclaration */ && declaration.kind !== 201 /* FunctionDeclaration */) { + if (declaration.kind !== 201 /* VariableDeclaration */ && declaration.kind !== 203 /* FunctionDeclaration */) { return false; } // If the parent is not sourceFile or module block it is local variable - for (var parent_8 = declaration.parent; !ts.isFunctionBlock(parent_8); parent_8 = parent_8.parent) { + for (var parent_9 = declaration.parent; !ts.isFunctionBlock(parent_9); parent_9 = parent_9.parent) { // Reached source file or module block - if (parent_8.kind === 228 /* SourceFile */ || parent_8.kind === 207 /* ModuleBlock */) { + if (parent_9.kind === 230 /* SourceFile */ || parent_9.kind === 209 /* ModuleBlock */) { return false; } } @@ -37953,9 +38389,8 @@ var ts; var HostCache = (function () { function HostCache(host, getCanonicalFileName) { this.host = host; - this.getCanonicalFileName = getCanonicalFileName; // script id => script index - this.fileNameToEntry = {}; + this.fileNameToEntry = ts.createFileMap(getCanonicalFileName); // Initialize the list with the root file names var rootFileNames = host.getScriptFileNames(); for (var _i = 0; _i < rootFileNames.length; _i++) { @@ -37968,9 +38403,6 @@ var ts; HostCache.prototype.compilationSettings = function () { return this._compilationSettings; }; - HostCache.prototype.normalizeFileName = function (fileName) { - return this.getCanonicalFileName(ts.normalizeSlashes(fileName)); - }; HostCache.prototype.createEntry = function (fileName) { var entry; var scriptSnapshot = this.host.getScriptSnapshot(fileName); @@ -37981,13 +38413,14 @@ var ts; scriptSnapshot: scriptSnapshot }; } - return this.fileNameToEntry[this.normalizeFileName(fileName)] = entry; + this.fileNameToEntry.set(fileName, entry); + return entry; }; HostCache.prototype.getEntry = function (fileName) { - return ts.lookUp(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.get(fileName); }; HostCache.prototype.contains = function (fileName) { - return ts.hasProperty(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.contains(fileName); }; HostCache.prototype.getOrCreateEntry = function (fileName) { if (this.contains(fileName)) { @@ -37996,12 +38429,10 @@ var ts; return this.createEntry(fileName); }; HostCache.prototype.getRootFileNames = function () { - var _this = this; var fileNames = []; - ts.forEachKey(this.fileNameToEntry, function (key) { - var entry = _this.getEntry(key); - if (entry) { - fileNames.push(entry.hostFileName); + this.fileNameToEntry.forEachValue(function (value) { + if (value) { + fileNames.push(value.hostFileName); } }); return fileNames; @@ -38061,7 +38492,7 @@ var ts; * - noLib = true * - noResolve = true */ - function transpile(input, compilerOptions, fileName, diagnostics) { + function transpile(input, compilerOptions, fileName, diagnostics, moduleName) { var options = compilerOptions ? ts.clone(compilerOptions) : getDefaultCompilerOptions(); options.isolatedModules = true; // Filename can be non-ts file. @@ -38075,9 +38506,8 @@ var ts; // Parse var inputFileName = fileName || "module.ts"; var sourceFile = ts.createSourceFile(inputFileName, input, options.target); - // Store syntactic diagnostics - if (diagnostics && sourceFile.parseDiagnostics) { - diagnostics.push.apply(diagnostics, sourceFile.parseDiagnostics); + if (moduleName) { + sourceFile.moduleName = moduleName; } var newLine = ts.getNewLineCharacter(options); // Output @@ -38096,9 +38526,8 @@ var ts; getNewLine: function () { return newLine; } }; var program = ts.createProgram([inputFileName], options, compilerHost); - if (diagnostics) { - diagnostics.push.apply(diagnostics, program.getCompilerOptionsDiagnostics()); - } + ts.addRange(diagnostics, program.getSyntacticDiagnostics(sourceFile)); + ts.addRange(diagnostics, program.getOptionsDiagnostics()); // Emit program.emit(); ts.Debug.assert(outputText !== undefined, "Output generation failed"); @@ -38158,10 +38587,16 @@ var ts; return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, true); } ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; - function createDocumentRegistry() { + function createGetCanonicalFileName(useCaseSensitivefileNames) { + return useCaseSensitivefileNames + ? (function (fileName) { return fileName; }) + : (function (fileName) { return fileName.toLowerCase(); }); + } + function createDocumentRegistry(useCaseSensitiveFileNames) { // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have // for those settings. var buckets = {}; + var getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames); function getKeyFromCompilationSettings(settings) { return "_" + settings.target; // + "|" + settings.propagateEnumConstantoString() } @@ -38169,7 +38604,7 @@ var ts; var key = getKeyFromCompilationSettings(settings); var bucket = ts.lookUp(buckets, key); if (!bucket && createIfMissing) { - buckets[key] = bucket = {}; + buckets[key] = bucket = ts.createFileMap(getCanonicalFileName); } return bucket; } @@ -38178,7 +38613,7 @@ var ts; var entries = ts.lookUp(buckets, name); var sourceFiles = []; for (var i in entries) { - var entry = entries[i]; + var entry = entries.get(i); sourceFiles.push({ name: i, refCount: entry.languageServiceRefCount, @@ -38201,16 +38636,17 @@ var ts; } function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) { var bucket = getBucketForCompilationSettings(compilationSettings, true); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); if (!entry) { ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?"); // Have never seen this file with these settings. Create a new source file for it. var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false); - bucket[fileName] = entry = { + entry = { sourceFile: sourceFile, languageServiceRefCount: 0, owners: [] }; + bucket.set(fileName, entry); } else { // We have an entry for this file. However, it may be for a different version of @@ -38233,11 +38669,11 @@ var ts; function releaseDocument(fileName, compilationSettings) { var bucket = getBucketForCompilationSettings(compilationSettings, false); ts.Debug.assert(bucket !== undefined); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); entry.languageServiceRefCount--; ts.Debug.assert(entry.languageServiceRefCount >= 0); if (entry.languageServiceRefCount === 0) { - delete bucket[fileName]; + bucket.remove(fileName); } } return { @@ -38300,7 +38736,7 @@ var ts; else { if (token === 65 /* Identifier */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // import d from "mod"; @@ -38310,7 +38746,7 @@ var ts; } else if (token === 53 /* EqualsToken */) { token = scanner.scan(); - if (token === 119 /* RequireKeyword */) { + if (token === 120 /* RequireKeyword */) { token = scanner.scan(); if (token === 16 /* OpenParenToken */) { token = scanner.scan(); @@ -38339,7 +38775,7 @@ var ts; } if (token === 15 /* CloseBraceToken */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // import {a as A} from "mod"; @@ -38355,7 +38791,7 @@ var ts; token = scanner.scan(); if (token === 65 /* Identifier */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // import * as NS from "mod" @@ -38378,7 +38814,7 @@ var ts; } if (token === 15 /* CloseBraceToken */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // export {a as A} from "mod"; @@ -38390,7 +38826,7 @@ var ts; } else if (token === 35 /* AsteriskToken */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // export * from "mod" @@ -38413,7 +38849,7 @@ var ts; /// Helpers function getTargetLabel(referenceNode, labelName) { while (referenceNode) { - if (referenceNode.kind === 195 /* LabeledStatement */ && referenceNode.label.text === labelName) { + if (referenceNode.kind === 197 /* LabeledStatement */ && referenceNode.label.text === labelName) { return referenceNode.label; } referenceNode = referenceNode.parent; @@ -38422,12 +38858,12 @@ var ts; } function isJumpStatementTarget(node) { return node.kind === 65 /* Identifier */ && - (node.parent.kind === 191 /* BreakStatement */ || node.parent.kind === 190 /* ContinueStatement */) && + (node.parent.kind === 193 /* BreakStatement */ || node.parent.kind === 192 /* ContinueStatement */) && node.parent.label === node; } function isLabelOfLabeledStatement(node) { return node.kind === 65 /* Identifier */ && - node.parent.kind === 195 /* LabeledStatement */ && + node.parent.kind === 197 /* LabeledStatement */ && node.parent.label === node; } /** @@ -38435,7 +38871,7 @@ var ts; * Note: 'node' cannot be a SourceFile. */ function isLabeledBy(node, labelName) { - for (var owner = node.parent; owner.kind === 195 /* LabeledStatement */; owner = owner.parent) { + for (var owner = node.parent; owner.kind === 197 /* LabeledStatement */; owner = owner.parent) { if (owner.label.text === labelName) { return true; } @@ -38446,25 +38882,25 @@ var ts; return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node); } function isRightSideOfQualifiedName(node) { - return node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node; + return node.parent.kind === 128 /* QualifiedName */ && node.parent.right === node; } function isRightSideOfPropertyAccess(node) { - return node && node.parent && node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node; + return node && node.parent && node.parent.kind === 158 /* PropertyAccessExpression */ && node.parent.name === node; } function isCallExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 158 /* CallExpression */ && node.parent.expression === node; + return node && node.parent && node.parent.kind === 160 /* CallExpression */ && node.parent.expression === node; } function isNewExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 159 /* NewExpression */ && node.parent.expression === node; + return node && node.parent && node.parent.kind === 161 /* NewExpression */ && node.parent.expression === node; } function isNameOfModuleDeclaration(node) { - return node.parent.kind === 206 /* ModuleDeclaration */ && node.parent.name === node; + return node.parent.kind === 208 /* ModuleDeclaration */ && node.parent.name === node; } function isNameOfFunctionDeclaration(node) { return node.kind === 65 /* Identifier */ && @@ -38473,22 +38909,22 @@ var ts; /** Returns true if node is a name of an object literal property, e.g. "a" in x = { "a": 1 } */ function isNameOfPropertyAssignment(node) { return (node.kind === 65 /* Identifier */ || node.kind === 8 /* StringLiteral */ || node.kind === 7 /* NumericLiteral */) && - (node.parent.kind === 225 /* PropertyAssignment */ || node.parent.kind === 226 /* ShorthandPropertyAssignment */) && node.parent.name === node; + (node.parent.kind === 227 /* PropertyAssignment */ || node.parent.kind === 228 /* ShorthandPropertyAssignment */) && node.parent.name === node; } function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) { if (node.kind === 8 /* StringLiteral */ || node.kind === 7 /* NumericLiteral */) { switch (node.parent.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 206 /* ModuleDeclaration */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 227 /* PropertyAssignment */: + case 229 /* EnumMember */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 208 /* ModuleDeclaration */: return node.parent.name === node; - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: return node.parent.argumentExpression === node; } } @@ -38547,7 +38983,7 @@ var ts; })(BreakContinueSearchType || (BreakContinueSearchType = {})); // A cache of completion entries for keywords, these do not change between sessions var keywordCompletions = []; - for (var i = 66 /* FirstKeyword */; i <= 126 /* LastKeyword */; i++) { + for (var i = 66 /* FirstKeyword */; i <= 127 /* LastKeyword */; i++) { keywordCompletions.push({ name: ts.tokenToString(i), kind: ScriptElementKind.keyword, @@ -38562,17 +38998,17 @@ var ts; return undefined; } switch (node.kind) { - case 228 /* SourceFile */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: + case 230 /* SourceFile */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 208 /* ModuleDeclaration */: return node; } } @@ -38580,38 +39016,38 @@ var ts; ts.getContainerNode = getContainerNode; /* @internal */ function getNodeKind(node) { switch (node.kind) { - case 206 /* ModuleDeclaration */: return ScriptElementKind.moduleElement; - case 202 /* ClassDeclaration */: return ScriptElementKind.classElement; - case 203 /* InterfaceDeclaration */: return ScriptElementKind.interfaceElement; - case 204 /* TypeAliasDeclaration */: return ScriptElementKind.typeElement; - case 205 /* EnumDeclaration */: return ScriptElementKind.enumElement; - case 199 /* VariableDeclaration */: + case 208 /* ModuleDeclaration */: return ScriptElementKind.moduleElement; + case 204 /* ClassDeclaration */: return ScriptElementKind.classElement; + case 205 /* InterfaceDeclaration */: return ScriptElementKind.interfaceElement; + case 206 /* TypeAliasDeclaration */: return ScriptElementKind.typeElement; + case 207 /* EnumDeclaration */: return ScriptElementKind.enumElement; + case 201 /* VariableDeclaration */: return ts.isConst(node) ? ScriptElementKind.constElement : ts.isLet(node) ? ScriptElementKind.letElement : ScriptElementKind.variableElement; - case 201 /* FunctionDeclaration */: return ScriptElementKind.functionElement; - case 137 /* GetAccessor */: return ScriptElementKind.memberGetAccessorElement; - case 138 /* SetAccessor */: return ScriptElementKind.memberSetAccessorElement; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 203 /* FunctionDeclaration */: return ScriptElementKind.functionElement; + case 138 /* GetAccessor */: return ScriptElementKind.memberGetAccessorElement; + case 139 /* SetAccessor */: return ScriptElementKind.memberSetAccessorElement; + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return ScriptElementKind.memberFunctionElement; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return ScriptElementKind.memberVariableElement; - case 141 /* IndexSignature */: return ScriptElementKind.indexSignatureElement; - case 140 /* ConstructSignature */: return ScriptElementKind.constructSignatureElement; - case 139 /* CallSignature */: return ScriptElementKind.callSignatureElement; - case 136 /* Constructor */: return ScriptElementKind.constructorImplementationElement; - case 129 /* TypeParameter */: return ScriptElementKind.typeParameterElement; - case 227 /* EnumMember */: return ScriptElementKind.variableElement; - case 130 /* Parameter */: return (node.flags & 112 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 211 /* ImportClause */: - case 218 /* ExportSpecifier */: - case 212 /* NamespaceImport */: + case 142 /* IndexSignature */: return ScriptElementKind.indexSignatureElement; + case 141 /* ConstructSignature */: return ScriptElementKind.constructSignatureElement; + case 140 /* CallSignature */: return ScriptElementKind.callSignatureElement; + case 137 /* Constructor */: return ScriptElementKind.constructorImplementationElement; + case 130 /* TypeParameter */: return ScriptElementKind.typeParameterElement; + case 229 /* EnumMember */: return ScriptElementKind.variableElement; + case 131 /* Parameter */: return (node.flags & 112 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; + case 211 /* ImportEqualsDeclaration */: + case 216 /* ImportSpecifier */: + case 213 /* ImportClause */: + case 220 /* ExportSpecifier */: + case 214 /* NamespaceImport */: return ScriptElementKind.alias; } return ScriptElementKind.unknown; @@ -38634,9 +39070,7 @@ var ts; host.log(message); } } - function getCanonicalFileName(fileName) { - return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); - } + var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames); function getValidSourceFile(fileName) { fileName = ts.normalizeSlashes(fileName); var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); @@ -38827,44 +39261,44 @@ var ts; return false; } switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_a_ts_file)); return true; - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.export_can_only_be_used_in_a_ts_file)); return true; - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: var classDeclaration = node; if (checkModifiers(classDeclaration.modifiers) || checkTypeParameters(classDeclaration.typeParameters)) { return true; } break; - case 223 /* HeritageClause */: + case 225 /* HeritageClause */: var heritageClause = node; if (heritageClause.token === 102 /* ImplementsKeyword */) { diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file)); return true; } break; - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.interface_declarations_can_only_be_used_in_a_ts_file)); return true; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.module_declarations_can_only_be_used_in_a_ts_file)); return true; - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.type_aliases_can_only_be_used_in_a_ts_file)); return true; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 201 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: var functionDeclaration = node; if (checkModifiers(functionDeclaration.modifiers) || checkTypeParameters(functionDeclaration.typeParameters) || @@ -38872,20 +39306,20 @@ var ts; return true; } break; - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: var variableStatement = node; if (checkModifiers(variableStatement.modifiers)) { return true; } break; - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: var variableDeclaration = node; if (checkTypeAnnotation(variableDeclaration.type)) { return true; } break; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: var expression = node; if (expression.typeArguments && expression.typeArguments.length > 0) { var start = expression.typeArguments.pos; @@ -38893,7 +39327,7 @@ var ts; return true; } break; - case 130 /* Parameter */: + case 131 /* Parameter */: var parameter = node; if (parameter.modifiers) { var start = parameter.modifiers.pos; @@ -38909,17 +39343,17 @@ var ts; return true; } break; - case 133 /* PropertyDeclaration */: + case 134 /* PropertyDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.property_declarations_can_only_be_used_in_a_ts_file)); return true; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file)); return true; - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: var typeAssertionExpression = node; diagnostics.push(ts.createDiagnosticForNode(typeAssertionExpression.type, ts.Diagnostics.type_assertion_expressions_can_only_be_used_in_a_ts_file)); return true; - case 131 /* Decorator */: + case 132 /* Decorator */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.decorators_can_only_be_used_in_a_ts_file)); return true; } @@ -38964,7 +39398,7 @@ var ts; } function getCompilerOptionsDiagnostics() { synchronizeHostData(); - return program.getGlobalDiagnostics(); + return program.getOptionsDiagnostics().concat(program.getGlobalDiagnostics()); } /// Completion function getCompletionEntryDisplayNameForSymbol(symbol, target, performCharacterChecks) { @@ -39053,11 +39487,11 @@ var ts; // visible symbols in the scope, and the node is the current location. var node = currentToken; var isRightOfDot = false; - if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 156 /* PropertyAccessExpression */) { + if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 158 /* PropertyAccessExpression */) { node = contextToken.parent.expression; isRightOfDot = true; } - else if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 127 /* QualifiedName */) { + else if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 128 /* QualifiedName */) { node = contextToken.parent.left; isRightOfDot = true; } @@ -39084,7 +39518,7 @@ var ts; // Right of dot member completion list isMemberCompletion = true; isNewIdentifierLocation = false; - if (node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */ || node.kind === 156 /* PropertyAccessExpression */) { + if (node.kind === 65 /* Identifier */ || node.kind === 128 /* QualifiedName */ || node.kind === 158 /* PropertyAccessExpression */) { var symbol = typeChecker.getSymbolAtLocation(node); // This is an alias, follow what it aliases if (symbol && symbol.flags & 8388608 /* Alias */) { @@ -39142,13 +39576,13 @@ var ts; symbols = filterContextualMembersList(contextualTypeMembers, containingObjectLiteral.properties); } } - else if (ts.getAncestor(contextToken, 211 /* ImportClause */)) { + else if (ts.getAncestor(contextToken, 213 /* ImportClause */)) { // cursor is in import clause // try to show exported member for imported module isMemberCompletion = true; isNewIdentifierLocation = true; if (showCompletionsInImportsClause(contextToken)) { - var importDeclaration = ts.getAncestor(contextToken, 210 /* ImportDeclaration */); + var importDeclaration = ts.getAncestor(contextToken, 212 /* ImportDeclaration */); ts.Debug.assert(importDeclaration !== undefined); var exports; if (importDeclaration.moduleSpecifier) { @@ -39227,7 +39661,7 @@ var ts; // import {| // import {a,| if (node.kind === 14 /* OpenBraceToken */ || node.kind === 23 /* CommaToken */) { - return node.parent.kind === 213 /* NamedImports */; + return node.parent.kind === 215 /* NamedImports */; } } return false; @@ -39237,38 +39671,38 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23 /* CommaToken */: - return containingNodeKind === 158 /* CallExpression */ // func( a, | - || containingNodeKind === 136 /* Constructor */ // constructor( a, | public, protected, private keywords are allowed here, so show completion - || containingNodeKind === 159 /* NewExpression */ // new C(a, | - || containingNodeKind === 154 /* ArrayLiteralExpression */ // [a, | - || containingNodeKind === 170 /* BinaryExpression */ // let x = (a, | - || containingNodeKind === 143 /* FunctionType */; // var x: (s: string, list| + return containingNodeKind === 160 /* CallExpression */ // func( a, | + || containingNodeKind === 137 /* Constructor */ // constructor( a, | public, protected, private keywords are allowed here, so show completion + || containingNodeKind === 161 /* NewExpression */ // new C(a, | + || containingNodeKind === 156 /* ArrayLiteralExpression */ // [a, | + || containingNodeKind === 172 /* BinaryExpression */ // let x = (a, | + || containingNodeKind === 145 /* FunctionType */; // var x: (s: string, list| case 16 /* OpenParenToken */: - return containingNodeKind === 158 /* CallExpression */ // func( | - || containingNodeKind === 136 /* Constructor */ // constructor( | - || containingNodeKind === 159 /* NewExpression */ // new C(a| - || containingNodeKind === 162 /* ParenthesizedExpression */ // let x = (a| - || containingNodeKind === 150 /* ParenthesizedType */; // function F(pred: (a| this can become an arrow function, where 'a' is the argument + return containingNodeKind === 160 /* CallExpression */ // func( | + || containingNodeKind === 137 /* Constructor */ // constructor( | + || containingNodeKind === 161 /* NewExpression */ // new C(a| + || containingNodeKind === 164 /* ParenthesizedExpression */ // let x = (a| + || containingNodeKind === 152 /* ParenthesizedType */; // function F(pred: (a| this can become an arrow function, where 'a' is the argument case 18 /* OpenBracketToken */: - return containingNodeKind === 154 /* ArrayLiteralExpression */; // [ | - case 117 /* ModuleKeyword */: // module | - case 118 /* NamespaceKeyword */: + return containingNodeKind === 156 /* ArrayLiteralExpression */; // [ | + case 118 /* ModuleKeyword */: // module | + case 119 /* NamespaceKeyword */: return true; case 20 /* DotToken */: - return containingNodeKind === 206 /* ModuleDeclaration */; // module A.| + return containingNodeKind === 208 /* ModuleDeclaration */; // module A.| case 14 /* OpenBraceToken */: - return containingNodeKind === 202 /* ClassDeclaration */; // class A{ | + return containingNodeKind === 204 /* ClassDeclaration */; // class A{ | case 53 /* EqualsToken */: - return containingNodeKind === 199 /* VariableDeclaration */ // let x = a| - || containingNodeKind === 170 /* BinaryExpression */; // x = a| + return containingNodeKind === 201 /* VariableDeclaration */ // let x = a| + || containingNodeKind === 172 /* BinaryExpression */; // x = a| case 11 /* TemplateHead */: - return containingNodeKind === 172 /* TemplateExpression */; // `aa ${| + return containingNodeKind === 174 /* TemplateExpression */; // `aa ${| case 12 /* TemplateMiddle */: - return containingNodeKind === 178 /* TemplateSpan */; // `aa ${10} dd ${| + return containingNodeKind === 180 /* TemplateSpan */; // `aa ${10} dd ${| case 108 /* PublicKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: - return containingNodeKind === 133 /* PropertyDeclaration */; // class A{ public | + return containingNodeKind === 134 /* PropertyDeclaration */; // class A{ public | } // Previous token may have been a keyword that was converted to an identifier. switch (previousToken.getText()) { @@ -39303,12 +39737,12 @@ var ts; function getContainingObjectLiteralApplicableForCompletion(previousToken) { // The locations in an object literal expression that are applicable for completion are property name definition locations. if (previousToken) { - var parent_9 = previousToken.parent; + var parent_10 = previousToken.parent; switch (previousToken.kind) { case 14 /* OpenBraceToken */: // let x = { | case 23 /* CommaToken */: - if (parent_9 && parent_9.kind === 155 /* ObjectLiteralExpression */) { - return parent_9; + if (parent_10 && parent_10.kind === 157 /* ObjectLiteralExpression */) { + return parent_10; } break; } @@ -39317,16 +39751,16 @@ var ts; } function isFunction(kind) { switch (kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: return true; } return false; @@ -39336,63 +39770,63 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23 /* CommaToken */: - return containingNodeKind === 199 /* VariableDeclaration */ || - containingNodeKind === 200 /* VariableDeclarationList */ || - containingNodeKind === 181 /* VariableStatement */ || - containingNodeKind === 205 /* EnumDeclaration */ || + return containingNodeKind === 201 /* VariableDeclaration */ || + containingNodeKind === 202 /* VariableDeclarationList */ || + containingNodeKind === 183 /* VariableStatement */ || + containingNodeKind === 207 /* EnumDeclaration */ || isFunction(containingNodeKind) || - containingNodeKind === 202 /* ClassDeclaration */ || - containingNodeKind === 201 /* FunctionDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || - containingNodeKind === 152 /* ArrayBindingPattern */ || - containingNodeKind === 151 /* ObjectBindingPattern */; // function func({ x, y| + containingNodeKind === 204 /* ClassDeclaration */ || + containingNodeKind === 203 /* FunctionDeclaration */ || + containingNodeKind === 205 /* InterfaceDeclaration */ || + containingNodeKind === 154 /* ArrayBindingPattern */ || + containingNodeKind === 153 /* ObjectBindingPattern */; // function func({ x, y| case 20 /* DotToken */: - return containingNodeKind === 152 /* ArrayBindingPattern */; // var [.| + return containingNodeKind === 154 /* ArrayBindingPattern */; // var [.| case 51 /* ColonToken */: - return containingNodeKind === 153 /* BindingElement */; // var {x :html| + return containingNodeKind === 155 /* BindingElement */; // var {x :html| case 18 /* OpenBracketToken */: - return containingNodeKind === 152 /* ArrayBindingPattern */; // var [x| + return containingNodeKind === 154 /* ArrayBindingPattern */; // var [x| case 16 /* OpenParenToken */: - return containingNodeKind === 224 /* CatchClause */ || + return containingNodeKind === 226 /* CatchClause */ || isFunction(containingNodeKind); case 14 /* OpenBraceToken */: - return containingNodeKind === 205 /* EnumDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || - containingNodeKind === 146 /* TypeLiteral */ || - containingNodeKind === 151 /* ObjectBindingPattern */; // function func({ x| + return containingNodeKind === 207 /* EnumDeclaration */ || + containingNodeKind === 205 /* InterfaceDeclaration */ || + containingNodeKind === 148 /* TypeLiteral */ || + containingNodeKind === 153 /* ObjectBindingPattern */; // function func({ x| case 22 /* SemicolonToken */: - return containingNodeKind === 132 /* PropertySignature */ && + return containingNodeKind === 133 /* PropertySignature */ && previousToken.parent && previousToken.parent.parent && - (previousToken.parent.parent.kind === 203 /* InterfaceDeclaration */ || - previousToken.parent.parent.kind === 146 /* TypeLiteral */); // let x : { a; | + (previousToken.parent.parent.kind === 205 /* InterfaceDeclaration */ || + previousToken.parent.parent.kind === 148 /* TypeLiteral */); // let x : { a; | case 24 /* LessThanToken */: - return containingNodeKind === 202 /* ClassDeclaration */ || - containingNodeKind === 201 /* FunctionDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || + return containingNodeKind === 204 /* ClassDeclaration */ || + containingNodeKind === 203 /* FunctionDeclaration */ || + containingNodeKind === 205 /* InterfaceDeclaration */ || isFunction(containingNodeKind); case 109 /* StaticKeyword */: - return containingNodeKind === 133 /* PropertyDeclaration */; + return containingNodeKind === 134 /* PropertyDeclaration */; case 21 /* DotDotDotToken */: - return containingNodeKind === 130 /* Parameter */ || - containingNodeKind === 136 /* Constructor */ || + return containingNodeKind === 131 /* Parameter */ || + containingNodeKind === 137 /* Constructor */ || (previousToken.parent && previousToken.parent.parent && - previousToken.parent.parent.kind === 152 /* ArrayBindingPattern */); // var [...z| + previousToken.parent.parent.kind === 154 /* ArrayBindingPattern */); // var [...z| case 108 /* PublicKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: - return containingNodeKind === 130 /* Parameter */; + return containingNodeKind === 131 /* Parameter */; case 69 /* ClassKeyword */: case 77 /* EnumKeyword */: case 103 /* InterfaceKeyword */: case 83 /* FunctionKeyword */: case 98 /* VarKeyword */: case 116 /* GetKeyword */: - case 121 /* SetKeyword */: + case 122 /* SetKeyword */: case 85 /* ImportKeyword */: case 104 /* LetKeyword */: case 70 /* ConstKeyword */: case 110 /* YieldKeyword */: - case 124 /* TypeKeyword */: + case 125 /* TypeKeyword */: return true; } // Previous token may have been a keyword that was converted to an identifier. @@ -39424,7 +39858,7 @@ var ts; return exports; } if (importDeclaration.importClause.namedBindings && - importDeclaration.importClause.namedBindings.kind === 213 /* NamedImports */) { + importDeclaration.importClause.namedBindings.kind === 215 /* NamedImports */) { ts.forEach(importDeclaration.importClause.namedBindings.elements, function (el) { var name = el.propertyName || el.name; exisingImports[name.text] = true; @@ -39441,7 +39875,7 @@ var ts; } var existingMemberNames = {}; ts.forEach(existingMembers, function (m) { - if (m.kind !== 225 /* PropertyAssignment */ && m.kind !== 226 /* ShorthandPropertyAssignment */) { + if (m.kind !== 227 /* PropertyAssignment */ && m.kind !== 228 /* ShorthandPropertyAssignment */) { // Ignore omitted expressions for missing members in the object literal return; } @@ -39491,10 +39925,10 @@ var ts; for (var _i = 0, _a = program.getSourceFiles(); _i < _a.length; _i++) { var sourceFile = _a[_i]; var nameTable = getNameTable(sourceFile); - for (var name_30 in nameTable) { - if (!allNames[name_30]) { - allNames[name_30] = name_30; - var displayName = getCompletionEntryDisplayName(name_30, target, true); + for (var name_27 in nameTable) { + if (!allNames[name_27]) { + allNames[name_27] = name_27; + var displayName = getCompletionEntryDisplayName(name_27, target, true); if (displayName) { var entry = { name: displayName, @@ -39693,7 +40127,7 @@ var ts; var signature; type = typeChecker.getTypeOfSymbolAtLocation(symbol, location); if (type) { - if (location.parent && location.parent.kind === 156 /* PropertyAccessExpression */) { + if (location.parent && location.parent.kind === 158 /* PropertyAccessExpression */) { var right = location.parent.name; // Either the location is on the right of a property access, or on the left and the right is missing if (right === location || (right && right.getFullWidth() === 0)) { @@ -39702,7 +40136,7 @@ var ts; } // try get the call/construct signature from the type if it matches var callExpression; - if (location.kind === 158 /* CallExpression */ || location.kind === 159 /* NewExpression */) { + if (location.kind === 160 /* CallExpression */ || location.kind === 161 /* NewExpression */) { callExpression = location; } else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) { @@ -39715,7 +40149,7 @@ var ts; // Use the first candidate: signature = candidateSignatures[0]; } - var useConstructSignatures = callExpression.kind === 159 /* NewExpression */ || callExpression.expression.kind === 91 /* SuperKeyword */; + var useConstructSignatures = callExpression.kind === 161 /* NewExpression */ || callExpression.expression.kind === 91 /* SuperKeyword */; var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures(); if (!ts.contains(allSignatures, signature.target || signature)) { // Get the first signature if there @@ -39767,24 +40201,24 @@ var ts; } } else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304 /* Accessor */)) || - (location.kind === 114 /* ConstructorKeyword */ && location.parent.kind === 136 /* Constructor */)) { + (location.kind === 114 /* ConstructorKeyword */ && location.parent.kind === 137 /* Constructor */)) { // get the signature from the declaration and write it var functionDeclaration = location.parent; - var allSignatures = functionDeclaration.kind === 136 /* Constructor */ ? type.getConstructSignatures() : type.getCallSignatures(); + var allSignatures = functionDeclaration.kind === 137 /* Constructor */ ? type.getConstructSignatures() : type.getCallSignatures(); if (!typeChecker.isImplementationOfOverload(functionDeclaration)) { signature = typeChecker.getSignatureFromDeclaration(functionDeclaration); } else { signature = allSignatures[0]; } - if (functionDeclaration.kind === 136 /* Constructor */) { + if (functionDeclaration.kind === 137 /* Constructor */) { // show (constructor) Type(...) signature symbolKind = ScriptElementKind.constructorImplementationElement; addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); } else { // (function/method) symbol(..signature) - addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 139 /* CallSignature */ && + addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 140 /* CallSignature */ && !(type.symbol.flags & 2048 /* TypeLiteral */ || type.symbol.flags & 4096 /* ObjectLiteral */) ? type.symbol : symbol, symbolKind); } addSignatureDisplayParts(signature, allSignatures); @@ -39807,7 +40241,7 @@ var ts; } if (symbolFlags & 524288 /* TypeAlias */) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(124 /* TypeKeyword */)); + displayParts.push(ts.keywordPart(125 /* TypeKeyword */)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); displayParts.push(ts.spacePart()); @@ -39827,9 +40261,9 @@ var ts; } if (symbolFlags & 1536 /* Module */) { addNewLineIfDisplayPartsExist(); - var declaration = ts.getDeclarationOfKind(symbol, 206 /* ModuleDeclaration */); + var declaration = ts.getDeclarationOfKind(symbol, 208 /* ModuleDeclaration */); var isNamespace = declaration && declaration.name && declaration.name.kind === 65 /* Identifier */; - displayParts.push(ts.keywordPart(isNamespace ? 118 /* NamespaceKeyword */ : 117 /* ModuleKeyword */)); + displayParts.push(ts.keywordPart(isNamespace ? 119 /* NamespaceKeyword */ : 118 /* ModuleKeyword */)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); } @@ -39850,13 +40284,13 @@ var ts; } else { // Method/function type parameter - var signatureDeclaration = ts.getDeclarationOfKind(symbol, 129 /* TypeParameter */).parent; + var signatureDeclaration = ts.getDeclarationOfKind(symbol, 130 /* TypeParameter */).parent; var signature = typeChecker.getSignatureFromDeclaration(signatureDeclaration); - if (signatureDeclaration.kind === 140 /* ConstructSignature */) { + if (signatureDeclaration.kind === 141 /* ConstructSignature */) { displayParts.push(ts.keywordPart(88 /* NewKeyword */)); displayParts.push(ts.spacePart()); } - else if (signatureDeclaration.kind !== 139 /* CallSignature */ && signatureDeclaration.name) { + else if (signatureDeclaration.kind !== 140 /* CallSignature */ && signatureDeclaration.name) { addFullSymbolName(signatureDeclaration.symbol); } displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeChecker, signature, sourceFile, 32 /* WriteTypeArgumentsOfSignature */)); @@ -39865,7 +40299,7 @@ var ts; if (symbolFlags & 8 /* EnumMember */) { addPrefixForAnyFunctionOrVar(symbol, "enum member"); var declaration = symbol.declarations[0]; - if (declaration.kind === 227 /* EnumMember */) { + if (declaration.kind === 229 /* EnumMember */) { var constantValue = typeChecker.getConstantValue(declaration); if (constantValue !== undefined) { displayParts.push(ts.spacePart()); @@ -39881,13 +40315,13 @@ var ts; displayParts.push(ts.spacePart()); addFullSymbolName(symbol); ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 209 /* ImportEqualsDeclaration */) { + if (declaration.kind === 211 /* ImportEqualsDeclaration */) { var importEqualsDeclaration = declaration; if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) { displayParts.push(ts.spacePart()); displayParts.push(ts.operatorPart(53 /* EqualsToken */)); displayParts.push(ts.spacePart()); - displayParts.push(ts.keywordPart(119 /* RequireKeyword */)); + displayParts.push(ts.keywordPart(120 /* RequireKeyword */)); displayParts.push(ts.punctuationPart(16 /* OpenParenToken */)); displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), SymbolDisplayPartKind.stringLiteral)); displayParts.push(ts.punctuationPart(17 /* CloseParenToken */)); @@ -40014,8 +40448,8 @@ var ts; // Try getting just type at this position and show switch (node.kind) { case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: + case 158 /* PropertyAccessExpression */: + case 128 /* QualifiedName */: case 93 /* ThisKeyword */: case 91 /* SuperKeyword */: // For the identifiers/this/super etc get the type at position @@ -40073,7 +40507,7 @@ var ts; if (isNewExpressionTarget(location) || location.kind === 114 /* ConstructorKeyword */) { if (symbol.flags & 32 /* Class */) { var classDeclaration = symbol.getDeclarations()[0]; - ts.Debug.assert(classDeclaration && classDeclaration.kind === 202 /* ClassDeclaration */); + ts.Debug.assert(classDeclaration && classDeclaration.kind === 204 /* ClassDeclaration */); return tryAddSignature(classDeclaration.members, true, symbolKind, symbolName, containerName, result); } } @@ -40089,8 +40523,8 @@ var ts; var declarations = []; var definition; ts.forEach(signatureDeclarations, function (d) { - if ((selectConstructors && d.kind === 136 /* Constructor */) || - (!selectConstructors && (d.kind === 201 /* FunctionDeclaration */ || d.kind === 135 /* MethodDeclaration */ || d.kind === 134 /* MethodSignature */))) { + if ((selectConstructors && d.kind === 137 /* Constructor */) || + (!selectConstructors && (d.kind === 203 /* FunctionDeclaration */ || d.kind === 136 /* MethodDeclaration */ || d.kind === 135 /* MethodSignature */))) { declarations.push(d); if (d.body) definition = d; @@ -40159,7 +40593,7 @@ var ts; // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition // is performed at the location of property access, we would like to go to definition of the property in the short-hand // assignment. This case and others are handled by the following code. - if (node.parent.kind === 226 /* ShorthandPropertyAssignment */) { + if (node.parent.kind === 228 /* ShorthandPropertyAssignment */) { var shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration); if (!shorthandSymbol) { return []; @@ -40193,7 +40627,7 @@ var ts; var result = []; ts.forEach(type.types, function (t) { if (t.symbol) { - result.push.apply(result, getDefinitionFromSymbol(t.symbol, node)); + ts.addRange(result, getDefinitionFromSymbol(t.symbol, node)); } }); return result; @@ -40288,74 +40722,74 @@ var ts; switch (node.kind) { case 84 /* IfKeyword */: case 76 /* ElseKeyword */: - if (hasKind(node.parent, 184 /* IfStatement */)) { + if (hasKind(node.parent, 186 /* IfStatement */)) { return getIfElseOccurrences(node.parent); } break; case 90 /* ReturnKeyword */: - if (hasKind(node.parent, 192 /* ReturnStatement */)) { + if (hasKind(node.parent, 194 /* ReturnStatement */)) { return getReturnOccurrences(node.parent); } break; case 94 /* ThrowKeyword */: - if (hasKind(node.parent, 196 /* ThrowStatement */)) { + if (hasKind(node.parent, 198 /* ThrowStatement */)) { return getThrowOccurrences(node.parent); } break; case 68 /* CatchKeyword */: - if (hasKind(parent(parent(node)), 197 /* TryStatement */)) { + if (hasKind(parent(parent(node)), 199 /* TryStatement */)) { return getTryCatchFinallyOccurrences(node.parent.parent); } break; case 96 /* TryKeyword */: case 81 /* FinallyKeyword */: - if (hasKind(parent(node), 197 /* TryStatement */)) { + if (hasKind(parent(node), 199 /* TryStatement */)) { return getTryCatchFinallyOccurrences(node.parent); } break; case 92 /* SwitchKeyword */: - if (hasKind(node.parent, 194 /* SwitchStatement */)) { + if (hasKind(node.parent, 196 /* SwitchStatement */)) { return getSwitchCaseDefaultOccurrences(node.parent); } break; case 67 /* CaseKeyword */: case 73 /* DefaultKeyword */: - if (hasKind(parent(parent(parent(node))), 194 /* SwitchStatement */)) { + if (hasKind(parent(parent(parent(node))), 196 /* SwitchStatement */)) { return getSwitchCaseDefaultOccurrences(node.parent.parent.parent); } break; case 66 /* BreakKeyword */: case 71 /* ContinueKeyword */: - if (hasKind(node.parent, 191 /* BreakStatement */) || hasKind(node.parent, 190 /* ContinueStatement */)) { + if (hasKind(node.parent, 193 /* BreakStatement */) || hasKind(node.parent, 192 /* ContinueStatement */)) { return getBreakOrContinueStatementOccurences(node.parent); } break; case 82 /* ForKeyword */: - if (hasKind(node.parent, 187 /* ForStatement */) || - hasKind(node.parent, 188 /* ForInStatement */) || - hasKind(node.parent, 189 /* ForOfStatement */)) { + if (hasKind(node.parent, 189 /* ForStatement */) || + hasKind(node.parent, 190 /* ForInStatement */) || + hasKind(node.parent, 191 /* ForOfStatement */)) { return getLoopBreakContinueOccurrences(node.parent); } break; case 100 /* WhileKeyword */: case 75 /* DoKeyword */: - if (hasKind(node.parent, 186 /* WhileStatement */) || hasKind(node.parent, 185 /* DoStatement */)) { + if (hasKind(node.parent, 188 /* WhileStatement */) || hasKind(node.parent, 187 /* DoStatement */)) { return getLoopBreakContinueOccurrences(node.parent); } break; case 114 /* ConstructorKeyword */: - if (hasKind(node.parent, 136 /* Constructor */)) { + if (hasKind(node.parent, 137 /* Constructor */)) { return getConstructorOccurrences(node.parent); } break; case 116 /* GetKeyword */: - case 121 /* SetKeyword */: - if (hasKind(node.parent, 137 /* GetAccessor */) || hasKind(node.parent, 138 /* SetAccessor */)) { + case 122 /* SetKeyword */: + if (hasKind(node.parent, 138 /* GetAccessor */) || hasKind(node.parent, 139 /* SetAccessor */)) { return getGetAndSetOccurrences(node.parent); } default: if (ts.isModifier(node.kind) && node.parent && - (ts.isDeclaration(node.parent) || node.parent.kind === 181 /* VariableStatement */)) { + (ts.isDeclaration(node.parent) || node.parent.kind === 183 /* VariableStatement */)) { return getModifierOccurrences(node.kind, node.parent); } } @@ -40371,10 +40805,10 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 196 /* ThrowStatement */) { + if (node.kind === 198 /* ThrowStatement */) { statementAccumulator.push(node); } - else if (node.kind === 197 /* TryStatement */) { + else if (node.kind === 199 /* TryStatement */) { var tryStatement = node; if (tryStatement.catchClause) { aggregate(tryStatement.catchClause); @@ -40402,19 +40836,19 @@ var ts; function getThrowStatementOwner(throwStatement) { var child = throwStatement; while (child.parent) { - var parent_10 = child.parent; - if (ts.isFunctionBlock(parent_10) || parent_10.kind === 228 /* SourceFile */) { - return parent_10; + var parent_11 = child.parent; + if (ts.isFunctionBlock(parent_11) || parent_11.kind === 230 /* SourceFile */) { + return parent_11; } // A throw-statement is only owned by a try-statement if the try-statement has // a catch clause, and if the throw-statement occurs within the try block. - if (parent_10.kind === 197 /* TryStatement */) { - var tryStatement = parent_10; + if (parent_11.kind === 199 /* TryStatement */) { + var tryStatement = parent_11; if (tryStatement.tryBlock === child && tryStatement.catchClause) { return child; } } - child = parent_10; + child = parent_11; } return undefined; } @@ -40423,7 +40857,7 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 191 /* BreakStatement */ || node.kind === 190 /* ContinueStatement */) { + if (node.kind === 193 /* BreakStatement */ || node.kind === 192 /* ContinueStatement */) { statementAccumulator.push(node); } else if (!ts.isFunctionLike(node)) { @@ -40437,25 +40871,25 @@ var ts; return actualOwner && actualOwner === owner; } function getBreakOrContinueOwner(statement) { - for (var node_1 = statement.parent; node_1; node_1 = node_1.parent) { - switch (node_1.kind) { - case 194 /* SwitchStatement */: - if (statement.kind === 190 /* ContinueStatement */) { + for (var node_2 = statement.parent; node_2; node_2 = node_2.parent) { + switch (node_2.kind) { + case 196 /* SwitchStatement */: + if (statement.kind === 192 /* ContinueStatement */) { continue; } // Fall through. - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: - case 185 /* DoStatement */: - if (!statement.label || isLabeledBy(node_1, statement.label.text)) { - return node_1; + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 188 /* WhileStatement */: + case 187 /* DoStatement */: + if (!statement.label || isLabeledBy(node_2, statement.label.text)) { + return node_2; } break; default: // Don't cross function boundaries. - if (ts.isFunctionLike(node_1)) { + if (ts.isFunctionLike(node_2)) { return undefined; } break; @@ -40467,18 +40901,18 @@ var ts; var container = declaration.parent; // Make sure we only highlight the keyword when it makes sense to do so. if (ts.isAccessibilityModifier(modifier)) { - if (!(container.kind === 202 /* ClassDeclaration */ || - (declaration.kind === 130 /* Parameter */ && hasKind(container, 136 /* Constructor */)))) { + if (!(container.kind === 204 /* ClassDeclaration */ || + (declaration.kind === 131 /* Parameter */ && hasKind(container, 137 /* Constructor */)))) { return undefined; } } else if (modifier === 109 /* StaticKeyword */) { - if (container.kind !== 202 /* ClassDeclaration */) { + if (container.kind !== 204 /* ClassDeclaration */) { return undefined; } } else if (modifier === 78 /* ExportKeyword */ || modifier === 115 /* DeclareKeyword */) { - if (!(container.kind === 207 /* ModuleBlock */ || container.kind === 228 /* SourceFile */)) { + if (!(container.kind === 209 /* ModuleBlock */ || container.kind === 230 /* SourceFile */)) { return undefined; } } @@ -40490,20 +40924,20 @@ var ts; var modifierFlag = getFlagFromModifier(modifier); var nodes; switch (container.kind) { - case 207 /* ModuleBlock */: - case 228 /* SourceFile */: + case 209 /* ModuleBlock */: + case 230 /* SourceFile */: nodes = container.statements; break; - case 136 /* Constructor */: + case 137 /* Constructor */: nodes = container.parameters.concat(container.parent.members); break; - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: nodes = container.members; // If we're an accessibility modifier, we're in an instance member and should search // the constructor's parameter list for instance members as well. if (modifierFlag & 112 /* AccessibilityModifier */) { var constructor = ts.forEach(container.members, function (member) { - return member.kind === 136 /* Constructor */ && member; + return member.kind === 137 /* Constructor */ && member; }); if (constructor) { nodes = nodes.concat(constructor.parameters); @@ -40551,13 +40985,13 @@ var ts; } function getGetAndSetOccurrences(accessorDeclaration) { var keywords = []; - tryPushAccessorKeyword(accessorDeclaration.symbol, 137 /* GetAccessor */); - tryPushAccessorKeyword(accessorDeclaration.symbol, 138 /* SetAccessor */); + tryPushAccessorKeyword(accessorDeclaration.symbol, 138 /* GetAccessor */); + tryPushAccessorKeyword(accessorDeclaration.symbol, 139 /* SetAccessor */); return ts.map(keywords, getHighlightSpanForNode); function tryPushAccessorKeyword(accessorSymbol, accessorKind) { var accessor = ts.getDeclarationOfKind(accessorSymbol, accessorKind); if (accessor) { - ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116 /* GetKeyword */, 121 /* SetKeyword */); }); + ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116 /* GetKeyword */, 122 /* SetKeyword */); }); } } } @@ -40575,7 +41009,7 @@ var ts; var keywords = []; if (pushKeywordIf(keywords, loopNode.getFirstToken(), 82 /* ForKeyword */, 100 /* WhileKeyword */, 75 /* DoKeyword */)) { // If we succeeded and got a do-while loop, then start looking for a 'while' keyword. - if (loopNode.kind === 185 /* DoStatement */) { + if (loopNode.kind === 187 /* DoStatement */) { var loopTokens = loopNode.getChildren(); for (var i = loopTokens.length - 1; i >= 0; i--) { if (pushKeywordIf(keywords, loopTokens[i], 100 /* WhileKeyword */)) { @@ -40596,13 +41030,13 @@ var ts; var owner = getBreakOrContinueOwner(breakOrContinueStatement); if (owner) { switch (owner.kind) { - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: return getLoopBreakContinueOccurrences(owner); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: return getSwitchCaseDefaultOccurrences(owner); } } @@ -40656,7 +41090,7 @@ var ts; function getReturnOccurrences(returnStatement) { var func = ts.getContainingFunction(returnStatement); // If we didn't find a containing function with a block body, bail out. - if (!(func && hasKind(func.body, 180 /* Block */))) { + if (!(func && hasKind(func.body, 182 /* Block */))) { return undefined; } var keywords = []; @@ -40672,7 +41106,7 @@ var ts; function getIfElseOccurrences(ifStatement) { var keywords = []; // Traverse upwards through all parent if-statements linked by their else-branches. - while (hasKind(ifStatement.parent, 184 /* IfStatement */) && ifStatement.parent.elseStatement === ifStatement) { + while (hasKind(ifStatement.parent, 186 /* IfStatement */) && ifStatement.parent.elseStatement === ifStatement) { ifStatement = ifStatement.parent; } // Now traverse back down through the else branches, aggregating if/else keywords of if-statements. @@ -40685,7 +41119,7 @@ var ts; break; } } - if (!hasKind(ifStatement.elseStatement, 184 /* IfStatement */)) { + if (!hasKind(ifStatement.elseStatement, 186 /* IfStatement */)) { break; } ifStatement = ifStatement.elseStatement; @@ -40864,17 +41298,17 @@ var ts; } function isImportOrExportSpecifierName(location) { return location.parent && - (location.parent.kind === 214 /* ImportSpecifier */ || location.parent.kind === 218 /* ExportSpecifier */) && + (location.parent.kind === 216 /* ImportSpecifier */ || location.parent.kind === 220 /* ExportSpecifier */) && location.parent.propertyName === location; } function isImportOrExportSpecifierImportSymbol(symbol) { return (symbol.flags & 8388608 /* Alias */) && ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 214 /* ImportSpecifier */ || declaration.kind === 218 /* ExportSpecifier */; + return declaration.kind === 216 /* ImportSpecifier */ || declaration.kind === 220 /* ExportSpecifier */; }); } function getDeclaredName(symbol, location) { // Special case for function expressions, whose names are solely local to their bodies. - var functionExpression = ts.forEach(symbol.declarations, function (d) { return d.kind === 163 /* FunctionExpression */ ? d : undefined; }); + var functionExpression = ts.forEach(symbol.declarations, function (d) { return d.kind === 165 /* FunctionExpression */ ? d : undefined; }); // When a name gets interned into a SourceFile's 'identifiers' Map, // its name is escaped and stored in the same way its symbol name/identifier // name should be stored. Function expressions, however, are a special case, @@ -40901,7 +41335,7 @@ var ts; return location.getText(); } // Special case for function expressions, whose names are solely local to their bodies. - var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 163 /* FunctionExpression */ ? d : undefined; }); + var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 165 /* FunctionExpression */ ? d : undefined; }); // When a name gets interned into a SourceFile's 'identifiers' Map, // its name is escaped and stored in the same way its symbol name/identifier // name should be stored. Function expressions, however, are a special case, @@ -40925,7 +41359,7 @@ var ts; if (symbol.flags & (4 /* Property */ | 8192 /* Method */)) { var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32 /* Private */) ? d : undefined; }); if (privateDeclaration) { - return ts.getAncestor(privateDeclaration, 202 /* ClassDeclaration */); + return ts.getAncestor(privateDeclaration, 204 /* ClassDeclaration */); } } // If the symbol is an import we would like to find it if we are looking for what it imports. @@ -40951,7 +41385,7 @@ var ts; // Different declarations have different containers, bail out return undefined; } - if (container.kind === 228 /* SourceFile */ && !ts.isExternalModule(container)) { + if (container.kind === 230 /* SourceFile */ && !ts.isExternalModule(container)) { // This is a global variable and not an external module, any declaration defined // within this scope is visible outside the file return undefined; @@ -41139,13 +41573,13 @@ var ts; // Whether 'super' occurs in a static context within a class. var staticFlag = 128 /* Static */; switch (searchSpaceNode.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class break; @@ -41177,27 +41611,27 @@ var ts; // Whether 'this' occurs in a static context within a class. var staticFlag = 128 /* Static */; switch (searchSpaceNode.kind) { - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (ts.isObjectLiteralMethod(searchSpaceNode)) { break; } // fall through - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class break; - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (ts.isExternalModule(searchSpaceNode)) { return undefined; } // Fall through - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: break; // Computed properties in classes are not handled here because references to this are illegal, // so there is no point finding references to them. @@ -41206,7 +41640,7 @@ var ts; } var references = []; var possiblePositions; - if (searchSpaceNode.kind === 228 /* SourceFile */) { + if (searchSpaceNode.kind === 230 /* SourceFile */) { ts.forEach(sourceFiles, function (sourceFile) { possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd()); getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, references); @@ -41237,27 +41671,27 @@ var ts; } var container = ts.getThisContainer(node, false); switch (searchSpaceNode.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: if (searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: // Make sure the container belongs to the same class // and has the appropriate static modifier from the original container. if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128 /* Static */) === staticFlag) { result.push(getReferenceEntryFromNode(node)); } break; - case 228 /* SourceFile */: - if (container.kind === 228 /* SourceFile */ && !ts.isExternalModule(container)) { + case 230 /* SourceFile */: + if (container.kind === 230 /* SourceFile */ && !ts.isExternalModule(container)) { result.push(getReferenceEntryFromNode(node)); } break; @@ -41311,11 +41745,11 @@ var ts; function getPropertySymbolsFromBaseTypes(symbol, propertyName, result) { if (symbol && symbol.flags & (32 /* Class */ | 64 /* Interface */)) { ts.forEach(symbol.getDeclarations(), function (declaration) { - if (declaration.kind === 202 /* ClassDeclaration */) { + if (declaration.kind === 204 /* ClassDeclaration */) { getPropertySymbolFromTypeReference(ts.getClassExtendsHeritageClauseElement(declaration)); ts.forEach(ts.getClassImplementsHeritageClauseElements(declaration), getPropertySymbolFromTypeReference); } - else if (declaration.kind === 203 /* InterfaceDeclaration */) { + else if (declaration.kind === 205 /* InterfaceDeclaration */) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), getPropertySymbolFromTypeReference); } }); @@ -41376,19 +41810,19 @@ var ts; if (isNameOfPropertyAssignment(node)) { var objectLiteral = node.parent.parent; var contextualType = typeChecker.getContextualType(objectLiteral); - var name_31 = node.text; + var name_28 = node.text; if (contextualType) { if (contextualType.flags & 16384 /* Union */) { // This is a union type, first see if the property we are looking for is a union property (i.e. exists in all types) // if not, search the constituent types for the property - var unionProperty = contextualType.getProperty(name_31); + var unionProperty = contextualType.getProperty(name_28); if (unionProperty) { return [unionProperty]; } else { var result_4 = []; ts.forEach(contextualType.types, function (t) { - var symbol = t.getProperty(name_31); + var symbol = t.getProperty(name_28); if (symbol) { result_4.push(symbol); } @@ -41397,7 +41831,7 @@ var ts; } } else { - var symbol_1 = contextualType.getProperty(name_31); + var symbol_1 = contextualType.getProperty(name_28); if (symbol_1) { return [symbol_1]; } @@ -41455,10 +41889,10 @@ var ts; } var parent = node.parent; if (parent) { - if (parent.kind === 169 /* PostfixUnaryExpression */ || parent.kind === 168 /* PrefixUnaryExpression */) { + if (parent.kind === 171 /* PostfixUnaryExpression */ || parent.kind === 170 /* PrefixUnaryExpression */) { return true; } - else if (parent.kind === 170 /* BinaryExpression */ && parent.left === node) { + else if (parent.kind === 172 /* BinaryExpression */ && parent.left === node) { var operator = parent.operatorToken.kind; return 53 /* FirstAssignment */ <= operator && operator <= 64 /* LastAssignment */; } @@ -41492,33 +41926,33 @@ var ts; } function getMeaningFromDeclaration(node) { switch (node.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 224 /* CatchClause */: + case 131 /* Parameter */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 227 /* PropertyAssignment */: + case 228 /* ShorthandPropertyAssignment */: + case 229 /* EnumMember */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 226 /* CatchClause */: return 1 /* Value */; - case 129 /* TypeParameter */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 146 /* TypeLiteral */: + case 130 /* TypeParameter */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 148 /* TypeLiteral */: return 2 /* Type */; - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: return 1 /* Value */ | 2 /* Type */; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: if (node.name.kind === 8 /* StringLiteral */) { return 4 /* Namespace */ | 1 /* Value */; } @@ -41528,15 +41962,15 @@ var ts; else { return 4 /* Namespace */; } - case 213 /* NamedImports */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 210 /* ImportDeclaration */: - case 215 /* ExportAssignment */: - case 216 /* ExportDeclaration */: + case 215 /* NamedImports */: + case 216 /* ImportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 212 /* ImportDeclaration */: + case 217 /* ExportAssignment */: + case 218 /* ExportDeclaration */: return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; // An external module can be a Value - case 228 /* SourceFile */: + case 230 /* SourceFile */: return 4 /* Namespace */ | 1 /* Value */; } return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; @@ -41546,7 +41980,8 @@ var ts; if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) { node = node.parent; } - return node.parent.kind === 142 /* TypeReference */ || node.parent.kind === 177 /* ExpressionWithTypeArguments */; + return node.parent.kind === 144 /* TypeReference */ || + (node.parent.kind === 179 /* ExpressionWithTypeArguments */ && !ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent)); } function isNamespaceReference(node) { return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node); @@ -41554,32 +41989,32 @@ var ts; function isPropertyAccessNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 156 /* PropertyAccessExpression */) { - while (root.parent && root.parent.kind === 156 /* PropertyAccessExpression */) { + if (root.parent.kind === 158 /* PropertyAccessExpression */) { + while (root.parent && root.parent.kind === 158 /* PropertyAccessExpression */) { root = root.parent; } isLastClause = root.name === node; } - if (!isLastClause && root.parent.kind === 177 /* ExpressionWithTypeArguments */ && root.parent.parent.kind === 223 /* HeritageClause */) { + if (!isLastClause && root.parent.kind === 179 /* ExpressionWithTypeArguments */ && root.parent.parent.kind === 225 /* HeritageClause */) { var decl = root.parent.parent.parent; - return (decl.kind === 202 /* ClassDeclaration */ && root.parent.parent.token === 102 /* ImplementsKeyword */) || - (decl.kind === 203 /* InterfaceDeclaration */ && root.parent.parent.token === 79 /* ExtendsKeyword */); + return (decl.kind === 204 /* ClassDeclaration */ && root.parent.parent.token === 102 /* ImplementsKeyword */) || + (decl.kind === 205 /* InterfaceDeclaration */ && root.parent.parent.token === 79 /* ExtendsKeyword */); } return false; } function isQualifiedNameNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 127 /* QualifiedName */) { - while (root.parent && root.parent.kind === 127 /* QualifiedName */) { + if (root.parent.kind === 128 /* QualifiedName */) { + while (root.parent && root.parent.kind === 128 /* QualifiedName */) { root = root.parent; } isLastClause = root.right === node; } - return root.parent.kind === 142 /* TypeReference */ && !isLastClause; + return root.parent.kind === 144 /* TypeReference */ && !isLastClause; } function isInRightSideOfImport(node) { - while (node.parent.kind === 127 /* QualifiedName */) { + while (node.parent.kind === 128 /* QualifiedName */) { node = node.parent; } return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node; @@ -41589,15 +42024,15 @@ var ts; // import a = |b|; // Namespace // import a = |b.c|; // Value, type, namespace // import a = |b.c|.d; // Namespace - if (node.parent.kind === 127 /* QualifiedName */ && + if (node.parent.kind === 128 /* QualifiedName */ && node.parent.right === node && - node.parent.parent.kind === 209 /* ImportEqualsDeclaration */) { + node.parent.parent.kind === 211 /* ImportEqualsDeclaration */) { return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; } return 4 /* Namespace */; } function getMeaningFromLocation(node) { - if (node.parent.kind === 215 /* ExportAssignment */) { + if (node.parent.kind === 217 /* ExportAssignment */) { return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; } else if (isInRightSideOfImport(node)) { @@ -41637,8 +42072,8 @@ var ts; return; } switch (node.kind) { - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: + case 158 /* PropertyAccessExpression */: + case 128 /* QualifiedName */: case 8 /* StringLiteral */: case 80 /* FalseKeyword */: case 95 /* TrueKeyword */: @@ -41661,7 +42096,7 @@ var ts; // If this is name of a module declarations, check if this is right side of dotted module name // If parent of the module declaration which is parent of this node is module declaration and its body is the module declaration that this node is name of // Then this name is name from dotted module - if (nodeForStartPos.parent.parent.kind === 206 /* ModuleDeclaration */ && + if (nodeForStartPos.parent.parent.kind === 208 /* ModuleDeclaration */ && nodeForStartPos.parent.parent.body === nodeForStartPos.parent) { // Use parent module declarations name for start pos nodeForStartPos = nodeForStartPos.parent.parent.name; @@ -41695,6 +42130,7 @@ var ts; var sourceFile = getValidSourceFile(fileName); var typeChecker = program.getTypeChecker(); var result = []; + var classifiableNames = program.getClassifiableNames(); processNode(sourceFile); return { spans: result, endOfLineState: 0 /* None */ }; function pushClassification(start, length, type) { @@ -41704,6 +42140,9 @@ var ts; } function classifySymbol(symbol, meaningAtPosition) { var flags = symbol.getFlags(); + if ((flags & 788448 /* Classifiable */) === 0 /* None */) { + return; + } if (flags & 32 /* Class */) { return 11 /* className */; } @@ -41736,19 +42175,26 @@ var ts; */ function hasValueSideModule(symbol) { return ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 206 /* ModuleDeclaration */ && ts.getModuleInstanceState(declaration) == 1 /* Instantiated */; + return declaration.kind === 208 /* ModuleDeclaration */ && + ts.getModuleInstanceState(declaration) === 1 /* Instantiated */; }); } } function processNode(node) { // Only walk into nodes that intersect the requested span. - if (node && ts.textSpanIntersectsWith(span, node.getStart(), node.getWidth())) { - if (node.kind === 65 /* Identifier */ && node.getWidth() > 0) { - var symbol = typeChecker.getSymbolAtLocation(node); - if (symbol) { - var type = classifySymbol(symbol, getMeaningFromLocation(node)); - if (type) { - pushClassification(node.getStart(), node.getWidth(), type); + if (node && ts.textSpanIntersectsWith(span, node.getFullStart(), node.getFullWidth())) { + if (node.kind === 65 /* Identifier */ && !ts.nodeIsMissing(node)) { + var identifier = node; + // Only bother calling into the typechecker if this is an identifier that + // could possibly resolve to a type name. This makes classification run + // in a third of the time it would normally take. + if (classifiableNames[identifier.text]) { + var symbol = typeChecker.getSymbolAtLocation(node); + if (symbol) { + var type = classifySymbol(symbol, getMeaningFromLocation(node)); + if (type) { + pushClassification(node.getStart(), node.getWidth(), type); + } } } } @@ -41795,6 +42241,8 @@ var ts; function getEncodedSyntacticClassifications(fileName, span) { // doesn't use compiler - no need to synchronize with host var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var spanStart = span.start; + var spanLength = span.length; // Make a scanner we can get trivia from. var triviaScanner = ts.createScanner(2 /* Latest */, false, sourceFile.text); var mergeConflictScanner = ts.createScanner(2 /* Latest */, false, sourceFile.text); @@ -41806,42 +42254,47 @@ var ts; result.push(length); result.push(type); } - function classifyLeadingTrivia(token) { - var tokenStart = ts.skipTrivia(sourceFile.text, token.pos, false); - if (tokenStart === token.pos) { - return; - } - // token has trivia. Classify them appropriately. + function classifyLeadingTriviaAndGetTokenStart(token) { triviaScanner.setTextPos(token.pos); while (true) { var start = triviaScanner.getTextPos(); + // only bother scanning if we have something that could be trivia. + if (!ts.couldStartTrivia(sourceFile.text, start)) { + return start; + } var kind = triviaScanner.scan(); var end = triviaScanner.getTextPos(); var width = end - start; // The moment we get something that isn't trivia, then stop processing. if (!ts.isTrivia(kind)) { - return; + return start; + } + // Don't bother with newlines/whitespace. + if (kind === 4 /* NewLineTrivia */ || kind === 5 /* WhitespaceTrivia */) { + continue; } // Only bother with the trivia if it at least intersects the span of interest. - if (ts.textSpanIntersectsWith(span, start, width)) { - if (ts.isComment(kind)) { - classifyComment(token, kind, start, width); + if (ts.isComment(kind)) { + classifyComment(token, kind, start, width); + // Classifying a comment might cause us to reuse the trivia scanner + // (because of jsdoc comments). So after we classify the comment make + // sure we set the scanner position back to where it needs to be. + triviaScanner.setTextPos(end); + continue; + } + if (kind === 6 /* ConflictMarkerTrivia */) { + var text = sourceFile.text; + var ch = text.charCodeAt(start); + // for the <<<<<<< and >>>>>>> markers, we just add them in as comments + // in the classification stream. + if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) { + pushClassification(start, width, 1 /* comment */); continue; } - if (kind === 6 /* ConflictMarkerTrivia */) { - var text = sourceFile.text; - var ch = text.charCodeAt(start); - // for the <<<<<<< and >>>>>>> markers, we just add them in as comments - // in the classification stream. - if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) { - pushClassification(start, width, 1 /* comment */); - continue; - } - // for the ======== add a comment for the first line, and then lex all - // subsequent lines up until the end of the conflict marker. - ts.Debug.assert(ch === 61 /* equals */); - classifyDisabledMergeCode(text, start, end); - } + // for the ======== add a comment for the first line, and then lex all + // subsequent lines up until the end of the conflict marker. + ts.Debug.assert(ch === 61 /* equals */); + classifyDisabledMergeCode(text, start, end); } } } @@ -41875,16 +42328,16 @@ var ts; pushClassification(tag.tagName.pos, tag.tagName.end - tag.tagName.pos, 18 /* docCommentTagName */); pos = tag.tagName.end; switch (tag.kind) { - case 247 /* JSDocParameterTag */: + case 249 /* JSDocParameterTag */: processJSDocParameterTag(tag); break; - case 250 /* JSDocTemplateTag */: + case 252 /* JSDocTemplateTag */: processJSDocTemplateTag(tag); break; - case 249 /* JSDocTypeTag */: + case 251 /* JSDocTypeTag */: processElement(tag.typeExpression); break; - case 248 /* JSDocReturnTag */: + case 250 /* JSDocReturnTag */: processElement(tag.typeExpression); break; } @@ -41942,11 +42395,13 @@ var ts; } } function classifyToken(token) { - classifyLeadingTrivia(token); - if (token.getWidth() > 0) { + var tokenStart = classifyLeadingTriviaAndGetTokenStart(token); + var tokenWidth = token.end - tokenStart; + ts.Debug.assert(tokenWidth >= 0); + if (tokenWidth > 0) { var type = classifyTokenType(token.kind, token); if (type) { - pushClassification(token.getStart(), token.getWidth(), type); + pushClassification(tokenStart, tokenWidth, type); } } } @@ -41970,16 +42425,16 @@ var ts; if (token) { if (tokenKind === 53 /* EqualsToken */) { // the '=' in a variable declaration is special cased here. - if (token.parent.kind === 199 /* VariableDeclaration */ || - token.parent.kind === 133 /* PropertyDeclaration */ || - token.parent.kind === 130 /* Parameter */) { + if (token.parent.kind === 201 /* VariableDeclaration */ || + token.parent.kind === 134 /* PropertyDeclaration */ || + token.parent.kind === 131 /* Parameter */) { return 5 /* operator */; } } - if (token.parent.kind === 170 /* BinaryExpression */ || - token.parent.kind === 168 /* PrefixUnaryExpression */ || - token.parent.kind === 169 /* PostfixUnaryExpression */ || - token.parent.kind === 171 /* ConditionalExpression */) { + if (token.parent.kind === 172 /* BinaryExpression */ || + token.parent.kind === 170 /* PrefixUnaryExpression */ || + token.parent.kind === 171 /* PostfixUnaryExpression */ || + token.parent.kind === 173 /* ConditionalExpression */) { return 5 /* operator */; } } @@ -42002,32 +42457,32 @@ var ts; else if (tokenKind === 65 /* Identifier */) { if (token) { switch (token.parent.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: if (token.parent.name === token) { return 11 /* className */; } return; - case 129 /* TypeParameter */: + case 130 /* TypeParameter */: if (token.parent.name === token) { return 15 /* typeParameterName */; } return; - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: if (token.parent.name === token) { return 13 /* interfaceName */; } return; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: if (token.parent.name === token) { return 12 /* enumName */; } return; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: if (token.parent.name === token) { return 14 /* moduleName */; } return; - case 130 /* Parameter */: + case 131 /* Parameter */: if (token.parent.name === token) { return 17 /* parameterName */; } @@ -42042,10 +42497,10 @@ var ts; return; } // Ignore nodes that don't intersect the original span to classify. - if (ts.textSpanIntersectsWith(span, element.getFullStart(), element.getFullWidth())) { + if (ts.decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) { var children = element.getChildren(sourceFile); - for (var _i = 0; _i < children.length; _i++) { - var child = children[_i]; + for (var i = 0, n = children.length; i < n; i++) { + var child = children[i]; if (ts.isToken(child)) { classifyToken(child); } @@ -42372,7 +42827,7 @@ var ts; // then we want 'something' to be in the name table. Similarly, if we have // "a['propname']" then we want to store "propname" in the name table. if (ts.isDeclarationName(node) || - node.parent.kind === 220 /* ExternalModuleReference */ || + node.parent.kind === 222 /* ExternalModuleReference */ || isArgumentOfElementAccessExpression(node)) { nameTable[node.text] = node.text; } @@ -42385,7 +42840,7 @@ var ts; function isArgumentOfElementAccessExpression(node) { return node && node.parent && - node.parent.kind === 157 /* ElementAccessExpression */ && + node.parent.kind === 159 /* ElementAccessExpression */ && node.parent.argumentExpression === node; } /// Classifier @@ -42433,7 +42888,7 @@ var ts; function canFollow(keyword1, keyword2) { if (ts.isAccessibilityModifier(keyword1)) { if (keyword2 === 116 /* GetKeyword */ || - keyword2 === 121 /* SetKeyword */ || + keyword2 === 122 /* SetKeyword */ || keyword2 === 114 /* ConstructorKeyword */ || keyword2 === 109 /* StaticKeyword */) { // Allow things like "public get", "public constructor" and "public static". @@ -42592,10 +43047,10 @@ var ts; angleBracketStack--; } else if (token === 112 /* AnyKeyword */ || - token === 122 /* StringKeyword */ || - token === 120 /* NumberKeyword */ || + token === 123 /* StringKeyword */ || + token === 121 /* NumberKeyword */ || token === 113 /* BooleanKeyword */ || - token === 123 /* SymbolKeyword */) { + token === 124 /* SymbolKeyword */) { if (angleBracketStack > 0 && !syntacticClassifierAbsent) { // If it looks like we're could be in something generic, don't classify this // as a keyword. We may just get overwritten by the syntactic classifier, @@ -42766,7 +43221,7 @@ var ts; } } function isKeyword(token) { - return token >= 66 /* FirstKeyword */ && token <= 126 /* LastKeyword */; + return token >= 66 /* FirstKeyword */ && token <= 127 /* LastKeyword */; } function classFromKind(token) { if (isKeyword(token)) { @@ -42824,7 +43279,7 @@ var ts; getNodeConstructor: function (kind) { function Node() { } - var proto = kind === 228 /* SourceFile */ ? new SourceFileObject() : new NodeObject(); + var proto = kind === 230 /* SourceFile */ ? new SourceFileObject() : new NodeObject(); proto.kind = kind; proto.pos = 0; proto.end = 0; @@ -42894,125 +43349,125 @@ var ts; function spanInNode(node) { if (node) { if (ts.isExpression(node)) { - if (node.parent.kind === 185 /* DoStatement */) { + if (node.parent.kind === 187 /* DoStatement */) { // Set span as if on while keyword return spanInPreviousNode(node); } - if (node.parent.kind === 187 /* ForStatement */) { + if (node.parent.kind === 189 /* ForStatement */) { // For now lets set the span on this expression, fix it later return textSpan(node); } - if (node.parent.kind === 170 /* BinaryExpression */ && node.parent.operatorToken.kind === 23 /* CommaToken */) { + if (node.parent.kind === 172 /* BinaryExpression */ && node.parent.operatorToken.kind === 23 /* CommaToken */) { // if this is comma expression, the breakpoint is possible in this expression return textSpan(node); } - if (node.parent.kind == 164 /* ArrowFunction */ && node.parent.body == node) { + if (node.parent.kind === 166 /* ArrowFunction */ && node.parent.body === node) { // If this is body of arrow function, it is allowed to have the breakpoint return textSpan(node); } } switch (node.kind) { - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: // Span on first variable declaration return spanInVariableDeclaration(node.declarationList.declarations[0]); - case 199 /* VariableDeclaration */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 201 /* VariableDeclaration */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return spanInVariableDeclaration(node); - case 130 /* Parameter */: + case 131 /* Parameter */: return spanInParameterDeclaration(node); - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 137 /* Constructor */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: return spanInFunctionDeclaration(node); - case 180 /* Block */: + case 182 /* Block */: if (ts.isFunctionBlock(node)) { return spanInFunctionBlock(node); } // Fall through - case 207 /* ModuleBlock */: + case 209 /* ModuleBlock */: return spanInBlock(node); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return spanInBlock(node.block); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: // span on the expression return textSpan(node.expression); - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: // span on return keyword and expression if present return textSpan(node.getChildAt(0), node.expression); - case 186 /* WhileStatement */: + case 188 /* WhileStatement */: // Span on while(...) return textSpan(node, ts.findNextToken(node.expression, node)); - case 185 /* DoStatement */: + case 187 /* DoStatement */: // span in statement of the do statement return spanInNode(node.statement); - case 198 /* DebuggerStatement */: + case 200 /* DebuggerStatement */: // span on debugger keyword return textSpan(node.getChildAt(0)); - case 184 /* IfStatement */: + case 186 /* IfStatement */: // set on if(..) span return textSpan(node, ts.findNextToken(node.expression, node)); - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: // span in statement return spanInNode(node.statement); - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: + case 193 /* BreakStatement */: + case 192 /* ContinueStatement */: // On break or continue keyword and label if present return textSpan(node.getChildAt(0), node.label); - case 187 /* ForStatement */: + case 189 /* ForStatement */: return spanInForStatement(node); - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: // span on for (a in ...) return textSpan(node, ts.findNextToken(node.expression, node)); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: // span on switch(...) return textSpan(node, ts.findNextToken(node.expression, node)); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: // span in first statement of the clause return spanInNode(node.statements[0]); - case 197 /* TryStatement */: + case 199 /* TryStatement */: // span in try block return spanInBlock(node.tryBlock); - case 196 /* ThrowStatement */: + case 198 /* ThrowStatement */: // span in throw ... return textSpan(node, node.expression); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: // span on export = id return textSpan(node, node.expression); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: // import statement without including semicolon return textSpan(node, node.moduleReference); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: // import statement without including semicolon return textSpan(node, node.moduleSpecifier); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: // import statement without including semicolon return textSpan(node, node.moduleSpecifier); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: // span on complete module if it is instantiated if (ts.getModuleInstanceState(node) !== 1 /* Instantiated */) { return undefined; } - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 229 /* EnumMember */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: // span on complete node return textSpan(node); - case 193 /* WithStatement */: + case 195 /* WithStatement */: // span in statement return spanInNode(node.statement); // No breakpoint in interface, type alias - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: return undefined; // Tokens: case 22 /* SemicolonToken */: @@ -43042,11 +43497,11 @@ var ts; return spanInNextNode(node); default: // If this is name of property assignment, set breakpoint in the initializer - if (node.parent.kind === 225 /* PropertyAssignment */ && node.parent.name === node) { + if (node.parent.kind === 227 /* PropertyAssignment */ && node.parent.name === node) { return spanInNode(node.parent.initializer); } // Breakpoint in type assertion goes to its operand - if (node.parent.kind === 161 /* TypeAssertionExpression */ && node.parent.type === node) { + if (node.parent.kind === 163 /* TypeAssertionExpression */ && node.parent.type === node) { return spanInNode(node.parent.expression); } // return type of function go to previous token @@ -43059,12 +43514,12 @@ var ts; } function spanInVariableDeclaration(variableDeclaration) { // If declaration of for in statement, just set the span in parent - if (variableDeclaration.parent.parent.kind === 188 /* ForInStatement */ || - variableDeclaration.parent.parent.kind === 189 /* ForOfStatement */) { + if (variableDeclaration.parent.parent.kind === 190 /* ForInStatement */ || + variableDeclaration.parent.parent.kind === 191 /* ForOfStatement */) { return spanInNode(variableDeclaration.parent.parent); } - var isParentVariableStatement = variableDeclaration.parent.parent.kind === 181 /* VariableStatement */; - var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 187 /* ForStatement */ && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); + var isParentVariableStatement = variableDeclaration.parent.parent.kind === 183 /* VariableStatement */; + var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 189 /* ForStatement */ && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); var declarations = isParentVariableStatement ? variableDeclaration.parent.parent.declarationList.declarations : isDeclarationOfForStatement @@ -43118,7 +43573,7 @@ var ts; } function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) { return !!(functionDeclaration.flags & 1 /* Export */) || - (functionDeclaration.parent.kind === 202 /* ClassDeclaration */ && functionDeclaration.kind !== 136 /* Constructor */); + (functionDeclaration.parent.kind === 204 /* ClassDeclaration */ && functionDeclaration.kind !== 137 /* Constructor */); } function spanInFunctionDeclaration(functionDeclaration) { // No breakpoints in the function signature @@ -43141,18 +43596,18 @@ var ts; } function spanInBlock(block) { switch (block.parent.kind) { - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: if (ts.getModuleInstanceState(block.parent) !== 1 /* Instantiated */) { return undefined; } // Set on parent if on same line otherwise on first statement - case 186 /* WhileStatement */: - case 184 /* IfStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 188 /* WhileStatement */: + case 186 /* IfStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); // Set span on previous token if it starts on same line otherwise on the first statement of the block - case 187 /* ForStatement */: + case 189 /* ForStatement */: return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]); } // Default action is to set on first statement @@ -43160,7 +43615,7 @@ var ts; } function spanInForStatement(forStatement) { if (forStatement.initializer) { - if (forStatement.initializer.kind === 200 /* VariableDeclarationList */) { + if (forStatement.initializer.kind === 202 /* VariableDeclarationList */) { var variableDeclarationList = forStatement.initializer; if (variableDeclarationList.declarations.length > 0) { return spanInNode(variableDeclarationList.declarations[0]); @@ -43180,13 +43635,13 @@ var ts; // Tokens: function spanInOpenBraceToken(node) { switch (node.parent.kind) { - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: var enumDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile)); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: var classDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile)); - case 208 /* CaseBlock */: + case 210 /* CaseBlock */: return spanInNodeIfStartsOnSameLine(node.parent.parent, node.parent.clauses[0]); } // Default to parent node @@ -43194,25 +43649,25 @@ var ts; } function spanInCloseBraceToken(node) { switch (node.parent.kind) { - case 207 /* ModuleBlock */: + case 209 /* ModuleBlock */: // If this is not instantiated module block no bp span if (ts.getModuleInstanceState(node.parent.parent) !== 1 /* Instantiated */) { return undefined; } - case 205 /* EnumDeclaration */: - case 202 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 204 /* ClassDeclaration */: // Span on close brace token return textSpan(node); - case 180 /* Block */: + case 182 /* Block */: if (ts.isFunctionBlock(node.parent)) { // Span on close brace token return textSpan(node); } // fall through. - case 224 /* CatchClause */: + case 226 /* CatchClause */: return spanInNode(ts.lastOrUndefined(node.parent.statements)); ; - case 208 /* CaseBlock */: + case 210 /* CaseBlock */: // breakpoint in last statement of the last clause var caseBlock = node.parent; var lastClause = ts.lastOrUndefined(caseBlock.clauses); @@ -43226,7 +43681,7 @@ var ts; } } function spanInOpenParenToken(node) { - if (node.parent.kind === 185 /* DoStatement */) { + if (node.parent.kind === 187 /* DoStatement */) { // Go to while keyword and do action instead return spanInPreviousNode(node); } @@ -43236,17 +43691,17 @@ var ts; function spanInCloseParenToken(node) { // Is this close paren token of parameter list, set span in previous token switch (node.parent.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 186 /* WhileStatement */: - case 185 /* DoStatement */: - case 187 /* ForStatement */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 137 /* Constructor */: + case 188 /* WhileStatement */: + case 187 /* DoStatement */: + case 189 /* ForStatement */: return spanInPreviousNode(node); // Default to parent node default: @@ -43257,19 +43712,19 @@ var ts; } function spanInColonToken(node) { // Is this : specifying return annotation of the function declaration - if (ts.isFunctionLike(node.parent) || node.parent.kind === 225 /* PropertyAssignment */) { + if (ts.isFunctionLike(node.parent) || node.parent.kind === 227 /* PropertyAssignment */) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInGreaterThanOrLessThanToken(node) { - if (node.parent.kind === 161 /* TypeAssertionExpression */) { + if (node.parent.kind === 163 /* TypeAssertionExpression */) { return spanInNode(node.parent.expression); } return spanInNode(node.parent); } function spanInWhileKeyword(node) { - if (node.parent.kind === 185 /* DoStatement */) { + if (node.parent.kind === 187 /* DoStatement */) { // Set span on while expression return textSpan(node, ts.findNextToken(node.parent.expression, node.parent)); } @@ -43320,6 +43775,7 @@ var ts; ScriptSnapshotShimAdapter.prototype.getChangeRange = function (oldSnapshot) { var oldSnapshotShim = oldSnapshot; var encoded = this.scriptSnapshotShim.getChangeRange(oldSnapshotShim.scriptSnapshotShim); + // TODO: should this be '==='? if (encoded == null) { return null; } @@ -43331,12 +43787,18 @@ var ts; var LanguageServiceShimHostAdapter = (function () { function LanguageServiceShimHostAdapter(shimHost) { this.shimHost = shimHost; + this.loggingEnabled = false; + this.tracingEnabled = false; } LanguageServiceShimHostAdapter.prototype.log = function (s) { - this.shimHost.log(s); + if (this.loggingEnabled) { + this.shimHost.log(s); + } }; LanguageServiceShimHostAdapter.prototype.trace = function (s) { - this.shimHost.trace(s); + if (this.tracingEnabled) { + this.shimHost.trace(s); + } }; LanguageServiceShimHostAdapter.prototype.error = function (s) { this.shimHost.error(s); @@ -43348,8 +43810,12 @@ var ts; } return this.shimHost.getProjectVersion(); }; + LanguageServiceShimHostAdapter.prototype.useCaseSensitiveFileNames = function () { + return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false; + }; LanguageServiceShimHostAdapter.prototype.getCompilationSettings = function () { var settingsJson = this.shimHost.getCompilationSettings(); + // TODO: should this be '==='? if (settingsJson == null || settingsJson == "") { throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings"); return null; @@ -43415,13 +43881,13 @@ var ts; return CoreServicesShimHostAdapter; })(); ts.CoreServicesShimHostAdapter = CoreServicesShimHostAdapter; - function simpleForwardCall(logger, actionDescription, action, noPerfLogging) { - if (!noPerfLogging) { + function simpleForwardCall(logger, actionDescription, action, logPerformance) { + if (logPerformance) { logger.log(actionDescription); var start = Date.now(); } var result = action(); - if (!noPerfLogging) { + if (logPerformance) { var end = Date.now(); logger.log(actionDescription + " completed in " + (end - start) + " msec"); if (typeof (result) === "string") { @@ -43434,9 +43900,9 @@ var ts; } return result; } - function forwardJSONCall(logger, actionDescription, action, noPerfLogging) { + function forwardJSONCall(logger, actionDescription, action, logPerformance) { try { - var result = simpleForwardCall(logger, actionDescription, action, noPerfLogging); + var result = simpleForwardCall(logger, actionDescription, action, logPerformance); return JSON.stringify({ result: result }); } catch (err) { @@ -43478,10 +43944,11 @@ var ts; _super.call(this, factory); this.host = host; this.languageService = languageService; + this.logPerformance = false; this.logger = this.host; } LanguageServiceShimObject.prototype.forwardJSONCall = function (actionDescription, action) { - return forwardJSONCall(this.logger, actionDescription, action, false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); }; /// DISPOSE /** @@ -43788,12 +44255,12 @@ var ts; function ClassifierShimObject(factory, logger) { _super.call(this, factory); this.logger = logger; + this.logPerformance = false; this.classifier = ts.createClassifier(); } ClassifierShimObject.prototype.getEncodedLexicalClassifications = function (text, lexState, syntacticClassifierAbsent) { var _this = this; - return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, - /*noPerfLogging:*/ true); + return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, this.logPerformance); }; /// COLORIZATION ClassifierShimObject.prototype.getClassificationsForLine = function (text, lexState, classifyKeywordsInGenerics) { @@ -43815,9 +44282,10 @@ var ts; _super.call(this, factory); this.logger = logger; this.host = host; + this.logPerformance = false; } CoreServicesShimObject.prototype.forwardJSONCall = function (actionDescription, action) { - return forwardJSONCall(this.logger, actionDescription, action, false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); }; CoreServicesShimObject.prototype.getPreProcessedFileInfo = function (fileName, sourceTextSnapshot) { return this.forwardJSONCall("getPreProcessedFileInfo('" + fileName + "')", function () { @@ -43874,7 +44342,6 @@ var ts; var TypeScriptServicesFactory = (function () { function TypeScriptServicesFactory() { this._shims = []; - this.documentRegistry = ts.createDocumentRegistry(); } /* * Returns script API version. @@ -43884,6 +44351,9 @@ var ts; }; TypeScriptServicesFactory.prototype.createLanguageServiceShim = function (host) { try { + if (this.documentRegistry === undefined) { + this.documentRegistry = ts.createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames()); + } var hostAdapter = new LanguageServiceShimHostAdapter(host); var languageService = ts.createLanguageService(hostAdapter, this.documentRegistry); return new LanguageServiceShimObject(this, host, languageService); diff --git a/bin/typescriptServices.d.ts b/bin/typescriptServices.d.ts index 9a153ade4b1..da6d55bfd80 100644 --- a/bin/typescriptServices.d.ts +++ b/bin/typescriptServices.d.ts @@ -13,10 +13,17 @@ See the Apache Version 2.0 License for specific language governing permissions and limitations under the License. ***************************************************************************** */ -declare module ts { +declare namespace ts { interface Map { [index: string]: T; } + interface FileMap { + get(fileName: string): T; + set(fileName: string, value: T): void; + contains(fileName: string): boolean; + remove(fileName: string): void; + forEachValue(f: (v: T) => void): void; + } interface TextRange { pos: number; end: number; @@ -139,156 +146,158 @@ declare module ts { ConstructorKeyword = 114, DeclareKeyword = 115, GetKeyword = 116, - ModuleKeyword = 117, - NamespaceKeyword = 118, - RequireKeyword = 119, - NumberKeyword = 120, - SetKeyword = 121, - StringKeyword = 122, - SymbolKeyword = 123, - TypeKeyword = 124, - FromKeyword = 125, - OfKeyword = 126, - QualifiedName = 127, - ComputedPropertyName = 128, - TypeParameter = 129, - Parameter = 130, - Decorator = 131, - PropertySignature = 132, - PropertyDeclaration = 133, - MethodSignature = 134, - MethodDeclaration = 135, - Constructor = 136, - GetAccessor = 137, - SetAccessor = 138, - CallSignature = 139, - ConstructSignature = 140, - IndexSignature = 141, - TypeReference = 142, - FunctionType = 143, - ConstructorType = 144, - TypeQuery = 145, - TypeLiteral = 146, - ArrayType = 147, - TupleType = 148, - UnionType = 149, - ParenthesizedType = 150, - ObjectBindingPattern = 151, - ArrayBindingPattern = 152, - BindingElement = 153, - ArrayLiteralExpression = 154, - ObjectLiteralExpression = 155, - PropertyAccessExpression = 156, - ElementAccessExpression = 157, - CallExpression = 158, - NewExpression = 159, - TaggedTemplateExpression = 160, - TypeAssertionExpression = 161, - ParenthesizedExpression = 162, - FunctionExpression = 163, - ArrowFunction = 164, - DeleteExpression = 165, - TypeOfExpression = 166, - VoidExpression = 167, - PrefixUnaryExpression = 168, - PostfixUnaryExpression = 169, - BinaryExpression = 170, - ConditionalExpression = 171, - TemplateExpression = 172, - YieldExpression = 173, - SpreadElementExpression = 174, - ClassExpression = 175, - OmittedExpression = 176, - ExpressionWithTypeArguments = 177, - TemplateSpan = 178, - SemicolonClassElement = 179, - Block = 180, - VariableStatement = 181, - EmptyStatement = 182, - ExpressionStatement = 183, - IfStatement = 184, - DoStatement = 185, - WhileStatement = 186, - ForStatement = 187, - ForInStatement = 188, - ForOfStatement = 189, - ContinueStatement = 190, - BreakStatement = 191, - ReturnStatement = 192, - WithStatement = 193, - SwitchStatement = 194, - LabeledStatement = 195, - ThrowStatement = 196, - TryStatement = 197, - DebuggerStatement = 198, - VariableDeclaration = 199, - VariableDeclarationList = 200, - FunctionDeclaration = 201, - ClassDeclaration = 202, - InterfaceDeclaration = 203, - TypeAliasDeclaration = 204, - EnumDeclaration = 205, - ModuleDeclaration = 206, - ModuleBlock = 207, - CaseBlock = 208, - ImportEqualsDeclaration = 209, - ImportDeclaration = 210, - ImportClause = 211, - NamespaceImport = 212, - NamedImports = 213, - ImportSpecifier = 214, - ExportAssignment = 215, - ExportDeclaration = 216, - NamedExports = 217, - ExportSpecifier = 218, - MissingDeclaration = 219, - ExternalModuleReference = 220, - CaseClause = 221, - DefaultClause = 222, - HeritageClause = 223, - CatchClause = 224, - PropertyAssignment = 225, - ShorthandPropertyAssignment = 226, - EnumMember = 227, - SourceFile = 228, - JSDocTypeExpression = 229, - JSDocAllType = 230, - JSDocUnknownType = 231, - JSDocArrayType = 232, - JSDocUnionType = 233, - JSDocTupleType = 234, - JSDocNullableType = 235, - JSDocNonNullableType = 236, - JSDocRecordType = 237, - JSDocRecordMember = 238, - JSDocTypeReference = 239, - JSDocOptionalType = 240, - JSDocFunctionType = 241, - JSDocVariadicType = 242, - JSDocConstructorType = 243, - JSDocThisType = 244, - JSDocComment = 245, - JSDocTag = 246, - JSDocParameterTag = 247, - JSDocReturnTag = 248, - JSDocTypeTag = 249, - JSDocTemplateTag = 250, - SyntaxList = 251, - Count = 252, + IsKeyword = 117, + ModuleKeyword = 118, + NamespaceKeyword = 119, + RequireKeyword = 120, + NumberKeyword = 121, + SetKeyword = 122, + StringKeyword = 123, + SymbolKeyword = 124, + TypeKeyword = 125, + FromKeyword = 126, + OfKeyword = 127, + QualifiedName = 128, + ComputedPropertyName = 129, + TypeParameter = 130, + Parameter = 131, + Decorator = 132, + PropertySignature = 133, + PropertyDeclaration = 134, + MethodSignature = 135, + MethodDeclaration = 136, + Constructor = 137, + GetAccessor = 138, + SetAccessor = 139, + CallSignature = 140, + ConstructSignature = 141, + IndexSignature = 142, + TypePredicate = 143, + TypeReference = 144, + FunctionType = 145, + ConstructorType = 146, + TypeQuery = 147, + TypeLiteral = 148, + ArrayType = 149, + TupleType = 150, + UnionType = 151, + ParenthesizedType = 152, + ObjectBindingPattern = 153, + ArrayBindingPattern = 154, + BindingElement = 155, + ArrayLiteralExpression = 156, + ObjectLiteralExpression = 157, + PropertyAccessExpression = 158, + ElementAccessExpression = 159, + CallExpression = 160, + NewExpression = 161, + TaggedTemplateExpression = 162, + TypeAssertionExpression = 163, + ParenthesizedExpression = 164, + FunctionExpression = 165, + ArrowFunction = 166, + DeleteExpression = 167, + TypeOfExpression = 168, + VoidExpression = 169, + PrefixUnaryExpression = 170, + PostfixUnaryExpression = 171, + BinaryExpression = 172, + ConditionalExpression = 173, + TemplateExpression = 174, + YieldExpression = 175, + SpreadElementExpression = 176, + ClassExpression = 177, + OmittedExpression = 178, + ExpressionWithTypeArguments = 179, + TemplateSpan = 180, + SemicolonClassElement = 181, + Block = 182, + VariableStatement = 183, + EmptyStatement = 184, + ExpressionStatement = 185, + IfStatement = 186, + DoStatement = 187, + WhileStatement = 188, + ForStatement = 189, + ForInStatement = 190, + ForOfStatement = 191, + ContinueStatement = 192, + BreakStatement = 193, + ReturnStatement = 194, + WithStatement = 195, + SwitchStatement = 196, + LabeledStatement = 197, + ThrowStatement = 198, + TryStatement = 199, + DebuggerStatement = 200, + VariableDeclaration = 201, + VariableDeclarationList = 202, + FunctionDeclaration = 203, + ClassDeclaration = 204, + InterfaceDeclaration = 205, + TypeAliasDeclaration = 206, + EnumDeclaration = 207, + ModuleDeclaration = 208, + ModuleBlock = 209, + CaseBlock = 210, + ImportEqualsDeclaration = 211, + ImportDeclaration = 212, + ImportClause = 213, + NamespaceImport = 214, + NamedImports = 215, + ImportSpecifier = 216, + ExportAssignment = 217, + ExportDeclaration = 218, + NamedExports = 219, + ExportSpecifier = 220, + MissingDeclaration = 221, + ExternalModuleReference = 222, + CaseClause = 223, + DefaultClause = 224, + HeritageClause = 225, + CatchClause = 226, + PropertyAssignment = 227, + ShorthandPropertyAssignment = 228, + EnumMember = 229, + SourceFile = 230, + JSDocTypeExpression = 231, + JSDocAllType = 232, + JSDocUnknownType = 233, + JSDocArrayType = 234, + JSDocUnionType = 235, + JSDocTupleType = 236, + JSDocNullableType = 237, + JSDocNonNullableType = 238, + JSDocRecordType = 239, + JSDocRecordMember = 240, + JSDocTypeReference = 241, + JSDocOptionalType = 242, + JSDocFunctionType = 243, + JSDocVariadicType = 244, + JSDocConstructorType = 245, + JSDocThisType = 246, + JSDocComment = 247, + JSDocTag = 248, + JSDocParameterTag = 249, + JSDocReturnTag = 250, + JSDocTypeTag = 251, + JSDocTemplateTag = 252, + SyntaxList = 253, + Count = 254, FirstAssignment = 53, LastAssignment = 64, FirstReservedWord = 66, LastReservedWord = 101, FirstKeyword = 66, - LastKeyword = 126, + LastKeyword = 127, FirstFutureReservedWord = 102, LastFutureReservedWord = 110, - FirstTypeNode = 142, - LastTypeNode = 150, + FirstTypeNode = 144, + LastTypeNode = 152, FirstPunctuation = 14, LastPunctuation = 64, FirstToken = 0, - LastToken = 126, + LastToken = 127, FirstTriviaToken = 2, LastTriviaToken = 6, FirstLiteralToken = 7, @@ -297,7 +306,7 @@ declare module ts { LastTemplateToken = 13, FirstBinaryOperator = 24, LastBinaryOperator = 64, - FirstNode = 127, + FirstNode = 128, } const enum NodeFlags { Export = 1, @@ -458,6 +467,10 @@ declare module ts { typeName: EntityName; typeArguments?: NodeArray; } + interface TypePredicateNode extends TypeNode { + parameterName: Identifier; + type: TypeNode; + } interface TypeQueryNode extends TypeNode { exprName: EntityName; } @@ -592,7 +605,7 @@ declare module ts { type: TypeNode; expression: UnaryExpression; } - interface Statement extends Node, ModuleElement { + interface Statement extends Node { _statementBrand: any; } interface Block extends Statement { @@ -672,9 +685,6 @@ declare module ts { variableDeclaration: VariableDeclaration; block: Block; } - interface ModuleElement extends Node { - _moduleElementBrand: any; - } interface ClassLikeDeclaration extends Declaration { name?: Identifier; typeParameters?: NodeArray; @@ -700,6 +710,7 @@ declare module ts { } interface TypeAliasDeclaration extends Declaration, Statement { name: Identifier; + typeParameters?: NodeArray; type: TypeNode; } interface EnumMember extends Declaration { @@ -710,21 +721,21 @@ declare module ts { name: Identifier; members: NodeArray; } - interface ModuleDeclaration extends Declaration, ModuleElement { + interface ModuleDeclaration extends Declaration, Statement { name: Identifier | LiteralExpression; body: ModuleBlock | ModuleDeclaration; } - interface ModuleBlock extends Node, ModuleElement { - statements: NodeArray; + interface ModuleBlock extends Node, Statement { + statements: NodeArray; } - interface ImportEqualsDeclaration extends Declaration, ModuleElement { + interface ImportEqualsDeclaration extends Declaration, Statement { name: Identifier; moduleReference: EntityName | ExternalModuleReference; } interface ExternalModuleReference extends Node { expression?: Expression; } - interface ImportDeclaration extends ModuleElement { + interface ImportDeclaration extends Statement { importClause?: ImportClause; moduleSpecifier: Expression; } @@ -735,7 +746,7 @@ declare module ts { interface NamespaceImport extends Declaration { name: Identifier; } - interface ExportDeclaration extends Declaration, ModuleElement { + interface ExportDeclaration extends Declaration, Statement { exportClause?: NamedExports; moduleSpecifier?: Expression; } @@ -750,7 +761,7 @@ declare module ts { } type ImportSpecifier = ImportOrExportSpecifier; type ExportSpecifier = ImportOrExportSpecifier; - interface ExportAssignment extends Declaration, ModuleElement { + interface ExportAssignment extends Declaration, Statement { isExportEquals?: boolean; expression: Expression; } @@ -838,7 +849,7 @@ declare module ts { isBracketed: boolean; } interface SourceFile extends Declaration { - statements: NodeArray; + statements: NodeArray; endOfFileToken: Node; fileName: string; text: string; @@ -846,8 +857,16 @@ declare module ts { path: string; name: string; }[]; - amdModuleName: string; + moduleName: string; referencedFiles: FileReference[]; + /** + * lib.d.ts should have a reference comment like + * + * /// + * + * If any other file has this comment, it signals not to include lib.d.ts + * because this containing file is intended to act as a default library. + */ hasNoDefaultLib: boolean; languageVersion: ScriptTarget; } @@ -878,8 +897,9 @@ declare module ts { * will be invoked when writing the JavaScript and declaration files. */ emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback): EmitResult; - getSyntacticDiagnostics(sourceFile?: SourceFile): Diagnostic[]; + getOptionsDiagnostics(): Diagnostic[]; getGlobalDiagnostics(): Diagnostic[]; + getSyntacticDiagnostics(sourceFile?: SourceFile): Diagnostic[]; getSemanticDiagnostics(sourceFile?: SourceFile): Diagnostic[]; getDeclarationDiagnostics(sourceFile?: SourceFile): Diagnostic[]; /** @@ -998,6 +1018,11 @@ declare module ts { WriteTypeParametersOrArguments = 1, UseOnlyExternalAliasing = 2, } + interface TypePredicate { + parameterName: string; + parameterIndex: number; + type: Type; + } const enum SymbolFlags { None = 0, FunctionScopedVariable = 1, @@ -1060,6 +1085,7 @@ declare module ts { ExportHasLocal = 944, HasExports = 1952, HasMembers = 6240, + BlockScoped = 418, PropertyOrAccessor = 98308, Export = 7340032, } @@ -1111,9 +1137,8 @@ declare module ts { typeParameters: TypeParameter[]; outerTypeParameters: TypeParameter[]; localTypeParameters: TypeParameter[]; - } - interface InterfaceTypeWithBaseTypes extends InterfaceType { - baseTypes: ObjectType[]; + resolvedBaseConstructorType?: Type; + resolvedBaseTypes: ObjectType[]; } interface InterfaceTypeWithDeclaredMembers extends InterfaceType { declaredProperties: Symbol[]; @@ -1146,6 +1171,7 @@ declare module ts { declaration: SignatureDeclaration; typeParameters: TypeParameter[]; parameters: Symbol[]; + typePredicate?: TypePredicate; } const enum IndexKind { String = 0, @@ -1267,7 +1293,7 @@ declare module ts { newLength: number; } } -declare module ts { +declare namespace ts { interface System { args: string[]; newLine: string; @@ -1291,7 +1317,7 @@ declare module ts { } var sys: System; } -declare module ts { +declare namespace ts { interface ErrorCallback { (message: DiagnosticMessage, length: number): void; } @@ -1323,12 +1349,13 @@ declare module ts { function getLineAndCharacterOfPosition(sourceFile: SourceFile, position: number): LineAndCharacter; function isWhiteSpace(ch: number): boolean; function isLineBreak(ch: number): boolean; + function couldStartTrivia(text: string, pos: number): boolean; function getLeadingCommentRanges(text: string, pos: number): CommentRange[]; function getTrailingCommentRanges(text: string, pos: number): CommentRange[]; function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean; } -declare module ts { +declare namespace ts { function getDefaultLibFileName(options: CompilerOptions): string; function textSpanEnd(span: TextSpan): number; function textSpanIsEmpty(span: TextSpan): boolean; @@ -1338,6 +1365,7 @@ declare module ts { function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan; function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan): boolean; function textSpanIntersectsWith(span: TextSpan, start: number, length: number): boolean; + function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): boolean; function textSpanIntersectsWithPosition(span: TextSpan, position: number): boolean; function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan; function createTextSpan(start: number, length: number): TextSpan; @@ -1357,14 +1385,14 @@ declare module ts { function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange; function getTypeParameterOwner(d: Declaration): Declaration; } -declare module ts { +declare namespace ts { function getNodeConstructor(kind: SyntaxKind): new () => Node; function createNode(kind: SyntaxKind): Node; function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T; function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean): SourceFile; function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile; } -declare module ts { +declare namespace ts { /** The version of the TypeScript compiler release */ const version: string; function findConfigFile(searchPath: string): string; @@ -1373,7 +1401,7 @@ declare module ts { function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string; function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program; } -declare module ts { +declare namespace ts { function parseCommandLine(commandLine: string[]): ParsedCommandLine; /** * Read tsconfig.json file @@ -1400,7 +1428,7 @@ declare module ts { */ function parseConfigFile(json: any, host: ParseConfigHost, basePath: string): ParsedCommandLine; } -declare module ts { +declare namespace ts { /** The version of the language service API */ let servicesVersion: string; interface Node { @@ -1490,6 +1518,7 @@ declare module ts { log?(s: string): void; trace?(s: string): void; error?(s: string): void; + useCaseSensitiveFileNames?(): boolean; } interface LanguageService { cleanupSemanticCache(): void; @@ -1948,11 +1977,11 @@ declare module ts { isCancellationRequested(): boolean; throwIfCancellationRequested(): void; } - function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string; + function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string; function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile; let disableIncrementalParsing: boolean; function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile; - function createDocumentRegistry(): DocumentRegistry; + function createDocumentRegistry(useCaseSensitiveFileNames?: boolean): DocumentRegistry; function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo; function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService; function createClassifier(): Classifier; diff --git a/bin/typescriptServices.js b/bin/typescriptServices.js index 138a38642c9..2e3a784b298 100644 --- a/bin/typescriptServices.js +++ b/bin/typescriptServices.js @@ -144,176 +144,178 @@ var ts; SyntaxKind[SyntaxKind["ConstructorKeyword"] = 114] = "ConstructorKeyword"; SyntaxKind[SyntaxKind["DeclareKeyword"] = 115] = "DeclareKeyword"; SyntaxKind[SyntaxKind["GetKeyword"] = 116] = "GetKeyword"; - SyntaxKind[SyntaxKind["ModuleKeyword"] = 117] = "ModuleKeyword"; - SyntaxKind[SyntaxKind["NamespaceKeyword"] = 118] = "NamespaceKeyword"; - SyntaxKind[SyntaxKind["RequireKeyword"] = 119] = "RequireKeyword"; - SyntaxKind[SyntaxKind["NumberKeyword"] = 120] = "NumberKeyword"; - SyntaxKind[SyntaxKind["SetKeyword"] = 121] = "SetKeyword"; - SyntaxKind[SyntaxKind["StringKeyword"] = 122] = "StringKeyword"; - SyntaxKind[SyntaxKind["SymbolKeyword"] = 123] = "SymbolKeyword"; - SyntaxKind[SyntaxKind["TypeKeyword"] = 124] = "TypeKeyword"; - SyntaxKind[SyntaxKind["FromKeyword"] = 125] = "FromKeyword"; - SyntaxKind[SyntaxKind["OfKeyword"] = 126] = "OfKeyword"; + SyntaxKind[SyntaxKind["IsKeyword"] = 117] = "IsKeyword"; + SyntaxKind[SyntaxKind["ModuleKeyword"] = 118] = "ModuleKeyword"; + SyntaxKind[SyntaxKind["NamespaceKeyword"] = 119] = "NamespaceKeyword"; + SyntaxKind[SyntaxKind["RequireKeyword"] = 120] = "RequireKeyword"; + SyntaxKind[SyntaxKind["NumberKeyword"] = 121] = "NumberKeyword"; + SyntaxKind[SyntaxKind["SetKeyword"] = 122] = "SetKeyword"; + SyntaxKind[SyntaxKind["StringKeyword"] = 123] = "StringKeyword"; + SyntaxKind[SyntaxKind["SymbolKeyword"] = 124] = "SymbolKeyword"; + SyntaxKind[SyntaxKind["TypeKeyword"] = 125] = "TypeKeyword"; + SyntaxKind[SyntaxKind["FromKeyword"] = 126] = "FromKeyword"; + SyntaxKind[SyntaxKind["OfKeyword"] = 127] = "OfKeyword"; // Parse tree nodes // Names - SyntaxKind[SyntaxKind["QualifiedName"] = 127] = "QualifiedName"; - SyntaxKind[SyntaxKind["ComputedPropertyName"] = 128] = "ComputedPropertyName"; + SyntaxKind[SyntaxKind["QualifiedName"] = 128] = "QualifiedName"; + SyntaxKind[SyntaxKind["ComputedPropertyName"] = 129] = "ComputedPropertyName"; // Signature elements - SyntaxKind[SyntaxKind["TypeParameter"] = 129] = "TypeParameter"; - SyntaxKind[SyntaxKind["Parameter"] = 130] = "Parameter"; - SyntaxKind[SyntaxKind["Decorator"] = 131] = "Decorator"; + SyntaxKind[SyntaxKind["TypeParameter"] = 130] = "TypeParameter"; + SyntaxKind[SyntaxKind["Parameter"] = 131] = "Parameter"; + SyntaxKind[SyntaxKind["Decorator"] = 132] = "Decorator"; // TypeMember - SyntaxKind[SyntaxKind["PropertySignature"] = 132] = "PropertySignature"; - SyntaxKind[SyntaxKind["PropertyDeclaration"] = 133] = "PropertyDeclaration"; - SyntaxKind[SyntaxKind["MethodSignature"] = 134] = "MethodSignature"; - SyntaxKind[SyntaxKind["MethodDeclaration"] = 135] = "MethodDeclaration"; - SyntaxKind[SyntaxKind["Constructor"] = 136] = "Constructor"; - SyntaxKind[SyntaxKind["GetAccessor"] = 137] = "GetAccessor"; - SyntaxKind[SyntaxKind["SetAccessor"] = 138] = "SetAccessor"; - SyntaxKind[SyntaxKind["CallSignature"] = 139] = "CallSignature"; - SyntaxKind[SyntaxKind["ConstructSignature"] = 140] = "ConstructSignature"; - SyntaxKind[SyntaxKind["IndexSignature"] = 141] = "IndexSignature"; + SyntaxKind[SyntaxKind["PropertySignature"] = 133] = "PropertySignature"; + SyntaxKind[SyntaxKind["PropertyDeclaration"] = 134] = "PropertyDeclaration"; + SyntaxKind[SyntaxKind["MethodSignature"] = 135] = "MethodSignature"; + SyntaxKind[SyntaxKind["MethodDeclaration"] = 136] = "MethodDeclaration"; + SyntaxKind[SyntaxKind["Constructor"] = 137] = "Constructor"; + SyntaxKind[SyntaxKind["GetAccessor"] = 138] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 139] = "SetAccessor"; + SyntaxKind[SyntaxKind["CallSignature"] = 140] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 141] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 142] = "IndexSignature"; // Type - SyntaxKind[SyntaxKind["TypeReference"] = 142] = "TypeReference"; - SyntaxKind[SyntaxKind["FunctionType"] = 143] = "FunctionType"; - SyntaxKind[SyntaxKind["ConstructorType"] = 144] = "ConstructorType"; - SyntaxKind[SyntaxKind["TypeQuery"] = 145] = "TypeQuery"; - SyntaxKind[SyntaxKind["TypeLiteral"] = 146] = "TypeLiteral"; - SyntaxKind[SyntaxKind["ArrayType"] = 147] = "ArrayType"; - SyntaxKind[SyntaxKind["TupleType"] = 148] = "TupleType"; - SyntaxKind[SyntaxKind["UnionType"] = 149] = "UnionType"; - SyntaxKind[SyntaxKind["ParenthesizedType"] = 150] = "ParenthesizedType"; + SyntaxKind[SyntaxKind["TypePredicate"] = 143] = "TypePredicate"; + SyntaxKind[SyntaxKind["TypeReference"] = 144] = "TypeReference"; + SyntaxKind[SyntaxKind["FunctionType"] = 145] = "FunctionType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 146] = "ConstructorType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 147] = "TypeQuery"; + SyntaxKind[SyntaxKind["TypeLiteral"] = 148] = "TypeLiteral"; + SyntaxKind[SyntaxKind["ArrayType"] = 149] = "ArrayType"; + SyntaxKind[SyntaxKind["TupleType"] = 150] = "TupleType"; + SyntaxKind[SyntaxKind["UnionType"] = 151] = "UnionType"; + SyntaxKind[SyntaxKind["ParenthesizedType"] = 152] = "ParenthesizedType"; // Binding patterns - SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 151] = "ObjectBindingPattern"; - SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 152] = "ArrayBindingPattern"; - SyntaxKind[SyntaxKind["BindingElement"] = 153] = "BindingElement"; + SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 153] = "ObjectBindingPattern"; + SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 154] = "ArrayBindingPattern"; + SyntaxKind[SyntaxKind["BindingElement"] = 155] = "BindingElement"; // Expression - SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 154] = "ArrayLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 155] = "ObjectLiteralExpression"; - SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 156] = "PropertyAccessExpression"; - SyntaxKind[SyntaxKind["ElementAccessExpression"] = 157] = "ElementAccessExpression"; - SyntaxKind[SyntaxKind["CallExpression"] = 158] = "CallExpression"; - SyntaxKind[SyntaxKind["NewExpression"] = 159] = "NewExpression"; - SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 160] = "TaggedTemplateExpression"; - SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 161] = "TypeAssertionExpression"; - SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 162] = "ParenthesizedExpression"; - SyntaxKind[SyntaxKind["FunctionExpression"] = 163] = "FunctionExpression"; - SyntaxKind[SyntaxKind["ArrowFunction"] = 164] = "ArrowFunction"; - SyntaxKind[SyntaxKind["DeleteExpression"] = 165] = "DeleteExpression"; - SyntaxKind[SyntaxKind["TypeOfExpression"] = 166] = "TypeOfExpression"; - SyntaxKind[SyntaxKind["VoidExpression"] = 167] = "VoidExpression"; - SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 168] = "PrefixUnaryExpression"; - SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 169] = "PostfixUnaryExpression"; - SyntaxKind[SyntaxKind["BinaryExpression"] = 170] = "BinaryExpression"; - SyntaxKind[SyntaxKind["ConditionalExpression"] = 171] = "ConditionalExpression"; - SyntaxKind[SyntaxKind["TemplateExpression"] = 172] = "TemplateExpression"; - SyntaxKind[SyntaxKind["YieldExpression"] = 173] = "YieldExpression"; - SyntaxKind[SyntaxKind["SpreadElementExpression"] = 174] = "SpreadElementExpression"; - SyntaxKind[SyntaxKind["ClassExpression"] = 175] = "ClassExpression"; - SyntaxKind[SyntaxKind["OmittedExpression"] = 176] = "OmittedExpression"; - SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 177] = "ExpressionWithTypeArguments"; + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 156] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 157] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 158] = "PropertyAccessExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 159] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["CallExpression"] = 160] = "CallExpression"; + SyntaxKind[SyntaxKind["NewExpression"] = 161] = "NewExpression"; + SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 162] = "TaggedTemplateExpression"; + SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 163] = "TypeAssertionExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 164] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 165] = "FunctionExpression"; + SyntaxKind[SyntaxKind["ArrowFunction"] = 166] = "ArrowFunction"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 167] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 168] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 169] = "VoidExpression"; + SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 170] = "PrefixUnaryExpression"; + SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 171] = "PostfixUnaryExpression"; + SyntaxKind[SyntaxKind["BinaryExpression"] = 172] = "BinaryExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 173] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["TemplateExpression"] = 174] = "TemplateExpression"; + SyntaxKind[SyntaxKind["YieldExpression"] = 175] = "YieldExpression"; + SyntaxKind[SyntaxKind["SpreadElementExpression"] = 176] = "SpreadElementExpression"; + SyntaxKind[SyntaxKind["ClassExpression"] = 177] = "ClassExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 178] = "OmittedExpression"; + SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 179] = "ExpressionWithTypeArguments"; // Misc - SyntaxKind[SyntaxKind["TemplateSpan"] = 178] = "TemplateSpan"; - SyntaxKind[SyntaxKind["SemicolonClassElement"] = 179] = "SemicolonClassElement"; + SyntaxKind[SyntaxKind["TemplateSpan"] = 180] = "TemplateSpan"; + SyntaxKind[SyntaxKind["SemicolonClassElement"] = 181] = "SemicolonClassElement"; // Element - SyntaxKind[SyntaxKind["Block"] = 180] = "Block"; - SyntaxKind[SyntaxKind["VariableStatement"] = 181] = "VariableStatement"; - SyntaxKind[SyntaxKind["EmptyStatement"] = 182] = "EmptyStatement"; - SyntaxKind[SyntaxKind["ExpressionStatement"] = 183] = "ExpressionStatement"; - SyntaxKind[SyntaxKind["IfStatement"] = 184] = "IfStatement"; - SyntaxKind[SyntaxKind["DoStatement"] = 185] = "DoStatement"; - SyntaxKind[SyntaxKind["WhileStatement"] = 186] = "WhileStatement"; - SyntaxKind[SyntaxKind["ForStatement"] = 187] = "ForStatement"; - SyntaxKind[SyntaxKind["ForInStatement"] = 188] = "ForInStatement"; - SyntaxKind[SyntaxKind["ForOfStatement"] = 189] = "ForOfStatement"; - SyntaxKind[SyntaxKind["ContinueStatement"] = 190] = "ContinueStatement"; - SyntaxKind[SyntaxKind["BreakStatement"] = 191] = "BreakStatement"; - SyntaxKind[SyntaxKind["ReturnStatement"] = 192] = "ReturnStatement"; - SyntaxKind[SyntaxKind["WithStatement"] = 193] = "WithStatement"; - SyntaxKind[SyntaxKind["SwitchStatement"] = 194] = "SwitchStatement"; - SyntaxKind[SyntaxKind["LabeledStatement"] = 195] = "LabeledStatement"; - SyntaxKind[SyntaxKind["ThrowStatement"] = 196] = "ThrowStatement"; - SyntaxKind[SyntaxKind["TryStatement"] = 197] = "TryStatement"; - SyntaxKind[SyntaxKind["DebuggerStatement"] = 198] = "DebuggerStatement"; - SyntaxKind[SyntaxKind["VariableDeclaration"] = 199] = "VariableDeclaration"; - SyntaxKind[SyntaxKind["VariableDeclarationList"] = 200] = "VariableDeclarationList"; - SyntaxKind[SyntaxKind["FunctionDeclaration"] = 201] = "FunctionDeclaration"; - SyntaxKind[SyntaxKind["ClassDeclaration"] = 202] = "ClassDeclaration"; - SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 203] = "InterfaceDeclaration"; - SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 204] = "TypeAliasDeclaration"; - SyntaxKind[SyntaxKind["EnumDeclaration"] = 205] = "EnumDeclaration"; - SyntaxKind[SyntaxKind["ModuleDeclaration"] = 206] = "ModuleDeclaration"; - SyntaxKind[SyntaxKind["ModuleBlock"] = 207] = "ModuleBlock"; - SyntaxKind[SyntaxKind["CaseBlock"] = 208] = "CaseBlock"; - SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 209] = "ImportEqualsDeclaration"; - SyntaxKind[SyntaxKind["ImportDeclaration"] = 210] = "ImportDeclaration"; - SyntaxKind[SyntaxKind["ImportClause"] = 211] = "ImportClause"; - SyntaxKind[SyntaxKind["NamespaceImport"] = 212] = "NamespaceImport"; - SyntaxKind[SyntaxKind["NamedImports"] = 213] = "NamedImports"; - SyntaxKind[SyntaxKind["ImportSpecifier"] = 214] = "ImportSpecifier"; - SyntaxKind[SyntaxKind["ExportAssignment"] = 215] = "ExportAssignment"; - SyntaxKind[SyntaxKind["ExportDeclaration"] = 216] = "ExportDeclaration"; - SyntaxKind[SyntaxKind["NamedExports"] = 217] = "NamedExports"; - SyntaxKind[SyntaxKind["ExportSpecifier"] = 218] = "ExportSpecifier"; - SyntaxKind[SyntaxKind["MissingDeclaration"] = 219] = "MissingDeclaration"; + SyntaxKind[SyntaxKind["Block"] = 182] = "Block"; + SyntaxKind[SyntaxKind["VariableStatement"] = 183] = "VariableStatement"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 184] = "EmptyStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 185] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["IfStatement"] = 186] = "IfStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 187] = "DoStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 188] = "WhileStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 189] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 190] = "ForInStatement"; + SyntaxKind[SyntaxKind["ForOfStatement"] = 191] = "ForOfStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 192] = "ContinueStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 193] = "BreakStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 194] = "ReturnStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 195] = "WithStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 196] = "SwitchStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 197] = "LabeledStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 198] = "ThrowStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 199] = "TryStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 200] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["VariableDeclaration"] = 201] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarationList"] = 202] = "VariableDeclarationList"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 203] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 204] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 205] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 206] = "TypeAliasDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 207] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 208] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ModuleBlock"] = 209] = "ModuleBlock"; + SyntaxKind[SyntaxKind["CaseBlock"] = 210] = "CaseBlock"; + SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 211] = "ImportEqualsDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 212] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ImportClause"] = 213] = "ImportClause"; + SyntaxKind[SyntaxKind["NamespaceImport"] = 214] = "NamespaceImport"; + SyntaxKind[SyntaxKind["NamedImports"] = 215] = "NamedImports"; + SyntaxKind[SyntaxKind["ImportSpecifier"] = 216] = "ImportSpecifier"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 217] = "ExportAssignment"; + SyntaxKind[SyntaxKind["ExportDeclaration"] = 218] = "ExportDeclaration"; + SyntaxKind[SyntaxKind["NamedExports"] = 219] = "NamedExports"; + SyntaxKind[SyntaxKind["ExportSpecifier"] = 220] = "ExportSpecifier"; + SyntaxKind[SyntaxKind["MissingDeclaration"] = 221] = "MissingDeclaration"; // Module references - SyntaxKind[SyntaxKind["ExternalModuleReference"] = 220] = "ExternalModuleReference"; + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 222] = "ExternalModuleReference"; // Clauses - SyntaxKind[SyntaxKind["CaseClause"] = 221] = "CaseClause"; - SyntaxKind[SyntaxKind["DefaultClause"] = 222] = "DefaultClause"; - SyntaxKind[SyntaxKind["HeritageClause"] = 223] = "HeritageClause"; - SyntaxKind[SyntaxKind["CatchClause"] = 224] = "CatchClause"; + SyntaxKind[SyntaxKind["CaseClause"] = 223] = "CaseClause"; + SyntaxKind[SyntaxKind["DefaultClause"] = 224] = "DefaultClause"; + SyntaxKind[SyntaxKind["HeritageClause"] = 225] = "HeritageClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 226] = "CatchClause"; // Property assignments - SyntaxKind[SyntaxKind["PropertyAssignment"] = 225] = "PropertyAssignment"; - SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 226] = "ShorthandPropertyAssignment"; + SyntaxKind[SyntaxKind["PropertyAssignment"] = 227] = "PropertyAssignment"; + SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 228] = "ShorthandPropertyAssignment"; // Enum - SyntaxKind[SyntaxKind["EnumMember"] = 227] = "EnumMember"; + SyntaxKind[SyntaxKind["EnumMember"] = 229] = "EnumMember"; // Top-level nodes - SyntaxKind[SyntaxKind["SourceFile"] = 228] = "SourceFile"; + SyntaxKind[SyntaxKind["SourceFile"] = 230] = "SourceFile"; // JSDoc nodes. - SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 229] = "JSDocTypeExpression"; + SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 231] = "JSDocTypeExpression"; // The * type. - SyntaxKind[SyntaxKind["JSDocAllType"] = 230] = "JSDocAllType"; + SyntaxKind[SyntaxKind["JSDocAllType"] = 232] = "JSDocAllType"; // The ? type. - SyntaxKind[SyntaxKind["JSDocUnknownType"] = 231] = "JSDocUnknownType"; - SyntaxKind[SyntaxKind["JSDocArrayType"] = 232] = "JSDocArrayType"; - SyntaxKind[SyntaxKind["JSDocUnionType"] = 233] = "JSDocUnionType"; - SyntaxKind[SyntaxKind["JSDocTupleType"] = 234] = "JSDocTupleType"; - SyntaxKind[SyntaxKind["JSDocNullableType"] = 235] = "JSDocNullableType"; - SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 236] = "JSDocNonNullableType"; - SyntaxKind[SyntaxKind["JSDocRecordType"] = 237] = "JSDocRecordType"; - SyntaxKind[SyntaxKind["JSDocRecordMember"] = 238] = "JSDocRecordMember"; - SyntaxKind[SyntaxKind["JSDocTypeReference"] = 239] = "JSDocTypeReference"; - SyntaxKind[SyntaxKind["JSDocOptionalType"] = 240] = "JSDocOptionalType"; - SyntaxKind[SyntaxKind["JSDocFunctionType"] = 241] = "JSDocFunctionType"; - SyntaxKind[SyntaxKind["JSDocVariadicType"] = 242] = "JSDocVariadicType"; - SyntaxKind[SyntaxKind["JSDocConstructorType"] = 243] = "JSDocConstructorType"; - SyntaxKind[SyntaxKind["JSDocThisType"] = 244] = "JSDocThisType"; - SyntaxKind[SyntaxKind["JSDocComment"] = 245] = "JSDocComment"; - SyntaxKind[SyntaxKind["JSDocTag"] = 246] = "JSDocTag"; - SyntaxKind[SyntaxKind["JSDocParameterTag"] = 247] = "JSDocParameterTag"; - SyntaxKind[SyntaxKind["JSDocReturnTag"] = 248] = "JSDocReturnTag"; - SyntaxKind[SyntaxKind["JSDocTypeTag"] = 249] = "JSDocTypeTag"; - SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 250] = "JSDocTemplateTag"; + SyntaxKind[SyntaxKind["JSDocUnknownType"] = 233] = "JSDocUnknownType"; + SyntaxKind[SyntaxKind["JSDocArrayType"] = 234] = "JSDocArrayType"; + SyntaxKind[SyntaxKind["JSDocUnionType"] = 235] = "JSDocUnionType"; + SyntaxKind[SyntaxKind["JSDocTupleType"] = 236] = "JSDocTupleType"; + SyntaxKind[SyntaxKind["JSDocNullableType"] = 237] = "JSDocNullableType"; + SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 238] = "JSDocNonNullableType"; + SyntaxKind[SyntaxKind["JSDocRecordType"] = 239] = "JSDocRecordType"; + SyntaxKind[SyntaxKind["JSDocRecordMember"] = 240] = "JSDocRecordMember"; + SyntaxKind[SyntaxKind["JSDocTypeReference"] = 241] = "JSDocTypeReference"; + SyntaxKind[SyntaxKind["JSDocOptionalType"] = 242] = "JSDocOptionalType"; + SyntaxKind[SyntaxKind["JSDocFunctionType"] = 243] = "JSDocFunctionType"; + SyntaxKind[SyntaxKind["JSDocVariadicType"] = 244] = "JSDocVariadicType"; + SyntaxKind[SyntaxKind["JSDocConstructorType"] = 245] = "JSDocConstructorType"; + SyntaxKind[SyntaxKind["JSDocThisType"] = 246] = "JSDocThisType"; + SyntaxKind[SyntaxKind["JSDocComment"] = 247] = "JSDocComment"; + SyntaxKind[SyntaxKind["JSDocTag"] = 248] = "JSDocTag"; + SyntaxKind[SyntaxKind["JSDocParameterTag"] = 249] = "JSDocParameterTag"; + SyntaxKind[SyntaxKind["JSDocReturnTag"] = 250] = "JSDocReturnTag"; + SyntaxKind[SyntaxKind["JSDocTypeTag"] = 251] = "JSDocTypeTag"; + SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 252] = "JSDocTemplateTag"; // Synthesized list - SyntaxKind[SyntaxKind["SyntaxList"] = 251] = "SyntaxList"; + SyntaxKind[SyntaxKind["SyntaxList"] = 253] = "SyntaxList"; // Enum value count - SyntaxKind[SyntaxKind["Count"] = 252] = "Count"; + SyntaxKind[SyntaxKind["Count"] = 254] = "Count"; // Markers SyntaxKind[SyntaxKind["FirstAssignment"] = 53] = "FirstAssignment"; SyntaxKind[SyntaxKind["LastAssignment"] = 64] = "LastAssignment"; SyntaxKind[SyntaxKind["FirstReservedWord"] = 66] = "FirstReservedWord"; SyntaxKind[SyntaxKind["LastReservedWord"] = 101] = "LastReservedWord"; SyntaxKind[SyntaxKind["FirstKeyword"] = 66] = "FirstKeyword"; - SyntaxKind[SyntaxKind["LastKeyword"] = 126] = "LastKeyword"; + SyntaxKind[SyntaxKind["LastKeyword"] = 127] = "LastKeyword"; SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 102] = "FirstFutureReservedWord"; SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 110] = "LastFutureReservedWord"; - SyntaxKind[SyntaxKind["FirstTypeNode"] = 142] = "FirstTypeNode"; - SyntaxKind[SyntaxKind["LastTypeNode"] = 150] = "LastTypeNode"; + SyntaxKind[SyntaxKind["FirstTypeNode"] = 144] = "FirstTypeNode"; + SyntaxKind[SyntaxKind["LastTypeNode"] = 152] = "LastTypeNode"; SyntaxKind[SyntaxKind["FirstPunctuation"] = 14] = "FirstPunctuation"; SyntaxKind[SyntaxKind["LastPunctuation"] = 64] = "LastPunctuation"; SyntaxKind[SyntaxKind["FirstToken"] = 0] = "FirstToken"; - SyntaxKind[SyntaxKind["LastToken"] = 126] = "LastToken"; + SyntaxKind[SyntaxKind["LastToken"] = 127] = "LastToken"; SyntaxKind[SyntaxKind["FirstTriviaToken"] = 2] = "FirstTriviaToken"; SyntaxKind[SyntaxKind["LastTriviaToken"] = 6] = "LastTriviaToken"; SyntaxKind[SyntaxKind["FirstLiteralToken"] = 7] = "FirstLiteralToken"; @@ -322,7 +324,7 @@ var ts; SyntaxKind[SyntaxKind["LastTemplateToken"] = 13] = "LastTemplateToken"; SyntaxKind[SyntaxKind["FirstBinaryOperator"] = 24] = "FirstBinaryOperator"; SyntaxKind[SyntaxKind["LastBinaryOperator"] = 64] = "LastBinaryOperator"; - SyntaxKind[SyntaxKind["FirstNode"] = 127] = "FirstNode"; + SyntaxKind[SyntaxKind["FirstNode"] = 128] = "FirstNode"; })(ts.SyntaxKind || (ts.SyntaxKind = {})); var SyntaxKind = ts.SyntaxKind; (function (NodeFlags) { @@ -349,9 +351,6 @@ var ts; /* @internal */ (function (ParserContextFlags) { ParserContextFlags[ParserContextFlags["None"] = 0] = "None"; - // Set if this node was parsed in strict mode. Used for grammar error checks, as well as - // checking if the node can be reused in incremental settings. - ParserContextFlags[ParserContextFlags["StrictMode"] = 1] = "StrictMode"; // If this node was parsed in a context where 'in-expressions' are not allowed. ParserContextFlags[ParserContextFlags["DisallowIn"] = 2] = "DisallowIn"; // If this node was parsed in the 'yield' context created when parsing a generator. @@ -368,7 +367,7 @@ var ts; // its type can be specified usign a JSDoc comment. ParserContextFlags[ParserContextFlags["JavaScriptFile"] = 64] = "JavaScriptFile"; // Context flags set directly by the parser. - ParserContextFlags[ParserContextFlags["ParserGeneratedFlags"] = 63] = "ParserGeneratedFlags"; + ParserContextFlags[ParserContextFlags["ParserGeneratedFlags"] = 62] = "ParserGeneratedFlags"; // Context flags computed by aggregating child flags upwards. // Used during incremental parsing to determine if this node or any of its children had an // error. Computed only once and then cached. @@ -494,8 +493,13 @@ var ts; SymbolFlags[SymbolFlags["ExportHasLocal"] = 944] = "ExportHasLocal"; SymbolFlags[SymbolFlags["HasExports"] = 1952] = "HasExports"; SymbolFlags[SymbolFlags["HasMembers"] = 6240] = "HasMembers"; + SymbolFlags[SymbolFlags["BlockScoped"] = 418] = "BlockScoped"; SymbolFlags[SymbolFlags["PropertyOrAccessor"] = 98308] = "PropertyOrAccessor"; SymbolFlags[SymbolFlags["Export"] = 7340032] = "Export"; + /* @internal */ + // The set of things we consider semantically classifiable. Used to speed up the LS during + // classification. + SymbolFlags[SymbolFlags["Classifiable"] = 788448] = "Classifiable"; })(ts.SymbolFlags || (ts.SymbolFlags = {})); var SymbolFlags = ts.SymbolFlags; /* @internal */ @@ -735,6 +739,36 @@ var ts; Ternary[Ternary["True"] = -1] = "True"; })(ts.Ternary || (ts.Ternary = {})); var Ternary = ts.Ternary; + function createFileMap(getCanonicalFileName) { + var files = {}; + return { + get: get, + set: set, + contains: contains, + remove: remove, + forEachValue: forEachValueInMap + }; + function set(fileName, value) { + files[normalizeKey(fileName)] = value; + } + function get(fileName) { + return files[normalizeKey(fileName)]; + } + function contains(fileName) { + return hasProperty(files, normalizeKey(fileName)); + } + function remove(fileName) { + var key = normalizeKey(fileName); + delete files[key]; + } + function forEachValueInMap(f) { + forEachValue(files, f); + } + function normalizeKey(key) { + return getCanonicalFileName(normalizeSlashes(key)); + } + } + ts.createFileMap = createFileMap; (function (Comparison) { Comparison[Comparison["LessThan"] = -1] = "LessThan"; Comparison[Comparison["EqualTo"] = 0] = "EqualTo"; @@ -1232,7 +1266,7 @@ var ts; function getNormalizedPathComponents(path, currentDirectory) { path = normalizeSlashes(path); var rootLength = getRootLength(path); - if (rootLength == 0) { + if (rootLength === 0) { // If the path is not rooted it is relative to current directory path = combinePaths(normalizeSlashes(currentDirectory), path); rootLength = getRootLength(path); @@ -1896,14 +1930,26 @@ var ts; A_class_declaration_without_the_default_modifier_must_have_a_name: { code: 1211, category: ts.DiagnosticCategory.Error, key: "A class declaration without the 'default' modifier must have a name" }, Identifier_expected_0_is_a_reserved_word_in_strict_mode: { code: 1212, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode" }, Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1213, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, - Type_expected_0_is_a_reserved_word_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode" }, - Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: ts.DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: { code: 1214, category: ts.DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode." }, + Invalid_use_of_0_Modules_are_automatically_in_strict_mode: { code: 1215, category: ts.DiagnosticCategory.Error, key: "Invalid use of '{0}'. Modules are automatically in strict mode." }, Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: ts.DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalDecorators_to_remove_this_warning: { code: 1219, category: ts.DiagnosticCategory.Error, key: "Experimental support for decorators is a feature that is subject to change in a future release. Specify '--experimentalDecorators' to remove this warning." }, Generators_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 1220, category: ts.DiagnosticCategory.Error, key: "Generators are only available when targeting ECMAScript 6 or higher." }, Generators_are_not_allowed_in_an_ambient_context: { code: 1221, category: ts.DiagnosticCategory.Error, key: "Generators are not allowed in an ambient context." }, An_overload_signature_cannot_be_declared_as_a_generator: { code: 1222, category: ts.DiagnosticCategory.Error, key: "An overload signature cannot be declared as a generator." }, _0_tag_already_specified: { code: 1223, category: ts.DiagnosticCategory.Error, key: "'{0}' tag already specified." }, + Signature_0_must_have_a_type_predicate: { code: 1224, category: ts.DiagnosticCategory.Error, key: "Signature '{0}' must have a type predicate." }, + Cannot_find_parameter_0: { code: 1225, category: ts.DiagnosticCategory.Error, key: "Cannot find parameter '{0}'." }, + Type_predicate_0_is_not_assignable_to_1: { code: 1226, category: ts.DiagnosticCategory.Error, key: "Type predicate '{0}' is not assignable to '{1}'." }, + Parameter_0_is_not_in_the_same_position_as_parameter_1: { code: 1227, category: ts.DiagnosticCategory.Error, key: "Parameter '{0}' is not in the same position as parameter '{1}'." }, + A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: { code: 1228, category: ts.DiagnosticCategory.Error, key: "A type predicate is only allowed in return type position for functions and methods." }, + A_type_predicate_cannot_reference_a_rest_parameter: { code: 1229, category: ts.DiagnosticCategory.Error, key: "A type predicate cannot reference a rest parameter." }, + A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: { code: 1230, category: ts.DiagnosticCategory.Error, key: "A type predicate cannot reference element '{0}' in a binding pattern." }, + An_export_assignment_can_only_be_used_in_a_module: { code: 1231, category: ts.DiagnosticCategory.Error, key: "An export assignment can only be used in a module." }, + An_import_declaration_can_only_be_used_in_a_namespace_or_module: { code: 1232, category: ts.DiagnosticCategory.Error, key: "An import declaration can only be used in a namespace or module." }, + An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, + An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, + A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.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: ts.DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -2097,6 +2143,11 @@ var ts; Cannot_find_namespace_0: { code: 2503, category: ts.DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, No_best_common_type_exists_among_yield_expressions: { code: 2504, category: ts.DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: ts.DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, + _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: { code: 2506, category: ts.DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own base expression." }, + Type_0_is_not_a_constructor_function_type: { code: 2507, category: ts.DiagnosticCategory.Error, key: "Type '{0}' is not a constructor function type." }, + No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: ts.DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." }, + Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: ts.DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." }, + Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: ts.DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: ts.DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: ts.DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -2306,7 +2357,7 @@ var ts; "false": 80 /* FalseKeyword */, "finally": 81 /* FinallyKeyword */, "for": 82 /* ForKeyword */, - "from": 125 /* FromKeyword */, + "from": 126 /* FromKeyword */, "function": 83 /* FunctionKeyword */, "get": 116 /* GetKeyword */, "if": 84 /* IfKeyword */, @@ -2315,36 +2366,37 @@ var ts; "in": 86 /* InKeyword */, "instanceof": 87 /* InstanceOfKeyword */, "interface": 103 /* InterfaceKeyword */, + "is": 117 /* IsKeyword */, "let": 104 /* LetKeyword */, - "module": 117 /* ModuleKeyword */, - "namespace": 118 /* NamespaceKeyword */, + "module": 118 /* ModuleKeyword */, + "namespace": 119 /* NamespaceKeyword */, "new": 88 /* NewKeyword */, "null": 89 /* NullKeyword */, - "number": 120 /* NumberKeyword */, + "number": 121 /* NumberKeyword */, "package": 105 /* PackageKeyword */, "private": 106 /* PrivateKeyword */, "protected": 107 /* ProtectedKeyword */, "public": 108 /* PublicKeyword */, - "require": 119 /* RequireKeyword */, + "require": 120 /* RequireKeyword */, "return": 90 /* ReturnKeyword */, - "set": 121 /* SetKeyword */, + "set": 122 /* SetKeyword */, "static": 109 /* StaticKeyword */, - "string": 122 /* StringKeyword */, + "string": 123 /* StringKeyword */, "super": 91 /* SuperKeyword */, "switch": 92 /* SwitchKeyword */, - "symbol": 123 /* SymbolKeyword */, + "symbol": 124 /* SymbolKeyword */, "this": 93 /* ThisKeyword */, "throw": 94 /* ThrowKeyword */, "true": 95 /* TrueKeyword */, "try": 96 /* TryKeyword */, - "type": 124 /* TypeKeyword */, + "type": 125 /* TypeKeyword */, "typeof": 97 /* TypeOfKeyword */, "var": 98 /* VarKeyword */, "void": 99 /* VoidKeyword */, "while": 100 /* WhileKeyword */, "with": 101 /* WithKeyword */, "yield": 110 /* YieldKeyword */, - "of": 126 /* OfKeyword */, + "of": 127 /* OfKeyword */, "{": 14 /* OpenBraceToken */, "}": 15 /* CloseBraceToken */, "(": 16 /* OpenParenToken */, @@ -2604,8 +2656,31 @@ var ts; return ch >= 48 /* _0 */ && ch <= 55 /* _7 */; } ts.isOctalDigit = isOctalDigit; + function couldStartTrivia(text, pos) { + // Keep in sync with skipTrivia + var ch = text.charCodeAt(pos); + switch (ch) { + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 32 /* space */: + case 47 /* slash */: + // starts of normal trivia + case 60 /* lessThan */: + case 61 /* equals */: + case 62 /* greaterThan */: + // Starts of conflict marker trivia + return true; + default: + return ch > 127 /* maxAsciiCharacter */; + } + } + ts.couldStartTrivia = couldStartTrivia; /* @internal */ function skipTrivia(text, pos, stopAfterLineBreak) { + // Keep in sync with couldStartTrivia while (true) { var ch = text.charCodeAt(pos); switch (ch) { @@ -3109,7 +3184,7 @@ var ts; error(ts.Diagnostics.Unexpected_end_of_text); isInvalidExtendedEscape = true; } - else if (text.charCodeAt(pos) == 125 /* closeBrace */) { + else if (text.charCodeAt(pos) === 125 /* closeBrace */) { // Only swallow the following character up if it's a '}'. pos++; } @@ -3666,16 +3741,16 @@ var ts; function getModuleInstanceState(node) { // A module is uninstantiated if it contains only // 1. interface declarations, type alias declarations - if (node.kind === 203 /* InterfaceDeclaration */ || node.kind === 204 /* TypeAliasDeclaration */) { + if (node.kind === 205 /* InterfaceDeclaration */ || node.kind === 206 /* TypeAliasDeclaration */) { return 0 /* NonInstantiated */; } else if (ts.isConstEnumDeclaration(node)) { return 2 /* ConstEnumOnly */; } - else if ((node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */) && !(node.flags & 1 /* Export */)) { + else if ((node.kind === 212 /* ImportDeclaration */ || node.kind === 211 /* ImportEqualsDeclaration */) && !(node.flags & 1 /* Export */)) { return 0 /* NonInstantiated */; } - else if (node.kind === 207 /* ModuleBlock */) { + else if (node.kind === 209 /* ModuleBlock */) { var state = 0 /* NonInstantiated */; ts.forEachChild(node, function (n) { switch (getModuleInstanceState(n)) { @@ -3694,7 +3769,7 @@ var ts; }); return state; } - else if (node.kind === 206 /* ModuleDeclaration */) { + else if (node.kind === 208 /* ModuleDeclaration */) { return getModuleInstanceState(node.body); } else { @@ -3734,11 +3809,17 @@ var ts; var container; var blockScopeContainer; var lastContainer; + // If this file is an external module, then it is automatically in strict-mode according to + // ES6. If it is not an external module, then we'll determine if it is in strict mode or + // not depending on if we see "use strict" in certain places (or if we hit a class/namespace). + var inStrictMode = !!file.externalModuleIndicator; var symbolCount = 0; var Symbol = ts.objectAllocator.getSymbolConstructor(); + var classifiableNames = {}; if (!file.locals) { bind(file); file.symbolCount = symbolCount; + file.classifiableNames = classifiableNames; } return; function createSymbol(flags, name) { @@ -3766,10 +3847,10 @@ var ts; // unless it is a well known Symbol. function getDeclarationName(node) { if (node.name) { - if (node.kind === 206 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */) { + if (node.kind === 208 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */) { return '"' + node.name.text + '"'; } - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { var nameExpression = node.name.expression; ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); @@ -3777,22 +3858,22 @@ var ts; return node.name.text; } switch (node.kind) { - case 136 /* Constructor */: + case 137 /* Constructor */: return "__constructor"; - case 143 /* FunctionType */: - case 139 /* CallSignature */: + case 145 /* FunctionType */: + case 140 /* CallSignature */: return "__call"; - case 144 /* ConstructorType */: - case 140 /* ConstructSignature */: + case 146 /* ConstructorType */: + case 141 /* ConstructSignature */: return "__new"; - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: return "__index"; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return "__export"; - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return node.isExportEquals ? "export=" : "default"; - case 201 /* FunctionDeclaration */: - case 202 /* ClassDeclaration */: + case 203 /* FunctionDeclaration */: + case 204 /* ClassDeclaration */: return node.flags & 256 /* Default */ ? "default" : undefined; } } @@ -3826,6 +3907,9 @@ var ts; symbol = ts.hasProperty(symbolTable, name) ? symbolTable[name] : (symbolTable[name] = createSymbol(0 /* None */, name)); + if (name && (includes & 788448 /* Classifiable */)) { + classifiableNames[name] = name; + } if (symbol.flags & excludes) { if (node.name) { node.name.parent = node; @@ -3852,7 +3936,7 @@ var ts; function declareModuleMember(node, symbolFlags, symbolExcludes) { var hasExportModifier = ts.getCombinedNodeFlags(node) & 1 /* Export */; if (symbolFlags & 8388608 /* Alias */) { - if (node.kind === 218 /* ExportSpecifier */ || (node.kind === 209 /* ImportEqualsDeclaration */ && hasExportModifier)) { + if (node.kind === 220 /* ExportSpecifier */ || (node.kind === 211 /* ImportEqualsDeclaration */ && hasExportModifier)) { return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); } else { @@ -3933,36 +4017,37 @@ var ts; } function getContainerFlags(node) { switch (node.kind) { - case 175 /* ClassExpression */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 146 /* TypeLiteral */: - case 155 /* ObjectLiteralExpression */: + case 177 /* ClassExpression */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 148 /* TypeLiteral */: + case 157 /* ObjectLiteralExpression */: return 1 /* IsContainer */; - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 201 /* FunctionDeclaration */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 206 /* ModuleDeclaration */: - case 228 /* SourceFile */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 203 /* FunctionDeclaration */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 208 /* ModuleDeclaration */: + case 230 /* SourceFile */: + case 206 /* TypeAliasDeclaration */: return 5 /* IsContainerWithLocals */; - case 224 /* CatchClause */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 208 /* CaseBlock */: + case 226 /* CatchClause */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 210 /* CaseBlock */: return 2 /* IsBlockScopedContainer */; - case 180 /* Block */: + case 182 /* Block */: // do not treat blocks directly inside a function as a block-scoped-container. // Locals that reside in this block should go to the function locals. Othewise 'x' // would not appear to be a redeclaration of a block scoped local in the following @@ -3995,45 +4080,47 @@ var ts; } function declareSymbolAndAddToSymbolTableWorker(node, symbolFlags, symbolExcludes) { switch (container.kind) { - // Modules, source files, and classes need specialized handling for how their + // Modules, source files, and classes need specialized handling for how their // members are declared (for example, a member of a class will go into a specific - // symbol table depending on if it is static or not). As such, we defer to - // specialized handlers to take care of declaring these child members. - case 206 /* ModuleDeclaration */: + // symbol table depending on if it is static or not). We defer to specialized + // handlers to take care of declaring these child members. + case 208 /* ModuleDeclaration */: return declareModuleMember(node, symbolFlags, symbolExcludes); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return declareSourceFileMember(node, symbolFlags, symbolExcludes); - case 175 /* ClassExpression */: - case 202 /* ClassDeclaration */: + case 177 /* ClassExpression */: + case 204 /* ClassDeclaration */: return declareClassMember(node, symbolFlags, symbolExcludes); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); - case 146 /* TypeLiteral */: - case 155 /* ObjectLiteralExpression */: - case 203 /* InterfaceDeclaration */: + case 148 /* TypeLiteral */: + case 157 /* ObjectLiteralExpression */: + case 205 /* InterfaceDeclaration */: // Interface/Object-types always have their children added to the 'members' of - // their container. They are only accessible through an instance of their - // container, and are never in scope otherwise (even inside the body of the - // object / type / interface declaring them). + // their container. They are only accessible through an instance of their + // container, and are never in scope otherwise (even inside the body of the + // object / type / interface declaring them). An exception is type parameters, + // which are in scope without qualification (similar to 'locals'). return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 206 /* TypeAliasDeclaration */: // All the children of these container types are never visible through another - // symbol (i.e. through another symbol's 'exports' or 'members'). Instead, - // they're only accessed 'lexically' (i.e. from code that exists underneath + // symbol (i.e. through another symbol's 'exports' or 'members'). Instead, + // they're only accessed 'lexically' (i.e. from code that exists underneath // their container in the tree. To accomplish this, we simply add their declared - // symbol to the 'locals' of the container. These symbols can then be found as + // symbol to the 'locals' of the container. These symbols can then be found as // the type checker walks up the containers, checking them for matching names. return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes); } @@ -4058,11 +4145,11 @@ var ts; return false; } function hasExportDeclarations(node) { - var body = node.kind === 228 /* SourceFile */ ? node : node.body; - if (body.kind === 228 /* SourceFile */ || body.kind === 207 /* ModuleBlock */) { + var body = node.kind === 230 /* SourceFile */ ? node : node.body; + if (body.kind === 230 /* SourceFile */ || body.kind === 209 /* ModuleBlock */) { for (var _i = 0, _a = body.statements; _i < _a.length; _i++) { var stat = _a[_i]; - if (stat.kind === 216 /* ExportDeclaration */ || stat.kind === 215 /* ExportAssignment */) { + if (stat.kind === 218 /* ExportDeclaration */ || stat.kind === 217 /* ExportAssignment */) { return true; } } @@ -4117,16 +4204,54 @@ var ts; typeLiteralSymbol.members = (_a = {}, _a[symbol.name] = symbol, _a); var _a; } + function bindObjectLiteralExpression(node) { + var ElementKind; + (function (ElementKind) { + ElementKind[ElementKind["Property"] = 1] = "Property"; + ElementKind[ElementKind["Accessor"] = 2] = "Accessor"; + })(ElementKind || (ElementKind = {})); + if (inStrictMode) { + var seen = {}; + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var prop = _a[_i]; + if (prop.name.kind !== 65 /* Identifier */) { + continue; + } + var identifier = prop.name; + // ECMA-262 11.1.5 Object Initialiser + // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true + // a.This production is contained in strict code and IsDataDescriptor(previous) is true and + // IsDataDescriptor(propId.descriptor) is true. + // b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true. + // c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true. + // d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true + // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields + var currentKind = prop.kind === 227 /* PropertyAssignment */ || prop.kind === 228 /* ShorthandPropertyAssignment */ || prop.kind === 136 /* MethodDeclaration */ + ? 1 /* Property */ + : 2 /* Accessor */; + var existingKind = seen[identifier.text]; + if (!existingKind) { + seen[identifier.text] = currentKind; + continue; + } + if (currentKind === 1 /* Property */ && existingKind === 1 /* Property */) { + var span = ts.getErrorSpanForNode(file, identifier); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode)); + } + } + } + return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object"); + } function bindAnonymousDeclaration(node, symbolFlags, name) { var symbol = createSymbol(symbolFlags, name); addDeclarationToSymbol(symbol, node, symbolFlags); } function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) { switch (blockScopeContainer.kind) { - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: declareModuleMember(node, symbolFlags, symbolExcludes); break; - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolFlags, symbolExcludes); break; @@ -4143,11 +4268,126 @@ var ts; function bindBlockScopedVariableDeclaration(node) { bindBlockScopedDeclaration(node, 2 /* BlockScopedVariable */, 107455 /* BlockScopedVariableExcludes */); } + // The binder visits every node in the syntax tree so it is a convenient place to perform a single localized + // check for reserved words used as identifiers in strict mode code. + function checkStrictModeIdentifier(node) { + if (inStrictMode && + node.originalKeywordKind >= 102 /* FirstFutureReservedWord */ && + node.originalKeywordKind <= 110 /* LastFutureReservedWord */ && + !ts.isIdentifierName(node)) { + // Report error only if there are no parse errors in file + if (!file.parseDiagnostics.length) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node))); + } + } + } + function getStrictModeIdentifierMessage(node) { + // Provide specialized messages to help the user understand why we think they're in + // strict mode. + if (ts.getAncestor(node, 204 /* ClassDeclaration */) || ts.getAncestor(node, 177 /* ClassExpression */)) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode; + } + function checkStrictModeBinaryExpression(node) { + if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { + // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an + // Assignment operator(11.13) or of a PostfixExpression(11.3) + checkStrictModeEvalOrArguments(node, node.left); + } + } + function checkStrictModeCatchClause(node) { + // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the + // Catch production is eval or arguments + if (inStrictMode && node.variableDeclaration) { + checkStrictModeEvalOrArguments(node, node.variableDeclaration.name); + } + } + function checkStrictModeDeleteExpression(node) { + // Grammar checking + if (inStrictMode && node.expression.kind === 65 /* 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 + var span = ts.getErrorSpanForNode(file, node.expression); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode)); + } + } + function isEvalOrArgumentsIdentifier(node) { + return node.kind === 65 /* Identifier */ && + (node.text === "eval" || node.text === "arguments"); + } + function checkStrictModeEvalOrArguments(contextNode, name) { + if (name && name.kind === 65 /* Identifier */) { + var identifier = name; + if (isEvalOrArgumentsIdentifier(identifier)) { + // We check first if the name is inside class declaration or class expression; if so give explicit message + // otherwise report generic error message. + var span = ts.getErrorSpanForNode(file, name); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), identifier.text)); + } + } + } + function getStrictModeEvalOrArgumentsMessage(node) { + // Provide specialized messages to help the user understand why we think they're in + // strict mode. + if (ts.getAncestor(node, 204 /* ClassDeclaration */) || ts.getAncestor(node, 177 /* ClassExpression */)) { + return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Invalid_use_of_0_in_strict_mode; + } + function checkStrictModeFunctionName(node) { + if (inStrictMode) { + // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1)) + checkStrictModeEvalOrArguments(node, node.name); + } + } + function checkStrictModeNumericLiteral(node) { + if (inStrictMode && node.flags & 16384 /* OctalLiteral */) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode)); + } + } + function checkStrictModePostfixUnaryExpression(node) { + // Grammar checking + // 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 (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + function checkStrictModePrefixUnaryExpression(node) { + // Grammar checking + if (inStrictMode) { + if (node.operator === 38 /* PlusPlusToken */ || node.operator === 39 /* MinusMinusToken */) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + } + function checkStrictModeWithStatement(node) { + // Grammar checking for withStatement + if (inStrictMode) { + grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); + } + } + function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) { + var span = ts.getSpanOfTokenAtPosition(file, node.pos); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2)); + } function getDestructuringParameterName(node) { return "__" + ts.indexOf(node.parent.parameters, node); } function bind(node) { node.parent = parent; + var savedInStrictMode = inStrictMode; + if (!savedInStrictMode) { + updateStrictMode(node); + } // First we bind declaration nodes to a symbol if possible. We'll both create a symbol // and then potentially add the symbol to an appropriate symbol table. Possible // destination symbol tables are: @@ -4164,76 +4404,132 @@ var ts; // the current 'container' node when it changes. This helps us know which symbol table // a local should go into for example. bindChildren(node); + inStrictMode = savedInStrictMode; + } + function updateStrictMode(node) { + switch (node.kind) { + case 230 /* SourceFile */: + case 209 /* ModuleBlock */: + updateStrictModeStatementList(node.statements); + return; + case 182 /* Block */: + if (ts.isFunctionLike(node.parent)) { + updateStrictModeStatementList(node.statements); + } + return; + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + // All classes are automatically in strict mode in ES6. + inStrictMode = true; + return; + } + } + function updateStrictModeStatementList(statements) { + for (var _i = 0; _i < statements.length; _i++) { + var statement = statements[_i]; + if (!ts.isPrologueDirective(statement)) { + return; + } + if (isUseStrictPrologueDirective(statement)) { + inStrictMode = true; + return; + } + } + } + /// Should be called only on prologue directives (isPrologueDirective(node) should be true) + function isUseStrictPrologueDirective(node) { + var nodeText = ts.getTextOfNodeFromSourceText(file.text, node.expression); + // Note: the node text must be exactly "use strict" or 'use strict'. It is not ok for the + // string to contain unicode escapes (as per ES5). + return nodeText === '"use strict"' || nodeText === "'use strict'"; } function bindWorker(node) { switch (node.kind) { - case 129 /* TypeParameter */: + case 65 /* Identifier */: + return checkStrictModeIdentifier(node); + case 172 /* BinaryExpression */: + return checkStrictModeBinaryExpression(node); + case 226 /* CatchClause */: + return checkStrictModeCatchClause(node); + case 167 /* DeleteExpression */: + return checkStrictModeDeleteExpression(node); + case 7 /* NumericLiteral */: + return checkStrictModeNumericLiteral(node); + case 171 /* PostfixUnaryExpression */: + return checkStrictModePostfixUnaryExpression(node); + case 170 /* PrefixUnaryExpression */: + return checkStrictModePrefixUnaryExpression(node); + case 195 /* WithStatement */: + return checkStrictModeWithStatement(node); + case 130 /* TypeParameter */: return declareSymbolAndAddToSymbolTable(node, 262144 /* TypeParameter */, 530912 /* TypeParameterExcludes */); - case 130 /* Parameter */: + case 131 /* Parameter */: return bindParameter(node); - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: return bindVariableDeclarationOrBindingElement(node); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return bindPropertyOrMethodOrAccessor(node, 4 /* Property */ | (node.questionToken ? 536870912 /* Optional */ : 0 /* None */), 107455 /* PropertyExcludes */); - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: + case 227 /* PropertyAssignment */: + case 228 /* ShorthandPropertyAssignment */: return bindPropertyOrMethodOrAccessor(node, 4 /* Property */, 107455 /* PropertyExcludes */); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return bindPropertyOrMethodOrAccessor(node, 8 /* EnumMember */, 107455 /* EnumMemberExcludes */); - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: return declareSymbolAndAddToSymbolTable(node, 131072 /* Signature */, 0 /* None */); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: // If this is an ObjectLiteralExpression method, then it sits in the same space // as other properties in the object literal. So we use SymbolFlags.PropertyExcludes // so that it will conflict with any other object literal members with the same // name. return bindPropertyOrMethodOrAccessor(node, 8192 /* Method */ | (node.questionToken ? 536870912 /* Optional */ : 0 /* None */), ts.isObjectLiteralMethod(node) ? 107455 /* PropertyExcludes */ : 99263 /* MethodExcludes */); - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: + checkStrictModeFunctionName(node); return declareSymbolAndAddToSymbolTable(node, 16 /* Function */, 106927 /* FunctionExcludes */); - case 136 /* Constructor */: + case 137 /* Constructor */: return declareSymbolAndAddToSymbolTable(node, 16384 /* Constructor */, 0 /* None */); - case 137 /* GetAccessor */: + case 138 /* GetAccessor */: return bindPropertyOrMethodOrAccessor(node, 32768 /* GetAccessor */, 41919 /* GetAccessorExcludes */); - case 138 /* SetAccessor */: + case 139 /* SetAccessor */: return bindPropertyOrMethodOrAccessor(node, 65536 /* SetAccessor */, 74687 /* SetAccessorExcludes */); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return bindFunctionOrConstructorType(node); - case 146 /* TypeLiteral */: + case 148 /* TypeLiteral */: return bindAnonymousDeclaration(node, 2048 /* TypeLiteral */, "__type"); - case 155 /* ObjectLiteralExpression */: - return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object"); - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 157 /* ObjectLiteralExpression */: + return bindObjectLiteralExpression(node); + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + checkStrictModeFunctionName(node); return bindAnonymousDeclaration(node, 16 /* Function */, "__function"); - case 175 /* ClassExpression */: - case 202 /* ClassDeclaration */: + case 177 /* ClassExpression */: + case 204 /* ClassDeclaration */: return bindClassLikeDeclaration(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return bindBlockScopedDeclaration(node, 64 /* Interface */, 792992 /* InterfaceExcludes */); - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: return bindBlockScopedDeclaration(node, 524288 /* TypeAlias */, 793056 /* TypeAliasExcludes */); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return bindEnumDeclaration(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return bindModuleDeclaration(node); - case 209 /* ImportEqualsDeclaration */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 214 /* NamespaceImport */: + case 216 /* ImportSpecifier */: + case 220 /* ExportSpecifier */: return declareSymbolAndAddToSymbolTable(node, 8388608 /* Alias */, 8388608 /* AliasExcludes */); - case 211 /* ImportClause */: + case 213 /* ImportClause */: return bindImportClause(node); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return bindExportDeclaration(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return bindExportAssignment(node); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return bindSourceFileIfExternalModule(); } } @@ -4244,7 +4540,11 @@ var ts; } } function bindExportAssignment(node) { - if (node.expression.kind === 65 /* Identifier */) { + if (!container.symbol || !container.symbol.exports) { + // Export assignment in some sort of block construct + bindAnonymousDeclaration(node, 8388608 /* Alias */, getDeclarationName(node)); + } + else if (node.expression.kind === 65 /* Identifier */) { // An export default clause with an identifier exports all meanings of that identifier declareSymbol(container.symbol.exports, container.symbol, node, 8388608 /* Alias */, 107455 /* PropertyExcludes */ | 8388608 /* AliasExcludes */); } @@ -4254,7 +4554,11 @@ var ts; } } function bindExportDeclaration(node) { - if (!node.exportClause) { + if (!container.symbol || !container.symbol.exports) { + // Export * in some sort of block construct + bindAnonymousDeclaration(node, 1073741824 /* ExportStar */, getDeclarationName(node)); + } + else if (!node.exportClause) { // All export * declarations are collected in an __export symbol declareSymbol(container.symbol.exports, container.symbol, node, 1073741824 /* ExportStar */, 0 /* None */); } @@ -4265,7 +4569,7 @@ var ts; } } function bindClassLikeDeclaration(node) { - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { bindBlockScopedDeclaration(node, 32 /* Class */, 899583 /* ClassExcludes */); } else { @@ -4297,6 +4601,9 @@ var ts; : bindBlockScopedDeclaration(node, 256 /* RegularEnum */, 899327 /* RegularEnumExcludes */); } function bindVariableDeclarationOrBindingElement(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } if (!ts.isBindingPattern(node.name)) { if (ts.isBlockOrCatchScoped(node)) { bindBlockScopedVariableDeclaration(node); @@ -4319,6 +4626,11 @@ var ts; } } function bindParameter(node) { + if (inStrictMode) { + // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a + // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) + checkStrictModeEvalOrArguments(node, node.name); + } if (ts.isBindingPattern(node.name)) { bindAnonymousDeclaration(node, 1 /* FunctionScopedVariable */, getDestructuringParameterName(node)); } @@ -4328,8 +4640,8 @@ var ts; // If this is a property-parameter, then also declare the property symbol into the // containing class. if (node.flags & 112 /* AccessibilityModifier */ && - node.parent.kind === 136 /* Constructor */ && - (node.parent.parent.kind === 202 /* ClassDeclaration */ || node.parent.parent.kind === 175 /* ClassExpression */)) { + node.parent.kind === 137 /* Constructor */ && + (node.parent.parent.kind === 204 /* ClassDeclaration */ || node.parent.parent.kind === 177 /* ClassExpression */)) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* Property */, 107455 /* PropertyExcludes */); } @@ -4359,7 +4671,7 @@ var ts; // Pool writers to avoid needing to allocate them for every symbol we write. var stringWriters = []; function getSingleLineStringWriter() { - if (stringWriters.length == 0) { + if (stringWriters.length === 0) { var str = ""; var writeText = function (text) { return str += text; }; return { @@ -4416,7 +4728,7 @@ var ts; } } function getSourceFileOfNode(node) { - while (node && node.kind !== 228 /* SourceFile */) { + while (node && node.kind !== 230 /* SourceFile */) { node = node.parent; } return node; @@ -4526,15 +4838,15 @@ var ts; return current; } switch (current.kind) { - case 228 /* SourceFile */: - case 208 /* CaseBlock */: - case 224 /* CatchClause */: - case 206 /* ModuleDeclaration */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 230 /* SourceFile */: + case 210 /* CaseBlock */: + case 226 /* CatchClause */: + case 208 /* ModuleDeclaration */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: return current; - case 180 /* Block */: + case 182 /* Block */: // function block is not considered block-scope container // see comment in binder.ts: bind(...), case for SyntaxKind.Block if (!isFunctionLike(current.parent)) { @@ -4547,9 +4859,9 @@ var ts; ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer; function isCatchClauseVariableDeclaration(declaration) { return declaration && - declaration.kind === 199 /* VariableDeclaration */ && + declaration.kind === 201 /* VariableDeclaration */ && declaration.parent && - declaration.parent.kind === 224 /* CatchClause */; + declaration.parent.kind === 226 /* CatchClause */; } ts.isCatchClauseVariableDeclaration = isCatchClauseVariableDeclaration; // Return display name of an identifier @@ -4588,7 +4900,7 @@ var ts; function getErrorSpanForNode(sourceFile, node) { var errorNode = node; switch (node.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: var pos_1 = ts.skipTrivia(sourceFile.text, 0, false); if (pos_1 === sourceFile.text.length) { // file is empty - return span for the beginning of the file @@ -4597,16 +4909,16 @@ var ts; return getSpanOfTokenAtPosition(sourceFile, pos_1); // This list is a work in progress. Add missing node kinds to improve their error // spans. - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + case 205 /* InterfaceDeclaration */: + case 208 /* ModuleDeclaration */: + case 207 /* EnumDeclaration */: + case 229 /* EnumMember */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: errorNode = node.name; break; } @@ -4630,11 +4942,11 @@ var ts; } ts.isDeclarationFile = isDeclarationFile; function isConstEnumDeclaration(node) { - return node.kind === 205 /* EnumDeclaration */ && isConst(node); + return node.kind === 207 /* EnumDeclaration */ && isConst(node); } ts.isConstEnumDeclaration = isConstEnumDeclaration; function walkUpBindingElementsAndPatterns(node) { - while (node && (node.kind === 153 /* BindingElement */ || isBindingPattern(node))) { + while (node && (node.kind === 155 /* BindingElement */ || isBindingPattern(node))) { node = node.parent; } return node; @@ -4649,14 +4961,14 @@ var ts; function getCombinedNodeFlags(node) { node = walkUpBindingElementsAndPatterns(node); var flags = node.flags; - if (node.kind === 199 /* VariableDeclaration */) { + if (node.kind === 201 /* VariableDeclaration */) { node = node.parent; } - if (node && node.kind === 200 /* VariableDeclarationList */) { + if (node && node.kind === 202 /* VariableDeclarationList */) { flags |= node.flags; node = node.parent; } - if (node && node.kind === 181 /* VariableStatement */) { + if (node && node.kind === 183 /* VariableStatement */) { flags |= node.flags; } return flags; @@ -4671,12 +4983,12 @@ var ts; } ts.isLet = isLet; function isPrologueDirective(node) { - return node.kind === 183 /* ExpressionStatement */ && node.expression.kind === 8 /* StringLiteral */; + return node.kind === 185 /* ExpressionStatement */ && node.expression.kind === 8 /* StringLiteral */; } ts.isPrologueDirective = isPrologueDirective; function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { // If parameter/type parameter, the prev token trailing comments are part of this node too - if (node.kind === 130 /* Parameter */ || node.kind === 129 /* TypeParameter */) { + if (node.kind === 131 /* Parameter */ || node.kind === 130 /* TypeParameter */) { // e.g. (/** blah */ a, /** blah */ b); // e.g.: ( // /** blah */ a, @@ -4700,40 +5012,40 @@ var ts; ts.getJsDocComments = getJsDocComments; ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/; function isTypeNode(node) { - if (142 /* FirstTypeNode */ <= node.kind && node.kind <= 150 /* LastTypeNode */) { + if (144 /* FirstTypeNode */ <= node.kind && node.kind <= 152 /* LastTypeNode */) { return true; } switch (node.kind) { case 112 /* AnyKeyword */: - case 120 /* NumberKeyword */: - case 122 /* StringKeyword */: + case 121 /* NumberKeyword */: + case 123 /* StringKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: return true; case 99 /* VoidKeyword */: - return node.parent.kind !== 167 /* VoidExpression */; + return node.parent.kind !== 169 /* VoidExpression */; case 8 /* StringLiteral */: // Specialized signatures can have string literals as their parameters' type names - return node.parent.kind === 130 /* Parameter */; - case 177 /* ExpressionWithTypeArguments */: - return true; + return node.parent.kind === 131 /* Parameter */; + case 179 /* ExpressionWithTypeArguments */: + return !isExpressionWithTypeArgumentsInClassExtendsClause(node); // Identifiers and qualified names may be type nodes, depending on their context. Climb // above them to find the lowest container case 65 /* Identifier */: // If the identifier is the RHS of a qualified name, then it's a type iff its parent is. - if (node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node) { + if (node.parent.kind === 128 /* QualifiedName */ && node.parent.right === node) { node = node.parent; } - else if (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node) { + else if (node.parent.kind === 158 /* PropertyAccessExpression */ && node.parent.name === node) { node = node.parent; } // fall through - case 127 /* QualifiedName */: - case 156 /* PropertyAccessExpression */: + case 128 /* QualifiedName */: + case 158 /* PropertyAccessExpression */: // At this point, node is either a qualified name or an identifier - ts.Debug.assert(node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */ || node.kind === 156 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); + ts.Debug.assert(node.kind === 65 /* Identifier */ || node.kind === 128 /* QualifiedName */ || node.kind === 158 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); var parent_1 = node.parent; - if (parent_1.kind === 145 /* TypeQuery */) { + if (parent_1.kind === 147 /* TypeQuery */) { return false; } // Do not recursively call isTypeNode on the parent. In the example: @@ -4742,38 +5054,38 @@ var ts; // // Calling isTypeNode would consider the qualified name A.B a type node. Only C or // A.B.C is a type node. - if (142 /* FirstTypeNode */ <= parent_1.kind && parent_1.kind <= 150 /* LastTypeNode */) { + if (144 /* FirstTypeNode */ <= parent_1.kind && parent_1.kind <= 152 /* LastTypeNode */) { return true; } switch (parent_1.kind) { - case 177 /* ExpressionWithTypeArguments */: - return true; - case 129 /* TypeParameter */: + case 179 /* ExpressionWithTypeArguments */: + return !isExpressionWithTypeArgumentsInClassExtendsClause(parent_1); + case 130 /* TypeParameter */: return node === parent_1.constraint; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 131 /* Parameter */: + case 201 /* VariableDeclaration */: return node === parent_1.type; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 136 /* Constructor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 137 /* Constructor */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return node === parent_1.type; - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: return node === parent_1.type; - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return node === parent_1.type; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return parent_1.typeArguments && ts.indexOf(parent_1.typeArguments, node) >= 0; - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: // TODO (drosen): TaggedTemplateExpressions may eventually support type arguments. return false; } @@ -4787,23 +5099,23 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: return visitor(node); - case 208 /* CaseBlock */: - case 180 /* Block */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: + case 210 /* CaseBlock */: + case 182 /* Block */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 195 /* WithStatement */: + case 196 /* SwitchStatement */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: + case 197 /* LabeledStatement */: + case 199 /* TryStatement */: + case 226 /* CatchClause */: return ts.forEachChild(node, traverse); } } @@ -4813,17 +5125,17 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: visitor(node); var operand = node.expression; if (operand) { traverse(operand); } - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 202 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 205 /* InterfaceDeclaration */: + case 208 /* ModuleDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 204 /* ClassDeclaration */: // These are not allowed inside a generator now, but eventually they may be allowed // as local types. Regardless, any yield statements contained within them should be // skipped in this traversal. @@ -4831,7 +5143,7 @@ var ts; default: if (isFunctionLike(node)) { var name_4 = node.name; - if (name_4 && name_4.kind === 128 /* ComputedPropertyName */) { + if (name_4 && name_4.kind === 129 /* ComputedPropertyName */) { // Note that we will not include methods/accessors of a class because they would require // first descending into the class. This is by design. traverse(name_4.expression); @@ -4850,14 +5162,14 @@ var ts; function isVariableLike(node) { if (node) { switch (node.kind) { - case 153 /* BindingElement */: - case 227 /* EnumMember */: - case 130 /* Parameter */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 226 /* ShorthandPropertyAssignment */: - case 199 /* VariableDeclaration */: + case 155 /* BindingElement */: + case 229 /* EnumMember */: + case 131 /* Parameter */: + case 227 /* PropertyAssignment */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 228 /* ShorthandPropertyAssignment */: + case 201 /* VariableDeclaration */: return true; } } @@ -4867,8 +5179,8 @@ var ts; function isAccessor(node) { if (node) { switch (node.kind) { - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return true; } } @@ -4877,26 +5189,26 @@ var ts; ts.isAccessor = isAccessor; function isClassLike(node) { if (node) { - return node.kind === 202 /* ClassDeclaration */ || node.kind === 175 /* ClassExpression */; + return node.kind === 204 /* ClassDeclaration */ || node.kind === 177 /* ClassExpression */; } } ts.isClassLike = isClassLike; function isFunctionLike(node) { if (node) { switch (node.kind) { - case 136 /* Constructor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 137 /* Constructor */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return true; } } @@ -4904,11 +5216,11 @@ var ts; } ts.isFunctionLike = isFunctionLike; function isFunctionBlock(node) { - return node && node.kind === 180 /* Block */ && isFunctionLike(node.parent); + return node && node.kind === 182 /* Block */ && isFunctionLike(node.parent); } ts.isFunctionBlock = isFunctionBlock; function isObjectLiteralMethod(node) { - return node && node.kind === 135 /* MethodDeclaration */ && node.parent.kind === 155 /* ObjectLiteralExpression */; + return node && node.kind === 136 /* MethodDeclaration */ && node.parent.kind === 157 /* ObjectLiteralExpression */; } ts.isObjectLiteralMethod = isObjectLiteralMethod; function getContainingFunction(node) { @@ -4927,12 +5239,12 @@ var ts; return undefined; } switch (node.kind) { - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: // If the grandparent node is an object literal (as opposed to a class), // then the computed property is not a 'this' container. // A computed property name in a class needs to be a this container // so that we can error on it. - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.parent.kind === 204 /* ClassDeclaration */) { return node; } // If this is a computed property, then the parent should not @@ -4942,9 +5254,9 @@ var ts; // the *body* of the container. node = node.parent; break; - case 131 /* Decorator */: + case 132 /* Decorator */: // Decorators are always applied outside of the body of a class or method. - if (node.parent.kind === 130 /* Parameter */ && isClassElement(node.parent.parent)) { + if (node.parent.kind === 131 /* Parameter */ && isClassElement(node.parent.parent)) { // If the decorator's parent is a Parameter, we resolve the this container from // the grandparent class declaration. node = node.parent.parent; @@ -4955,23 +5267,23 @@ var ts; node = node.parent; } break; - case 164 /* ArrowFunction */: + case 166 /* ArrowFunction */: if (!includeArrowFunctions) { continue; } // Fall through - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 206 /* ModuleDeclaration */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 205 /* EnumDeclaration */: - case 228 /* SourceFile */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 208 /* ModuleDeclaration */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 207 /* EnumDeclaration */: + case 230 /* SourceFile */: return node; } } @@ -4983,12 +5295,12 @@ var ts; if (!node) return node; switch (node.kind) { - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: // If the grandparent node is an object literal (as opposed to a class), // then the computed property is not a 'super' container. // A computed property name in a class needs to be a super container // so that we can error on it. - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.parent.kind === 204 /* ClassDeclaration */) { return node; } // If this is a computed property, then the parent should not @@ -4998,9 +5310,9 @@ var ts; // the *body* of the container. node = node.parent; break; - case 131 /* Decorator */: + case 132 /* Decorator */: // Decorators are always applied outside of the body of a class or method. - if (node.parent.kind === 130 /* Parameter */ && isClassElement(node.parent.parent)) { + if (node.parent.kind === 131 /* Parameter */ && isClassElement(node.parent.parent)) { // If the decorator's parent is a Parameter, we resolve the this container from // the grandparent class declaration. node = node.parent.parent; @@ -5011,26 +5323,26 @@ var ts; node = node.parent; } break; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: if (!includeFunctions) { continue; } - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return node; } } } ts.getSuperContainer = getSuperContainer; function getInvokedExpression(node) { - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 162 /* TaggedTemplateExpression */) { return node.tag; } // Will either be a CallExpression or NewExpression. @@ -5039,44 +5351,44 @@ var ts; ts.getInvokedExpression = getInvokedExpression; function nodeCanBeDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: // classes are valid targets return true; - case 133 /* PropertyDeclaration */: + case 134 /* PropertyDeclaration */: // property declarations are valid if their parent is a class declaration. - return node.parent.kind === 202 /* ClassDeclaration */; - case 130 /* Parameter */: + return node.parent.kind === 204 /* ClassDeclaration */; + case 131 /* Parameter */: // if the parameter's parent has a body and its grandparent is a class declaration, this is a valid target; - return node.parent.body && node.parent.parent.kind === 202 /* ClassDeclaration */; - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 135 /* MethodDeclaration */: + return node.parent.body && node.parent.parent.kind === 204 /* ClassDeclaration */; + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 136 /* MethodDeclaration */: // if this method has a body and its parent is a class declaration, this is a valid target. - return node.body && node.parent.kind === 202 /* ClassDeclaration */; + return node.body && node.parent.kind === 204 /* ClassDeclaration */; } return false; } ts.nodeCanBeDecorated = nodeCanBeDecorated; function nodeIsDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: if (node.decorators) { return true; } return false; - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 131 /* Parameter */: if (node.decorators) { return true; } return false; - case 137 /* GetAccessor */: + case 138 /* GetAccessor */: if (node.body && node.decorators) { return true; } return false; - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 136 /* MethodDeclaration */: + case 139 /* SetAccessor */: if (node.body && node.decorators) { return true; } @@ -5087,10 +5399,10 @@ var ts; ts.nodeIsDecorated = nodeIsDecorated; function childIsDecorated(node) { switch (node.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return ts.forEach(node.members, nodeOrChildIsDecorated); - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 136 /* MethodDeclaration */: + case 139 /* SetAccessor */: return ts.forEach(node.parameters, nodeIsDecorated); } return false; @@ -5108,38 +5420,38 @@ var ts; case 95 /* TrueKeyword */: case 80 /* FalseKeyword */: case 9 /* RegularExpressionLiteral */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 160 /* TaggedTemplateExpression */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 163 /* FunctionExpression */: - case 175 /* ClassExpression */: - case 164 /* ArrowFunction */: - case 167 /* VoidExpression */: - case 165 /* DeleteExpression */: - case 166 /* TypeOfExpression */: - case 168 /* PrefixUnaryExpression */: - case 169 /* PostfixUnaryExpression */: - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 172 /* TemplateExpression */: + case 156 /* ArrayLiteralExpression */: + case 157 /* ObjectLiteralExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 162 /* TaggedTemplateExpression */: + case 163 /* TypeAssertionExpression */: + case 164 /* ParenthesizedExpression */: + case 165 /* FunctionExpression */: + case 177 /* ClassExpression */: + case 166 /* ArrowFunction */: + case 169 /* VoidExpression */: + case 167 /* DeleteExpression */: + case 168 /* TypeOfExpression */: + case 170 /* PrefixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: + case 172 /* BinaryExpression */: + case 173 /* ConditionalExpression */: + case 176 /* SpreadElementExpression */: + case 174 /* TemplateExpression */: case 10 /* NoSubstitutionTemplateLiteral */: - case 176 /* OmittedExpression */: - case 173 /* YieldExpression */: + case 178 /* OmittedExpression */: + case 175 /* YieldExpression */: return true; - case 127 /* QualifiedName */: - while (node.parent.kind === 127 /* QualifiedName */) { + case 128 /* QualifiedName */: + while (node.parent.kind === 128 /* QualifiedName */) { node = node.parent; } - return node.parent.kind === 145 /* TypeQuery */; + return node.parent.kind === 147 /* TypeQuery */; case 65 /* Identifier */: - if (node.parent.kind === 145 /* TypeQuery */) { + if (node.parent.kind === 147 /* TypeQuery */) { return true; } // fall through @@ -5147,43 +5459,45 @@ var ts; case 8 /* StringLiteral */: var parent_2 = node.parent; switch (parent_2.kind) { - case 199 /* VariableDeclaration */: - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 227 /* EnumMember */: - case 225 /* PropertyAssignment */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 131 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 229 /* EnumMember */: + case 227 /* PropertyAssignment */: + case 155 /* BindingElement */: return parent_2.initializer === node; - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 192 /* ReturnStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 196 /* ThrowStatement */: - case 194 /* SwitchStatement */: + case 185 /* ExpressionStatement */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 194 /* ReturnStatement */: + case 195 /* WithStatement */: + case 196 /* SwitchStatement */: + case 223 /* CaseClause */: + case 198 /* ThrowStatement */: + case 196 /* SwitchStatement */: return parent_2.expression === node; - case 187 /* ForStatement */: + case 189 /* ForStatement */: var forStatement = parent_2; - return (forStatement.initializer === node && forStatement.initializer.kind !== 200 /* VariableDeclarationList */) || + return (forStatement.initializer === node && forStatement.initializer.kind !== 202 /* VariableDeclarationList */) || forStatement.condition === node || forStatement.incrementor === node; - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: var forInStatement = parent_2; - return (forInStatement.initializer === node && forInStatement.initializer.kind !== 200 /* VariableDeclarationList */) || + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 202 /* VariableDeclarationList */) || forInStatement.expression === node; - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return node === parent_2.expression; - case 178 /* TemplateSpan */: + case 180 /* TemplateSpan */: return node === parent_2.expression; - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: return node === parent_2.expression; - case 131 /* Decorator */: + case 132 /* Decorator */: return true; + case 179 /* ExpressionWithTypeArguments */: + return parent_2.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent_2); default: if (isExpression(parent_2)) { return true; @@ -5200,7 +5514,7 @@ var ts; } ts.isInstantiatedModule = isInstantiatedModule; function isExternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 220 /* ExternalModuleReference */; + return node.kind === 211 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 222 /* ExternalModuleReference */; } ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; function getExternalModuleImportEqualsDeclarationExpression(node) { @@ -5209,20 +5523,20 @@ var ts; } ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; function isInternalModuleImportEqualsDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 220 /* ExternalModuleReference */; + return node.kind === 211 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 222 /* ExternalModuleReference */; } ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; function getExternalModuleName(node) { - if (node.kind === 210 /* ImportDeclaration */) { + if (node.kind === 212 /* ImportDeclaration */) { return node.moduleSpecifier; } - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 211 /* ImportEqualsDeclaration */) { var reference = node.moduleReference; - if (reference.kind === 220 /* ExternalModuleReference */) { + if (reference.kind === 222 /* ExternalModuleReference */) { return reference.expression; } } - if (node.kind === 216 /* ExportDeclaration */) { + if (node.kind === 218 /* ExportDeclaration */) { return node.moduleSpecifier; } } @@ -5230,15 +5544,15 @@ var ts; function hasQuestionToken(node) { if (node) { switch (node.kind) { - case 130 /* Parameter */: + case 131 /* Parameter */: return node.questionToken !== undefined; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return node.questionToken !== undefined; - case 226 /* ShorthandPropertyAssignment */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 228 /* ShorthandPropertyAssignment */: + case 227 /* PropertyAssignment */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return node.questionToken !== undefined; } } @@ -5246,9 +5560,9 @@ var ts; } ts.hasQuestionToken = hasQuestionToken; function isJSDocConstructSignature(node) { - return node.kind === 241 /* JSDocFunctionType */ && + return node.kind === 243 /* JSDocFunctionType */ && node.parameters.length > 0 && - node.parameters[0].type.kind === 243 /* JSDocConstructorType */; + node.parameters[0].type.kind === 245 /* JSDocConstructorType */; } ts.isJSDocConstructSignature = isJSDocConstructSignature; function getJSDocTag(node, kind) { @@ -5262,15 +5576,15 @@ var ts; } } function getJSDocTypeTag(node) { - return getJSDocTag(node, 249 /* JSDocTypeTag */); + return getJSDocTag(node, 251 /* JSDocTypeTag */); } ts.getJSDocTypeTag = getJSDocTypeTag; function getJSDocReturnTag(node) { - return getJSDocTag(node, 248 /* JSDocReturnTag */); + return getJSDocTag(node, 250 /* JSDocReturnTag */); } ts.getJSDocReturnTag = getJSDocReturnTag; function getJSDocTemplateTag(node) { - return getJSDocTag(node, 250 /* JSDocTemplateTag */); + return getJSDocTag(node, 252 /* JSDocTemplateTag */); } ts.getJSDocTemplateTag = getJSDocTemplateTag; function getCorrespondingJSDocParameterTag(parameter) { @@ -5281,7 +5595,7 @@ var ts; var docComment = parameter.parent.jsDocComment; if (docComment) { return ts.forEach(docComment.tags, function (t) { - if (t.kind === 247 /* JSDocParameterTag */) { + if (t.kind === 249 /* JSDocParameterTag */) { var parameterTag = t; var name_5 = parameterTag.preParameterName || parameterTag.postParameterName; if (name_5.text === parameterName) { @@ -5300,12 +5614,12 @@ var ts; function isRestParameter(node) { if (node) { if (node.parserContextFlags & 64 /* JavaScriptFile */) { - if (node.type && node.type.kind === 242 /* JSDocVariadicType */) { + if (node.type && node.type.kind === 244 /* JSDocVariadicType */) { return true; } var paramTag = getCorrespondingJSDocParameterTag(node); if (paramTag && paramTag.typeExpression) { - return paramTag.typeExpression.type.kind === 242 /* JSDocVariadicType */; + return paramTag.typeExpression.type.kind === 244 /* JSDocVariadicType */; } } return node.dotDotDotToken !== undefined; @@ -5326,7 +5640,7 @@ var ts; } ts.isTemplateLiteralKind = isTemplateLiteralKind; function isBindingPattern(node) { - return !!node && (node.kind === 152 /* ArrayBindingPattern */ || node.kind === 151 /* ObjectBindingPattern */); + return !!node && (node.kind === 154 /* ArrayBindingPattern */ || node.kind === 153 /* ObjectBindingPattern */); } ts.isBindingPattern = isBindingPattern; function isInAmbientContext(node) { @@ -5341,33 +5655,33 @@ var ts; ts.isInAmbientContext = isInAmbientContext; function isDeclaration(node) { switch (node.kind) { - case 164 /* ArrowFunction */: - case 153 /* BindingElement */: - case 202 /* ClassDeclaration */: - case 136 /* Constructor */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 218 /* ExportSpecifier */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 137 /* GetAccessor */: - case 211 /* ImportClause */: - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 203 /* InterfaceDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 206 /* ModuleDeclaration */: - case 212 /* NamespaceImport */: - case 130 /* Parameter */: - case 225 /* PropertyAssignment */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 138 /* SetAccessor */: - case 226 /* ShorthandPropertyAssignment */: - case 204 /* TypeAliasDeclaration */: - case 129 /* TypeParameter */: - case 199 /* VariableDeclaration */: + case 166 /* ArrowFunction */: + case 155 /* BindingElement */: + case 204 /* ClassDeclaration */: + case 137 /* Constructor */: + case 207 /* EnumDeclaration */: + case 229 /* EnumMember */: + case 220 /* ExportSpecifier */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 138 /* GetAccessor */: + case 213 /* ImportClause */: + case 211 /* ImportEqualsDeclaration */: + case 216 /* ImportSpecifier */: + case 205 /* InterfaceDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 208 /* ModuleDeclaration */: + case 214 /* NamespaceImport */: + case 131 /* Parameter */: + case 227 /* PropertyAssignment */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 139 /* SetAccessor */: + case 228 /* ShorthandPropertyAssignment */: + case 206 /* TypeAliasDeclaration */: + case 130 /* TypeParameter */: + case 201 /* VariableDeclaration */: return true; } return false; @@ -5375,25 +5689,25 @@ var ts; ts.isDeclaration = isDeclaration; function isStatement(n) { switch (n.kind) { - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 198 /* DebuggerStatement */: - case 185 /* DoStatement */: - case 183 /* ExpressionStatement */: - case 182 /* EmptyStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 184 /* IfStatement */: - case 195 /* LabeledStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: + case 193 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 200 /* DebuggerStatement */: + case 187 /* DoStatement */: + case 185 /* ExpressionStatement */: + case 184 /* EmptyStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 189 /* ForStatement */: + case 186 /* IfStatement */: + case 197 /* LabeledStatement */: + case 194 /* ReturnStatement */: + case 196 /* SwitchStatement */: case 94 /* ThrowKeyword */: - case 197 /* TryStatement */: - case 181 /* VariableStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 215 /* ExportAssignment */: + case 199 /* TryStatement */: + case 183 /* VariableStatement */: + case 188 /* WhileStatement */: + case 195 /* WithStatement */: + case 217 /* ExportAssignment */: return true; default: return false; @@ -5402,13 +5716,13 @@ var ts; ts.isStatement = isStatement; function isClassElement(n) { switch (n.kind) { - case 136 /* Constructor */: - case 133 /* PropertyDeclaration */: - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: + case 137 /* Constructor */: + case 134 /* PropertyDeclaration */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 135 /* MethodSignature */: + case 142 /* IndexSignature */: return true; default: return false; @@ -5421,7 +5735,7 @@ var ts; return false; } var parent = name.parent; - if (parent.kind === 214 /* ImportSpecifier */ || parent.kind === 218 /* ExportSpecifier */) { + if (parent.kind === 216 /* ImportSpecifier */ || parent.kind === 220 /* ExportSpecifier */) { if (parent.propertyName) { return true; } @@ -5432,6 +5746,41 @@ var ts; return false; } ts.isDeclarationName = isDeclarationName; + // Return true if the given identifier is classified as an IdentifierName + function isIdentifierName(node) { + var parent = node.parent; + switch (parent.kind) { + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 229 /* EnumMember */: + case 227 /* PropertyAssignment */: + case 158 /* PropertyAccessExpression */: + // Name in member declaration or property name in property access + return parent.name === node; + case 128 /* QualifiedName */: + // Name on right hand side of dot in a type query + if (parent.right === node) { + while (parent.kind === 128 /* QualifiedName */) { + parent = parent.parent; + } + return parent.kind === 147 /* TypeQuery */; + } + return false; + case 155 /* BindingElement */: + case 216 /* ImportSpecifier */: + // Property name in binding element or import specifier + return parent.propertyName === node; + case 220 /* ExportSpecifier */: + // Any name in an export specifier + return true; + } + return false; + } + ts.isIdentifierName = isIdentifierName; // An alias symbol is created by one of the following declarations: // import = ... // import from ... @@ -5441,12 +5790,12 @@ var ts; // export = ... // export default ... function isAliasSymbolDeclaration(node) { - return node.kind === 209 /* ImportEqualsDeclaration */ || - node.kind === 211 /* ImportClause */ && !!node.name || - node.kind === 212 /* NamespaceImport */ || - node.kind === 214 /* ImportSpecifier */ || - node.kind === 218 /* ExportSpecifier */ || - node.kind === 215 /* ExportAssignment */ && node.expression.kind === 65 /* Identifier */; + return node.kind === 211 /* ImportEqualsDeclaration */ || + node.kind === 213 /* ImportClause */ && !!node.name || + node.kind === 214 /* NamespaceImport */ || + node.kind === 216 /* ImportSpecifier */ || + node.kind === 220 /* ExportSpecifier */ || + node.kind === 217 /* ExportAssignment */ && node.expression.kind === 65 /* Identifier */; } ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration; function getClassExtendsHeritageClauseElement(node) { @@ -5529,7 +5878,7 @@ var ts; } ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; function isKeyword(token) { - return 66 /* FirstKeyword */ <= token && token <= 126 /* LastKeyword */; + return 66 /* FirstKeyword */ <= token && token <= 127 /* LastKeyword */; } ts.isKeyword = isKeyword; function isTrivia(token) { @@ -5545,7 +5894,7 @@ var ts; */ function hasDynamicName(declaration) { return declaration.name && - declaration.name.kind === 128 /* ComputedPropertyName */ && + declaration.name.kind === 129 /* ComputedPropertyName */ && !isWellKnownSymbolSyntactically(declaration.name.expression); } ts.hasDynamicName = hasDynamicName; @@ -5555,14 +5904,14 @@ var ts; * where Symbol is literally the word "Symbol", and name is any identifierName */ function isWellKnownSymbolSyntactically(node) { - return node.kind === 156 /* PropertyAccessExpression */ && isESSymbolIdentifier(node.expression); + return node.kind === 158 /* PropertyAccessExpression */ && isESSymbolIdentifier(node.expression); } ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; function getPropertyNameForPropertyNameNode(name) { if (name.kind === 65 /* Identifier */ || name.kind === 8 /* StringLiteral */ || name.kind === 7 /* NumericLiteral */) { return name.text; } - if (name.kind === 128 /* ComputedPropertyName */) { + if (name.kind === 129 /* ComputedPropertyName */) { var nameExpression = name.expression; if (isWellKnownSymbolSyntactically(nameExpression)) { var rightHandSideName = nameExpression.name.text; @@ -5600,18 +5949,18 @@ var ts; ts.isModifier = isModifier; function isParameterDeclaration(node) { var root = getRootDeclaration(node); - return root.kind === 130 /* Parameter */; + return root.kind === 131 /* Parameter */; } ts.isParameterDeclaration = isParameterDeclaration; function getRootDeclaration(node) { - while (node.kind === 153 /* BindingElement */) { + while (node.kind === 155 /* BindingElement */) { node = node.parent.parent; } return node; } ts.getRootDeclaration = getRootDeclaration; function nodeStartsNewLexicalEnvironment(n) { - return isFunctionLike(n) || n.kind === 206 /* ModuleDeclaration */ || n.kind === 228 /* SourceFile */; + return isFunctionLike(n) || n.kind === 208 /* ModuleDeclaration */ || n.kind === 230 /* SourceFile */; } ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment; function nodeIsSynthesized(node) { @@ -5847,7 +6196,7 @@ var ts; ts.getLineOfLocalPosition = getLineOfLocalPosition; function getFirstConstructorWithBody(node) { return ts.forEach(node.members, function (member) { - if (member.kind === 136 /* Constructor */ && nodeIsPresent(member.body)) { + if (member.kind === 137 /* Constructor */ && nodeIsPresent(member.body)) { return member; } }); @@ -5872,10 +6221,10 @@ var ts; var setAccessor; if (hasDynamicName(accessor)) { firstAccessor = accessor; - if (accessor.kind === 137 /* GetAccessor */) { + if (accessor.kind === 138 /* GetAccessor */) { getAccessor = accessor; } - else if (accessor.kind === 138 /* SetAccessor */) { + else if (accessor.kind === 139 /* SetAccessor */) { setAccessor = accessor; } else { @@ -5884,7 +6233,7 @@ var ts; } else { ts.forEach(declarations, function (member) { - if ((member.kind === 137 /* GetAccessor */ || member.kind === 138 /* SetAccessor */) + if ((member.kind === 138 /* GetAccessor */ || member.kind === 139 /* SetAccessor */) && (member.flags & 128 /* Static */) === (accessor.flags & 128 /* Static */)) { var memberName = getPropertyNameForPropertyNameNode(member.name); var accessorName = getPropertyNameForPropertyNameNode(accessor.name); @@ -5895,10 +6244,10 @@ var ts; else if (!secondAccessor) { secondAccessor = member; } - if (member.kind === 137 /* GetAccessor */ && !getAccessor) { + if (member.kind === 138 /* GetAccessor */ && !getAccessor) { getAccessor = member; } - if (member.kind === 138 /* SetAccessor */ && !setAccessor) { + if (member.kind === 139 /* SetAccessor */ && !setAccessor) { setAccessor = member; } } @@ -6046,22 +6395,22 @@ var ts; function isLeftHandSideExpression(expr) { if (expr) { switch (expr.kind) { - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 159 /* NewExpression */: - case 158 /* CallExpression */: - case 160 /* TaggedTemplateExpression */: - case 154 /* ArrayLiteralExpression */: - case 162 /* ParenthesizedExpression */: - case 155 /* ObjectLiteralExpression */: - case 175 /* ClassExpression */: - case 163 /* FunctionExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 161 /* NewExpression */: + case 160 /* CallExpression */: + case 162 /* TaggedTemplateExpression */: + case 156 /* ArrayLiteralExpression */: + case 164 /* ParenthesizedExpression */: + case 157 /* ObjectLiteralExpression */: + case 177 /* ClassExpression */: + case 165 /* FunctionExpression */: case 65 /* Identifier */: case 9 /* RegularExpressionLiteral */: case 7 /* NumericLiteral */: case 8 /* StringLiteral */: case 10 /* NoSubstitutionTemplateLiteral */: - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: case 80 /* FalseKeyword */: case 89 /* NullKeyword */: case 93 /* ThisKeyword */: @@ -6077,6 +6426,12 @@ var ts; return token >= 53 /* FirstAssignment */ && token <= 64 /* LastAssignment */; } ts.isAssignmentOperator = isAssignmentOperator; + function isExpressionWithTypeArgumentsInClassExtendsClause(node) { + return node.kind === 179 /* ExpressionWithTypeArguments */ && + node.parent.token === 79 /* ExtendsKeyword */ && + node.parent.parent.kind === 204 /* ClassDeclaration */; + } + ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; // Returns false if this heritage clause element's expression contains something unsupported // (i.e. not a name or dotted name). function isSupportedExpressionWithTypeArguments(node) { @@ -6087,7 +6442,7 @@ var ts; if (node.kind === 65 /* Identifier */) { return true; } - else if (node.kind === 156 /* PropertyAccessExpression */) { + else if (node.kind === 158 /* PropertyAccessExpression */) { return isSupportedExpressionWithTypeArgumentsRest(node.expression); } else { @@ -6095,8 +6450,8 @@ var ts; } } function isRightSideOfQualifiedNameOrPropertyAccess(node) { - return (node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node) || - (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node); + return (node.parent.kind === 128 /* QualifiedName */ && node.parent.right === node) || + (node.parent.kind === 158 /* PropertyAccessExpression */ && node.parent.name === node); } ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess; function getLocalSymbolForExportDefault(symbol) { @@ -6237,6 +6592,12 @@ var ts; return start <= textSpanEnd(span) && end >= span.start; } ts.textSpanIntersectsWith = textSpanIntersectsWith; + function decodedTextSpanIntersectsWith(start1, length1, start2, length2) { + var end1 = start1 + length1; + var end2 = start2 + length2; + return start2 <= end1 && end2 >= start1; + } + ts.decodedTextSpanIntersectsWith = decodedTextSpanIntersectsWith; function textSpanIntersectsWithPosition(span, position) { return position <= textSpanEnd(span) && position >= span.start; } @@ -6396,9 +6757,9 @@ var ts; } ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions; function getTypeParameterOwner(d) { - if (d && d.kind === 129 /* TypeParameter */) { + if (d && d.kind === 130 /* TypeParameter */) { for (var current = d; current; current = current.parent) { - if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 203 /* InterfaceDeclaration */) { + if (ts.isFunctionLike(current) || ts.isClassLike(current) || current.kind === 205 /* InterfaceDeclaration */) { return current; } } @@ -6410,7 +6771,7 @@ var ts; /// var ts; (function (ts) { - var nodeConstructors = new Array(252 /* Count */); + var nodeConstructors = new Array(254 /* Count */); /* @internal */ ts.parseTime = 0; function getNodeConstructor(kind) { return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); @@ -6455,20 +6816,20 @@ var ts; var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; var cbNodes = cbNodeArray || cbNode; switch (node.kind) { - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); - case 129 /* TypeParameter */: + case 130 /* TypeParameter */: return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 131 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 227 /* PropertyAssignment */: + case 228 /* ShorthandPropertyAssignment */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || @@ -6477,24 +6838,24 @@ var ts; visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || @@ -6505,263 +6866,267 @@ var ts; visitNode(cbNode, node.type) || visitNode(cbNode, node.equalsGreaterThanToken) || visitNode(cbNode, node.body); - case 142 /* TypeReference */: + case 144 /* TypeReference */: return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); - case 145 /* TypeQuery */: + case 143 /* TypePredicate */: + return visitNode(cbNode, node.parameterName) || + visitNode(cbNode, node.type); + case 147 /* TypeQuery */: return visitNode(cbNode, node.exprName); - case 146 /* TypeLiteral */: + case 148 /* TypeLiteral */: return visitNodes(cbNodes, node.members); - case 147 /* ArrayType */: + case 149 /* ArrayType */: return visitNode(cbNode, node.elementType); - case 148 /* TupleType */: + case 150 /* TupleType */: return visitNodes(cbNodes, node.elementTypes); - case 149 /* UnionType */: + case 151 /* UnionType */: return visitNodes(cbNodes, node.types); - case 150 /* ParenthesizedType */: + case 152 /* ParenthesizedType */: return visitNode(cbNode, node.type); - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: return visitNodes(cbNodes, node.elements); - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return visitNodes(cbNodes, node.elements); - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return visitNodes(cbNodes, node.properties); - case 156 /* PropertyAccessExpression */: + case 158 /* PropertyAccessExpression */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.dotToken) || visitNode(cbNode, node.name); - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return visitNode(cbNode, node.expression); - case 165 /* DeleteExpression */: + case 167 /* DeleteExpression */: return visitNode(cbNode, node.expression); - case 166 /* TypeOfExpression */: + case 168 /* TypeOfExpression */: return visitNode(cbNode, node.expression); - case 167 /* VoidExpression */: + case 169 /* VoidExpression */: return visitNode(cbNode, node.expression); - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: return visitNode(cbNode, node.operand); - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); - case 169 /* PostfixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: return visitNode(cbNode, node.operand); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return visitNode(cbNode, node.condition) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.colonToken) || visitNode(cbNode, node.whenFalse); - case 174 /* SpreadElementExpression */: + case 176 /* SpreadElementExpression */: return visitNode(cbNode, node.expression); - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return visitNodes(cbNodes, node.statements); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); - case 200 /* VariableDeclarationList */: + case 202 /* VariableDeclarationList */: return visitNodes(cbNodes, node.declarations); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: return visitNode(cbNode, node.expression); - case 184 /* IfStatement */: + case 186 /* IfStatement */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); - case 185 /* DoStatement */: + case 187 /* DoStatement */: return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); - case 186 /* WhileStatement */: + case 188 /* WhileStatement */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 187 /* ForStatement */: + case 189 /* ForStatement */: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.incrementor) || visitNode(cbNode, node.statement); - case 188 /* ForInStatement */: + case 190 /* ForInStatement */: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 189 /* ForOfStatement */: + case 191 /* ForOfStatement */: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 193 /* BreakStatement */: return visitNode(cbNode, node.label); - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: return visitNode(cbNode, node.expression); - case 193 /* WithStatement */: + case 195 /* WithStatement */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.caseBlock); - case 208 /* CaseBlock */: + case 210 /* CaseBlock */: return visitNodes(cbNodes, node.clauses); - case 221 /* CaseClause */: + case 223 /* CaseClause */: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.statements); - case 222 /* DefaultClause */: + case 224 /* DefaultClause */: return visitNodes(cbNodes, node.statements); - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return visitNode(cbNode, node.label) || visitNode(cbNode, node.statement); - case 196 /* ThrowStatement */: + case 198 /* ThrowStatement */: return visitNode(cbNode, node.expression); - case 197 /* TryStatement */: + case 199 /* TryStatement */: return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return visitNode(cbNode, node.variableDeclaration) || visitNode(cbNode, node.block); - case 131 /* Decorator */: + case 132 /* Decorator */: return visitNode(cbNode, node.expression); - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || visitNode(cbNode, node.type); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.members); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.body); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.importClause) || visitNode(cbNode, node.moduleSpecifier); - case 211 /* ImportClause */: + case 213 /* ImportClause */: return visitNode(cbNode, node.name) || visitNode(cbNode, node.namedBindings); - case 212 /* NamespaceImport */: + case 214 /* NamespaceImport */: return visitNode(cbNode, node.name); - case 213 /* NamedImports */: - case 217 /* NamedExports */: + case 215 /* NamedImports */: + case 219 /* NamedExports */: return visitNodes(cbNodes, node.elements); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportClause) || visitNode(cbNode, node.moduleSpecifier); - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 216 /* ImportSpecifier */: + case 220 /* ExportSpecifier */: return visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.name); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return visitNodes(cbNodes, node.decorators) || visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.expression); - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); - case 178 /* TemplateSpan */: + case 180 /* TemplateSpan */: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: return visitNode(cbNode, node.expression); - case 223 /* HeritageClause */: + case 225 /* HeritageClause */: return visitNodes(cbNodes, node.types); - case 177 /* ExpressionWithTypeArguments */: + case 179 /* ExpressionWithTypeArguments */: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments); - case 220 /* ExternalModuleReference */: + case 222 /* ExternalModuleReference */: return visitNode(cbNode, node.expression); - case 219 /* MissingDeclaration */: + case 221 /* MissingDeclaration */: return visitNodes(cbNodes, node.decorators); - case 229 /* JSDocTypeExpression */: + case 231 /* JSDocTypeExpression */: return visitNode(cbNode, node.type); - case 233 /* JSDocUnionType */: + case 235 /* JSDocUnionType */: return visitNodes(cbNodes, node.types); - case 234 /* JSDocTupleType */: + case 236 /* JSDocTupleType */: return visitNodes(cbNodes, node.types); - case 232 /* JSDocArrayType */: + case 234 /* JSDocArrayType */: return visitNode(cbNode, node.elementType); - case 236 /* JSDocNonNullableType */: + case 238 /* JSDocNonNullableType */: return visitNode(cbNode, node.type); - case 235 /* JSDocNullableType */: + case 237 /* JSDocNullableType */: return visitNode(cbNode, node.type); - case 237 /* JSDocRecordType */: + case 239 /* JSDocRecordType */: return visitNodes(cbNodes, node.members); - case 239 /* JSDocTypeReference */: + case 241 /* JSDocTypeReference */: return visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeArguments); - case 240 /* JSDocOptionalType */: + case 242 /* JSDocOptionalType */: return visitNode(cbNode, node.type); - case 241 /* JSDocFunctionType */: + case 243 /* JSDocFunctionType */: return visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 242 /* JSDocVariadicType */: + case 244 /* JSDocVariadicType */: return visitNode(cbNode, node.type); - case 243 /* JSDocConstructorType */: + case 245 /* JSDocConstructorType */: return visitNode(cbNode, node.type); - case 244 /* JSDocThisType */: + case 246 /* JSDocThisType */: return visitNode(cbNode, node.type); - case 238 /* JSDocRecordMember */: + case 240 /* JSDocRecordMember */: return visitNode(cbNode, node.name) || visitNode(cbNode, node.type); - case 245 /* JSDocComment */: + case 247 /* JSDocComment */: return visitNodes(cbNodes, node.tags); - case 247 /* JSDocParameterTag */: + case 249 /* JSDocParameterTag */: return visitNode(cbNode, node.preParameterName) || visitNode(cbNode, node.typeExpression) || visitNode(cbNode, node.postParameterName); - case 248 /* JSDocReturnTag */: + case 250 /* JSDocReturnTag */: return visitNode(cbNode, node.typeExpression); - case 249 /* JSDocTypeTag */: + case 251 /* JSDocTypeTag */: return visitNode(cbNode, node.typeExpression); - case 250 /* JSDocTemplateTag */: + case 252 /* JSDocTemplateTag */: return visitNodes(cbNodes, node.typeParameters); } } @@ -6891,13 +7256,6 @@ var ts; // Note: any errors at the end of the file that do not precede a regular node, should get // attached to the EOF token. var parseErrorBeforeNextFinishedNode = false; - (function (StatementFlags) { - StatementFlags[StatementFlags["None"] = 0] = "None"; - StatementFlags[StatementFlags["Statement"] = 1] = "Statement"; - StatementFlags[StatementFlags["ModuleElement"] = 2] = "ModuleElement"; - StatementFlags[StatementFlags["StatementOrModuleElement"] = 3] = "StatementOrModuleElement"; - })(Parser.StatementFlags || (Parser.StatementFlags = {})); - var StatementFlags = Parser.StatementFlags; function parseSourceFile(fileName, _sourceText, languageVersion, _syntaxCursor, setParentNodes) { initializeState(fileName, _sourceText, languageVersion, _syntaxCursor); var result = parseSourceFileWorker(fileName, languageVersion, setParentNodes); @@ -6936,7 +7294,7 @@ var ts; // Prime the scanner. token = nextToken(); processReferenceComments(sourceFile); - sourceFile.statements = parseList(0 /* SourceElements */, true, parseSourceElement); + sourceFile.statements = parseList(0 /* SourceElements */, parseStatement); ts.Debug.assert(token === 1 /* EndOfFileToken */); sourceFile.endOfFileToken = parseTokenNode(); setExternalModuleIndicator(sourceFile); @@ -6962,9 +7320,9 @@ var ts; // Add additional cases as necessary depending on how we see JSDoc comments used // in the wild. switch (node.kind) { - case 181 /* VariableStatement */: - case 201 /* FunctionDeclaration */: - case 130 /* Parameter */: + case 183 /* VariableStatement */: + case 203 /* FunctionDeclaration */: + case 131 /* Parameter */: addJSDocComment(node); } forEachChild(node, visit); @@ -7005,7 +7363,7 @@ var ts; } Parser.fixupParentReferences = fixupParentReferences; function createSourceFile(fileName, languageVersion) { - var sourceFile = createNode(228 /* SourceFile */, 0); + var sourceFile = createNode(230 /* SourceFile */, 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; sourceFile.text = sourceText; @@ -7023,9 +7381,6 @@ var ts; contextFlags &= ~flag; } } - function setStrictModeContext(val) { - setContextFlag(val, 1 /* StrictMode */); - } function setDisallowInContext(val) { setContextFlag(val, 2 /* DisallowIn */); } @@ -7102,9 +7457,6 @@ var ts; function inYieldContext() { return (contextFlags & 4 /* Yield */) !== 0; } - function inStrictModeContext() { - return (contextFlags & 1 /* StrictMode */) !== 0; - } function inGeneratorParameterContext() { return (contextFlags & 8 /* GeneratorParameter */) !== 0; } @@ -7356,7 +7708,7 @@ var ts; // ComputedPropertyName[Yield] : // [ AssignmentExpression[In, ?Yield] ] // - var node = createNode(128 /* ComputedPropertyName */); + var node = createNode(129 /* ComputedPropertyName */); parseExpected(18 /* OpenBracketToken */); // We parse any expression (including a comma expression). But the grammar // says that only an assignment expression is allowed, so the grammar checker @@ -7414,37 +7766,34 @@ var ts; } switch (parsingContext) { case 0 /* SourceElements */: - case 1 /* ModuleElements */: + case 1 /* BlockStatements */: + case 3 /* SwitchClauseStatements */: // If we're in error recovery, then we don't want to treat ';' as an empty statement. // The problem is that ';' can show up in far too many contexts, and if we see one // and assume it's a statement, then we may bail out inappropriately from whatever // we're parsing. For example, if we have a semicolon in the middle of a class, then // we really don't want to assume the class is over and we're on a statement in the // outer module. We just want to consume and move on. - return !(token === 22 /* SemicolonToken */ && inErrorRecovery) && isStartOfModuleElement(); - case 2 /* BlockStatements */: - case 4 /* SwitchClauseStatements */: - // During error recovery we don't treat empty statements as statements return !(token === 22 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement(); - case 3 /* SwitchClauses */: + case 2 /* SwitchClauses */: return token === 67 /* CaseKeyword */ || token === 73 /* DefaultKeyword */; - case 5 /* TypeMembers */: + case 4 /* TypeMembers */: return isStartOfTypeMember(); - case 6 /* ClassMembers */: + case 5 /* ClassMembers */: // We allow semicolons as class elements (as specified by ES6) as long as we're // not in error recovery. If we're in error recovery, we don't want an errant // semicolon to be treated as a class member (since they're almost always used // for statements. return lookAhead(isClassMemberStart) || (token === 22 /* SemicolonToken */ && !inErrorRecovery); - case 7 /* EnumMembers */: + case 6 /* EnumMembers */: // Include open bracket computed properties. This technically also lets in indexers, // which would be a candidate for improved error reporting. return token === 18 /* OpenBracketToken */ || isLiteralPropertyName(); - case 13 /* ObjectLiteralMembers */: + case 12 /* ObjectLiteralMembers */: return token === 18 /* OpenBracketToken */ || token === 35 /* AsteriskToken */ || isLiteralPropertyName(); - case 10 /* ObjectBindingElements */: + case 9 /* ObjectBindingElements */: return isLiteralPropertyName(); - case 8 /* HeritageClauseElement */: + case 7 /* HeritageClauseElement */: // If we see { } then only consume it as an expression if it is followed by , or { // That way we won't consume the body of a class in its heritage clause. if (token === 14 /* OpenBraceToken */) { @@ -7459,29 +7808,29 @@ var ts; // element during recovery. return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword(); } - case 9 /* VariableDeclarations */: + case 8 /* VariableDeclarations */: return isIdentifierOrPattern(); - case 11 /* ArrayBindingElements */: + case 10 /* ArrayBindingElements */: return token === 23 /* CommaToken */ || token === 21 /* DotDotDotToken */ || isIdentifierOrPattern(); - case 16 /* TypeParameters */: + case 15 /* TypeParameters */: return isIdentifier(); - case 12 /* ArgumentExpressions */: - case 14 /* ArrayLiteralMembers */: + case 11 /* ArgumentExpressions */: + case 13 /* ArrayLiteralMembers */: return token === 23 /* CommaToken */ || token === 21 /* DotDotDotToken */ || isStartOfExpression(); - case 15 /* Parameters */: + case 14 /* Parameters */: return isStartOfParameter(); - case 17 /* TypeArguments */: - case 18 /* TupleElementTypes */: + case 16 /* TypeArguments */: + case 17 /* TupleElementTypes */: return token === 23 /* CommaToken */ || isStartOfType(); - case 19 /* HeritageClauses */: + case 18 /* HeritageClauses */: return isHeritageClause(); - case 20 /* ImportOrExportSpecifiers */: + case 19 /* ImportOrExportSpecifiers */: return isIdentifierOrKeyword(); - case 21 /* JSDocFunctionParameters */: - case 22 /* JSDocTypeArguments */: - case 24 /* JSDocTupleTypes */: + case 20 /* JSDocFunctionParameters */: + case 21 /* JSDocTypeArguments */: + case 23 /* JSDocTupleTypes */: return JSDocParser.isJSDocType(); - case 23 /* JSDocRecordMembers */: + case 22 /* JSDocRecordMembers */: return isSimplePropertyName(); } ts.Debug.fail("Non-exhaustive case in 'isListElement'."); @@ -7523,47 +7872,46 @@ var ts; return true; } switch (kind) { - case 1 /* ModuleElements */: - case 2 /* BlockStatements */: - case 3 /* SwitchClauses */: - case 5 /* TypeMembers */: - case 6 /* ClassMembers */: - case 7 /* EnumMembers */: - case 13 /* ObjectLiteralMembers */: - case 10 /* ObjectBindingElements */: - case 20 /* ImportOrExportSpecifiers */: + case 1 /* BlockStatements */: + case 2 /* SwitchClauses */: + case 4 /* TypeMembers */: + case 5 /* ClassMembers */: + case 6 /* EnumMembers */: + case 12 /* ObjectLiteralMembers */: + case 9 /* ObjectBindingElements */: + case 19 /* ImportOrExportSpecifiers */: return token === 15 /* CloseBraceToken */; - case 4 /* SwitchClauseStatements */: + case 3 /* SwitchClauseStatements */: return token === 15 /* CloseBraceToken */ || token === 67 /* CaseKeyword */ || token === 73 /* DefaultKeyword */; - case 8 /* HeritageClauseElement */: + case 7 /* HeritageClauseElement */: return token === 14 /* OpenBraceToken */ || token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; - case 9 /* VariableDeclarations */: + case 8 /* VariableDeclarations */: return isVariableDeclaratorListTerminator(); - case 16 /* TypeParameters */: + case 15 /* TypeParameters */: // Tokens other than '>' are here for better error recovery return token === 25 /* GreaterThanToken */ || token === 16 /* OpenParenToken */ || token === 14 /* OpenBraceToken */ || token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; - case 12 /* ArgumentExpressions */: + case 11 /* ArgumentExpressions */: // Tokens other than ')' are here for better error recovery return token === 17 /* CloseParenToken */ || token === 22 /* SemicolonToken */; - case 14 /* ArrayLiteralMembers */: - case 18 /* TupleElementTypes */: - case 11 /* ArrayBindingElements */: + case 13 /* ArrayLiteralMembers */: + case 17 /* TupleElementTypes */: + case 10 /* ArrayBindingElements */: return token === 19 /* CloseBracketToken */; - case 15 /* Parameters */: + case 14 /* Parameters */: // Tokens other than ')' and ']' (the latter for index signatures) are here for better error recovery return token === 17 /* CloseParenToken */ || token === 19 /* CloseBracketToken */ /*|| token === SyntaxKind.OpenBraceToken*/; - case 17 /* TypeArguments */: + case 16 /* TypeArguments */: // Tokens other than '>' are here for better error recovery return token === 25 /* GreaterThanToken */ || token === 16 /* OpenParenToken */; - case 19 /* HeritageClauses */: + case 18 /* HeritageClauses */: return token === 14 /* OpenBraceToken */ || token === 15 /* CloseBraceToken */; - case 21 /* JSDocFunctionParameters */: + case 20 /* JSDocFunctionParameters */: return token === 17 /* CloseParenToken */ || token === 51 /* ColonToken */ || token === 15 /* CloseBraceToken */; - case 22 /* JSDocTypeArguments */: + case 21 /* JSDocTypeArguments */: return token === 25 /* GreaterThanToken */ || token === 15 /* CloseBraceToken */; - case 24 /* JSDocTupleTypes */: + case 23 /* JSDocTupleTypes */: return token === 19 /* CloseBracketToken */ || token === 15 /* CloseBraceToken */; - case 23 /* JSDocRecordMembers */: + case 22 /* JSDocRecordMembers */: return token === 15 /* CloseBraceToken */; } } @@ -7590,7 +7938,7 @@ var ts; } // True if positioned at element or terminator of the current list or any enclosing list function isInSomeParsingContext() { - for (var kind = 0; kind < 25 /* Count */; kind++) { + for (var kind = 0; kind < 24 /* Count */; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, true) || isListTerminator(kind)) { return true; @@ -7600,47 +7948,25 @@ var ts; return false; } // Parses a list of elements - function parseList(kind, checkForStrictMode, parseElement) { + function parseList(kind, parseElement) { var saveParsingContext = parsingContext; parsingContext |= 1 << kind; var result = []; result.pos = getNodePos(); - var savedStrictModeContext = inStrictModeContext(); while (!isListTerminator(kind)) { if (isListElement(kind, false)) { var element = parseListElement(kind, parseElement); result.push(element); - // test elements only if we are not already in strict mode - if (checkForStrictMode && !inStrictModeContext()) { - if (ts.isPrologueDirective(element)) { - if (isUseStrictPrologueDirective(element)) { - setStrictModeContext(true); - checkForStrictMode = false; - } - } - else { - checkForStrictMode = false; - } - } continue; } if (abortParsingListOrMoveToNextToken(kind)) { break; } } - setStrictModeContext(savedStrictModeContext); result.end = getNodeEnd(); parsingContext = saveParsingContext; return result; } - /// Should be called only on prologue directives (isPrologueDirective(node) should be true) - function isUseStrictPrologueDirective(node) { - ts.Debug.assert(ts.isPrologueDirective(node)); - var nodeText = ts.getTextOfNodeFromSourceText(sourceText, node.expression); - // Note: the node text must be exactly "use strict" or 'use strict'. It is not ok for the - // string to contain unicode escapes (as per ES5). - return nodeText === '"use strict"' || nodeText === "'use strict'"; - } function parseListElement(parsingContext, parseElement) { var node = currentNode(parsingContext); if (node) { @@ -7688,7 +8014,7 @@ var ts; // differently depending on what mode it is in. // // This also applies to all our other context flags as well. - var nodeContextFlags = node.parserContextFlags & 63 /* ParserGeneratedFlags */; + var nodeContextFlags = node.parserContextFlags & 62 /* ParserGeneratedFlags */; if (nodeContextFlags !== contextFlags) { return undefined; } @@ -7707,37 +8033,36 @@ var ts; } function canReuseNode(node, parsingContext) { switch (parsingContext) { - case 1 /* ModuleElements */: - return isReusableModuleElement(node); - case 6 /* ClassMembers */: + case 5 /* ClassMembers */: return isReusableClassMember(node); - case 3 /* SwitchClauses */: + case 2 /* SwitchClauses */: return isReusableSwitchClause(node); - case 2 /* BlockStatements */: - case 4 /* SwitchClauseStatements */: + case 0 /* SourceElements */: + case 1 /* BlockStatements */: + case 3 /* SwitchClauseStatements */: return isReusableStatement(node); - case 7 /* EnumMembers */: + case 6 /* EnumMembers */: return isReusableEnumMember(node); - case 5 /* TypeMembers */: + case 4 /* TypeMembers */: return isReusableTypeMember(node); - case 9 /* VariableDeclarations */: + case 8 /* VariableDeclarations */: return isReusableVariableDeclaration(node); - case 15 /* Parameters */: + case 14 /* Parameters */: return isReusableParameter(node); // Any other lists we do not care about reusing nodes in. But feel free to add if // you can do so safely. Danger areas involve nodes that may involve speculative // parsing. If speculative parsing is involved with the node, then the range the // parser reached while looking ahead might be in the edited range (see the example // in canReuseVariableDeclaratorNode for a good case of this). - case 19 /* HeritageClauses */: + case 18 /* HeritageClauses */: // This would probably be safe to reuse. There is no speculative parsing with // heritage clauses. - case 16 /* TypeParameters */: + case 15 /* TypeParameters */: // This would probably be safe to reuse. There is no speculative parsing with // type parameters. Note that that's because type *parameters* only occur in // unambiguous *type* contexts. While type *arguments* occur in very ambiguous // *expression* contexts. - case 18 /* TupleElementTypes */: + case 17 /* TupleElementTypes */: // This would probably be safe to reuse. There is no speculative parsing with // tuple types. // Technically, type argument list types are probably safe to reuse. While @@ -7745,51 +8070,41 @@ var ts; // produced from speculative parsing a < as a type argument list), we only have // the types because speculative parsing succeeded. Thus, the lookahead never // went past the end of the list and rewound. - case 17 /* TypeArguments */: + case 16 /* TypeArguments */: // Note: these are almost certainly not safe to ever reuse. Expressions commonly // need a large amount of lookahead, and we should not reuse them as they may // have actually intersected the edit. - case 12 /* ArgumentExpressions */: + case 11 /* ArgumentExpressions */: // This is not safe to reuse for the same reason as the 'AssignmentExpression' // cases. i.e. a property assignment may end with an expression, and thus might // have lookahead far beyond it's old node. - case 13 /* ObjectLiteralMembers */: + case 12 /* ObjectLiteralMembers */: // This is probably not safe to reuse. There can be speculative parsing with // type names in a heritage clause. There can be generic names in the type // name list, and there can be left hand side expressions (which can have type // arguments.) - case 8 /* HeritageClauseElement */: - } - return false; - } - function isReusableModuleElement(node) { - if (node) { - switch (node.kind) { - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 216 /* ExportDeclaration */: - case 215 /* ExportAssignment */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - return true; - } - return isReusableStatement(node); + case 7 /* HeritageClauseElement */: } return false; } function isReusableClassMember(node) { if (node) { switch (node.kind) { - case 136 /* Constructor */: - case 141 /* IndexSignature */: - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 133 /* PropertyDeclaration */: - case 179 /* SemicolonClassElement */: + case 137 /* Constructor */: + case 142 /* IndexSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 134 /* PropertyDeclaration */: + case 181 /* SemicolonClassElement */: return true; + case 136 /* MethodDeclaration */: + // Method declarations are not necessarily reusable. An object-literal + // may have a method calls "constructor(...)" and we must reparse that + // into an actual .ConstructorDeclaration. + var methodDeclaration = node; + var nameIsConstructor = methodDeclaration.name.kind === 65 /* Identifier */ && + methodDeclaration.name.originalKeywordKind === 114 /* ConstructorKeyword */; + return !nameIsConstructor; } } return false; @@ -7797,8 +8112,8 @@ var ts; function isReusableSwitchClause(node) { if (node) { switch (node.kind) { - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: return true; } } @@ -7807,49 +8122,58 @@ var ts; function isReusableStatement(node) { if (node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 181 /* VariableStatement */: - case 180 /* Block */: - case 184 /* IfStatement */: - case 183 /* ExpressionStatement */: - case 196 /* ThrowStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 182 /* EmptyStatement */: - case 197 /* TryStatement */: - case 195 /* LabeledStatement */: - case 185 /* DoStatement */: - case 198 /* DebuggerStatement */: + case 203 /* FunctionDeclaration */: + case 183 /* VariableStatement */: + case 182 /* Block */: + case 186 /* IfStatement */: + case 185 /* ExpressionStatement */: + case 198 /* ThrowStatement */: + case 194 /* ReturnStatement */: + case 196 /* SwitchStatement */: + case 193 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 189 /* ForStatement */: + case 188 /* WhileStatement */: + case 195 /* WithStatement */: + case 184 /* EmptyStatement */: + case 199 /* TryStatement */: + case 197 /* LabeledStatement */: + case 187 /* DoStatement */: + case 200 /* DebuggerStatement */: + case 212 /* ImportDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 218 /* ExportDeclaration */: + case 217 /* ExportAssignment */: + case 208 /* ModuleDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 206 /* TypeAliasDeclaration */: return true; } } return false; } function isReusableEnumMember(node) { - return node.kind === 227 /* EnumMember */; + return node.kind === 229 /* EnumMember */; } function isReusableTypeMember(node) { if (node) { switch (node.kind) { - case 140 /* ConstructSignature */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: - case 132 /* PropertySignature */: - case 139 /* CallSignature */: + case 141 /* ConstructSignature */: + case 135 /* MethodSignature */: + case 142 /* IndexSignature */: + case 133 /* PropertySignature */: + case 140 /* CallSignature */: return true; } } return false; } function isReusableVariableDeclaration(node) { - if (node.kind !== 199 /* VariableDeclaration */) { + if (node.kind !== 201 /* VariableDeclaration */) { return false; } // Very subtle incremental parsing bug. Consider the following code: @@ -7870,7 +8194,7 @@ var ts; return variableDeclarator.initializer === undefined; } function isReusableParameter(node) { - if (node.kind !== 130 /* Parameter */) { + if (node.kind !== 131 /* Parameter */) { return false; } // See the comment in isReusableVariableDeclaration for why we do this. @@ -7889,30 +8213,29 @@ var ts; function parsingContextErrors(context) { switch (context) { case 0 /* SourceElements */: return ts.Diagnostics.Declaration_or_statement_expected; - case 1 /* ModuleElements */: return ts.Diagnostics.Declaration_or_statement_expected; - case 2 /* BlockStatements */: return ts.Diagnostics.Statement_expected; - case 3 /* SwitchClauses */: return ts.Diagnostics.case_or_default_expected; - case 4 /* SwitchClauseStatements */: return ts.Diagnostics.Statement_expected; - case 5 /* TypeMembers */: return ts.Diagnostics.Property_or_signature_expected; - case 6 /* ClassMembers */: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; - case 7 /* EnumMembers */: return ts.Diagnostics.Enum_member_expected; - case 8 /* HeritageClauseElement */: return ts.Diagnostics.Expression_expected; - case 9 /* VariableDeclarations */: return ts.Diagnostics.Variable_declaration_expected; - case 10 /* ObjectBindingElements */: return ts.Diagnostics.Property_destructuring_pattern_expected; - case 11 /* ArrayBindingElements */: return ts.Diagnostics.Array_element_destructuring_pattern_expected; - case 12 /* ArgumentExpressions */: return ts.Diagnostics.Argument_expression_expected; - case 13 /* ObjectLiteralMembers */: return ts.Diagnostics.Property_assignment_expected; - case 14 /* ArrayLiteralMembers */: return ts.Diagnostics.Expression_or_comma_expected; - case 15 /* Parameters */: return ts.Diagnostics.Parameter_declaration_expected; - case 16 /* TypeParameters */: return ts.Diagnostics.Type_parameter_declaration_expected; - case 17 /* TypeArguments */: return ts.Diagnostics.Type_argument_expected; - case 18 /* TupleElementTypes */: return ts.Diagnostics.Type_expected; - case 19 /* HeritageClauses */: return ts.Diagnostics.Unexpected_token_expected; - case 20 /* ImportOrExportSpecifiers */: return ts.Diagnostics.Identifier_expected; - case 21 /* JSDocFunctionParameters */: return ts.Diagnostics.Parameter_declaration_expected; - case 22 /* JSDocTypeArguments */: return ts.Diagnostics.Type_argument_expected; - case 24 /* JSDocTupleTypes */: return ts.Diagnostics.Type_expected; - case 23 /* JSDocRecordMembers */: return ts.Diagnostics.Property_assignment_expected; + case 1 /* BlockStatements */: return ts.Diagnostics.Declaration_or_statement_expected; + case 2 /* SwitchClauses */: return ts.Diagnostics.case_or_default_expected; + case 3 /* SwitchClauseStatements */: return ts.Diagnostics.Statement_expected; + case 4 /* TypeMembers */: return ts.Diagnostics.Property_or_signature_expected; + case 5 /* ClassMembers */: return ts.Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected; + case 6 /* EnumMembers */: return ts.Diagnostics.Enum_member_expected; + case 7 /* HeritageClauseElement */: return ts.Diagnostics.Expression_expected; + case 8 /* VariableDeclarations */: return ts.Diagnostics.Variable_declaration_expected; + case 9 /* ObjectBindingElements */: return ts.Diagnostics.Property_destructuring_pattern_expected; + case 10 /* ArrayBindingElements */: return ts.Diagnostics.Array_element_destructuring_pattern_expected; + case 11 /* ArgumentExpressions */: return ts.Diagnostics.Argument_expression_expected; + case 12 /* ObjectLiteralMembers */: return ts.Diagnostics.Property_assignment_expected; + case 13 /* ArrayLiteralMembers */: return ts.Diagnostics.Expression_or_comma_expected; + case 14 /* Parameters */: return ts.Diagnostics.Parameter_declaration_expected; + case 15 /* TypeParameters */: return ts.Diagnostics.Type_parameter_declaration_expected; + case 16 /* TypeArguments */: return ts.Diagnostics.Type_argument_expected; + case 17 /* TupleElementTypes */: return ts.Diagnostics.Type_expected; + case 18 /* HeritageClauses */: return ts.Diagnostics.Unexpected_token_expected; + case 19 /* ImportOrExportSpecifiers */: return ts.Diagnostics.Identifier_expected; + case 20 /* JSDocFunctionParameters */: return ts.Diagnostics.Parameter_declaration_expected; + case 21 /* JSDocTypeArguments */: return ts.Diagnostics.Type_argument_expected; + case 23 /* JSDocTupleTypes */: return ts.Diagnostics.Type_expected; + case 22 /* JSDocRecordMembers */: return ts.Diagnostics.Property_assignment_expected; } } ; @@ -7986,7 +8309,7 @@ var ts; function parseEntityName(allowReservedWords, diagnosticMessage) { var entity = parseIdentifier(diagnosticMessage); while (parseOptional(20 /* DotToken */)) { - var node = createNode(127 /* QualifiedName */, entity.pos); + var node = createNode(128 /* QualifiedName */, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -7994,38 +8317,38 @@ var ts; return entity; } function parseRightSideOfDot(allowIdentifierNames) { - // Technically a keyword is valid here as all keywords are identifier names. - // However, often we'll encounter this in error situations when the keyword + // Technically a keyword is valid here as all identifiers and keywords are identifier names. + // However, often we'll encounter this in error situations when the identifier or keyword // is actually starting another valid construct. // // So, we check for the following specific case: // // name. - // keyword identifierNameOrKeyword + // identifierOrKeyword identifierNameOrKeyword // // Note: the newlines are important here. For example, if that above code // were rewritten into: // - // name.keyword + // name.identifierOrKeyword // identifierNameOrKeyword // // Then we would consider it valid. That's because ASI would take effect and - // the code would be implicitly: "name.keyword; identifierNameOrKeyword". + // the code would be implicitly: "name.identifierOrKeyword; identifierNameOrKeyword". // In the first case though, ASI will not take effect because there is not a - // line terminator after the keyword. - if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord()) { + // line terminator after the identifier or keyword. + if (scanner.hasPrecedingLineBreak() && isIdentifierOrKeyword()) { var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); if (matchesPattern) { // Report that we need an identifier. However, report it right after the dot, // and not on the next token. This is because the next token might actually - // be an identifier and the error woudl be quite confusing. + // be an identifier and the error would be quite confusing. return createMissingNode(65 /* Identifier */, true, ts.Diagnostics.Identifier_expected); } } return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); } function parseTemplateExpression() { - var template = createNode(172 /* TemplateExpression */); + var template = createNode(174 /* TemplateExpression */); template.head = parseLiteralNode(); ts.Debug.assert(template.head.kind === 11 /* TemplateHead */, "Template head has wrong token kind"); var templateSpans = []; @@ -8038,7 +8361,7 @@ var ts; return finishNode(template); } function parseTemplateSpan() { - var span = createNode(178 /* TemplateSpan */); + var span = createNode(180 /* TemplateSpan */); span.expression = allowInAnd(parseExpression); var literal; if (token === 15 /* CloseBraceToken */) { @@ -8078,22 +8401,30 @@ var ts; return node; } // TYPES - function parseTypeReference() { - var node = createNode(142 /* TypeReference */); - node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + function parseTypeReferenceOrTypePredicate() { + var typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + if (typeName.kind === 65 /* Identifier */ && token === 117 /* IsKeyword */ && !scanner.hasPrecedingLineBreak()) { + nextToken(); + var node_1 = createNode(143 /* TypePredicate */, typeName.pos); + node_1.parameterName = typeName; + node_1.type = parseType(); + return finishNode(node_1); + } + var node = createNode(144 /* TypeReference */, typeName.pos); + node.typeName = typeName; if (!scanner.hasPrecedingLineBreak() && token === 24 /* LessThanToken */) { - node.typeArguments = parseBracketedList(17 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + node.typeArguments = parseBracketedList(16 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); } return finishNode(node); } function parseTypeQuery() { - var node = createNode(145 /* TypeQuery */); + var node = createNode(147 /* TypeQuery */); parseExpected(97 /* TypeOfKeyword */); node.exprName = parseEntityName(true); return finishNode(node); } function parseTypeParameter() { - var node = createNode(129 /* TypeParameter */); + var node = createNode(130 /* TypeParameter */); node.name = parseIdentifier(); if (parseOptional(79 /* ExtendsKeyword */)) { // It's not uncommon for people to write improper constraints to a generic. If the @@ -8118,7 +8449,7 @@ var ts; } function parseTypeParameters() { if (token === 24 /* LessThanToken */) { - return parseBracketedList(16 /* TypeParameters */, parseTypeParameter, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + return parseBracketedList(15 /* TypeParameters */, parseTypeParameter, 24 /* LessThanToken */, 25 /* GreaterThanToken */); } } function parseParameterType() { @@ -8139,7 +8470,7 @@ var ts; } } function parseParameter() { - var node = createNode(130 /* Parameter */); + var node = createNode(131 /* Parameter */); node.decorators = parseDecorators(); setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(21 /* DotDotDotToken */); @@ -8210,7 +8541,7 @@ var ts; var savedGeneratorParameterContext = inGeneratorParameterContext(); setYieldContext(yieldAndGeneratorParameterContext); setGeneratorParameterContext(yieldAndGeneratorParameterContext); - var result = parseDelimitedList(15 /* Parameters */, parseParameter); + var result = parseDelimitedList(14 /* Parameters */, parseParameter); setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); if (!parseExpected(17 /* CloseParenToken */) && requireCompleteParameterList) { @@ -8236,7 +8567,7 @@ var ts; } function parseSignatureMember(kind) { var node = createNode(kind); - if (kind === 140 /* ConstructSignature */) { + if (kind === 141 /* ConstructSignature */) { parseExpected(88 /* NewKeyword */); } fillSignature(51 /* ColonToken */, false, false, node); @@ -8300,10 +8631,10 @@ var ts; return token === 51 /* ColonToken */ || token === 23 /* CommaToken */ || token === 19 /* CloseBracketToken */; } function parseIndexSignatureDeclaration(fullStart, decorators, modifiers) { - var node = createNode(141 /* IndexSignature */, fullStart); + var node = createNode(142 /* IndexSignature */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - node.parameters = parseBracketedList(15 /* Parameters */, parseParameter, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); + node.parameters = parseBracketedList(14 /* Parameters */, parseParameter, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); node.type = parseTypeAnnotation(); parseTypeMemberSemicolon(); return finishNode(node); @@ -8313,7 +8644,7 @@ var ts; var name = parsePropertyName(); var questionToken = parseOptionalToken(50 /* QuestionToken */); if (token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */) { - var method = createNode(134 /* MethodSignature */, fullStart); + var method = createNode(135 /* MethodSignature */, fullStart); method.name = name; method.questionToken = questionToken; // Method signatues don't exist in expression contexts. So they have neither @@ -8323,7 +8654,7 @@ var ts; return finishNode(method); } else { - var property = createNode(132 /* PropertySignature */, fullStart); + var property = createNode(133 /* PropertySignature */, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -8365,7 +8696,7 @@ var ts; switch (token) { case 16 /* OpenParenToken */: case 24 /* LessThanToken */: - return parseSignatureMember(139 /* CallSignature */); + return parseSignatureMember(140 /* CallSignature */); case 18 /* OpenBracketToken */: // Indexer or computed property return isIndexSignature() @@ -8373,7 +8704,7 @@ var ts; : parsePropertyOrMethodSignature(); case 88 /* NewKeyword */: if (lookAhead(isStartOfConstructSignature)) { - return parseSignatureMember(140 /* ConstructSignature */); + return parseSignatureMember(141 /* ConstructSignature */); } // fall through. case 8 /* StringLiteral */: @@ -8410,14 +8741,14 @@ var ts; return token === 16 /* OpenParenToken */ || token === 24 /* LessThanToken */; } function parseTypeLiteral() { - var node = createNode(146 /* TypeLiteral */); + var node = createNode(148 /* TypeLiteral */); node.members = parseObjectTypeMembers(); return finishNode(node); } function parseObjectTypeMembers() { var members; if (parseExpected(14 /* OpenBraceToken */)) { - members = parseList(5 /* TypeMembers */, false, parseTypeMember); + members = parseList(4 /* TypeMembers */, parseTypeMember); parseExpected(15 /* CloseBraceToken */); } else { @@ -8426,12 +8757,12 @@ var ts; return members; } function parseTupleType() { - var node = createNode(148 /* TupleType */); - node.elementTypes = parseBracketedList(18 /* TupleElementTypes */, parseType, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); + var node = createNode(150 /* TupleType */); + node.elementTypes = parseBracketedList(17 /* TupleElementTypes */, parseType, 18 /* OpenBracketToken */, 19 /* CloseBracketToken */); return finishNode(node); } function parseParenthesizedType() { - var node = createNode(150 /* ParenthesizedType */); + var node = createNode(152 /* ParenthesizedType */); parseExpected(16 /* OpenParenToken */); node.type = parseType(); parseExpected(17 /* CloseParenToken */); @@ -8439,7 +8770,7 @@ var ts; } function parseFunctionOrConstructorType(kind) { var node = createNode(kind); - if (kind === 144 /* ConstructorType */) { + if (kind === 146 /* ConstructorType */) { parseExpected(88 /* NewKeyword */); } fillSignature(32 /* EqualsGreaterThanToken */, false, false, node); @@ -8452,13 +8783,13 @@ var ts; function parseNonArrayType() { switch (token) { case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: + case 123 /* StringKeyword */: + case 121 /* NumberKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: // If these are followed by a dot, then parse these out as a dotted type reference instead. var node = tryParse(parseKeywordAndNoDot); - return node || parseTypeReference(); + return node || parseTypeReferenceOrTypePredicate(); case 99 /* VoidKeyword */: return parseTokenNode(); case 97 /* TypeOfKeyword */: @@ -8470,16 +8801,16 @@ var ts; case 16 /* OpenParenToken */: return parseParenthesizedType(); default: - return parseTypeReference(); + return parseTypeReferenceOrTypePredicate(); } } function isStartOfType() { switch (token) { case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: + case 123 /* StringKeyword */: + case 121 /* NumberKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: case 99 /* VoidKeyword */: case 97 /* TypeOfKeyword */: case 14 /* OpenBraceToken */: @@ -8503,7 +8834,7 @@ var ts; var type = parseNonArrayType(); while (!scanner.hasPrecedingLineBreak() && parseOptional(18 /* OpenBracketToken */)) { parseExpected(19 /* CloseBracketToken */); - var node = createNode(147 /* ArrayType */, type.pos); + var node = createNode(149 /* ArrayType */, type.pos); node.elementType = type; type = finishNode(node); } @@ -8518,7 +8849,7 @@ var ts; types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(149 /* UnionType */, type.pos); + var node = createNode(151 /* UnionType */, type.pos); node.types = types; type = finishNode(node); } @@ -8573,10 +8904,10 @@ var ts; } function parseTypeWorker() { if (isStartOfFunctionType()) { - return parseFunctionOrConstructorType(143 /* FunctionType */); + return parseFunctionOrConstructorType(145 /* FunctionType */); } if (token === 88 /* NewKeyword */) { - return parseFunctionOrConstructorType(144 /* ConstructorType */); + return parseFunctionOrConstructorType(146 /* ConstructorType */); } return parseUnionTypeOrHigher(); } @@ -8745,11 +9076,6 @@ var ts; if (inYieldContext()) { return true; } - if (inStrictModeContext()) { - // If we're in strict mode, then 'yield' is a keyword, could only ever start - // a yield expression. - return true; - } // We're in a context where 'yield expr' is not allowed. However, if we can // definitely tell that the user was trying to parse a 'yield expr' and not // just a normal expr that start with a 'yield' identifier, then parse out @@ -8764,7 +9090,7 @@ var ts; // for now we just check if the next token is an identifier. More heuristics // can be added here later as necessary. We just need to make sure that we // don't accidently consume something legal. - return lookAhead(nextTokenIsIdentifierOnSameLine); + return lookAhead(nextTokenIsIdentifierOrKeywordOrNumberOnSameLine); } return false; } @@ -8773,7 +9099,7 @@ var ts; return !scanner.hasPrecedingLineBreak() && isIdentifier(); } function parseYieldExpression() { - var node = createNode(173 /* YieldExpression */); + var node = createNode(175 /* YieldExpression */); // YieldExpression[In] : // yield // yield [no LineTerminator here] [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield] @@ -8793,8 +9119,8 @@ var ts; } function parseSimpleArrowFunctionExpression(identifier) { ts.Debug.assert(token === 32 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(164 /* ArrowFunction */, identifier.pos); - var parameter = createNode(130 /* Parameter */, identifier.pos); + var node = createNode(166 /* ArrowFunction */, identifier.pos); + var parameter = createNode(131 /* Parameter */, identifier.pos); parameter.name = identifier; finishNode(parameter); node.parameters = [parameter]; @@ -8912,7 +9238,7 @@ var ts; return parseParenthesizedArrowFunctionExpressionHead(false); } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { - var node = createNode(164 /* ArrowFunction */); + var node = createNode(166 /* ArrowFunction */); // Arrow functions are never generators. // // If we're speculatively parsing a signature for a parenthesized arrow function, then @@ -8974,7 +9300,7 @@ var ts; } // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and // we do not that for the 'whenFalse' part. - var node = createNode(171 /* ConditionalExpression */, leftOperand.pos); + var node = createNode(173 /* ConditionalExpression */, leftOperand.pos); node.condition = leftOperand; node.questionToken = questionToken; node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher); @@ -8987,7 +9313,7 @@ var ts; return parseBinaryExpressionRest(precedence, leftOperand); } function isInOrOfKeyword(t) { - return t === 86 /* InKeyword */ || t === 126 /* OfKeyword */; + return t === 86 /* InKeyword */ || t === 127 /* OfKeyword */; } function parseBinaryExpressionRest(precedence, leftOperand) { while (true) { @@ -9053,33 +9379,33 @@ var ts; return -1; } function makeBinaryExpression(left, operatorToken, right) { - var node = createNode(170 /* BinaryExpression */, left.pos); + var node = createNode(172 /* BinaryExpression */, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; return finishNode(node); } function parsePrefixUnaryExpression() { - var node = createNode(168 /* PrefixUnaryExpression */); + var node = createNode(170 /* PrefixUnaryExpression */); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseDeleteExpression() { - var node = createNode(165 /* DeleteExpression */); + var node = createNode(167 /* DeleteExpression */); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(166 /* TypeOfExpression */); + var node = createNode(168 /* TypeOfExpression */); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(167 /* VoidExpression */); + var node = createNode(169 /* VoidExpression */); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); @@ -9109,7 +9435,7 @@ var ts; var expression = parseLeftHandSideExpressionOrHigher(); ts.Debug.assert(ts.isLeftHandSideExpression(expression)); if ((token === 38 /* PlusPlusToken */ || token === 39 /* MinusMinusToken */) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(169 /* PostfixUnaryExpression */, expression.pos); + var node = createNode(171 /* PostfixUnaryExpression */, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -9213,14 +9539,14 @@ var ts; } // If we have seen "super" it must be followed by '(' or '.'. // If it wasn't then just try to parse out a '.' and report an error. - var node = createNode(156 /* PropertyAccessExpression */, expression.pos); + var node = createNode(158 /* PropertyAccessExpression */, expression.pos); node.expression = expression; node.dotToken = parseExpectedToken(20 /* DotToken */, false, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); node.name = parseRightSideOfDot(true); return finishNode(node); } function parseTypeAssertion() { - var node = createNode(161 /* TypeAssertionExpression */); + var node = createNode(163 /* TypeAssertionExpression */); parseExpected(24 /* LessThanToken */); node.type = parseType(); parseExpected(25 /* GreaterThanToken */); @@ -9231,7 +9557,7 @@ var ts; while (true) { var dotToken = parseOptionalToken(20 /* DotToken */); if (dotToken) { - var propertyAccess = createNode(156 /* PropertyAccessExpression */, expression.pos); + var propertyAccess = createNode(158 /* PropertyAccessExpression */, expression.pos); propertyAccess.expression = expression; propertyAccess.dotToken = dotToken; propertyAccess.name = parseRightSideOfDot(true); @@ -9240,7 +9566,7 @@ var ts; } // when in the [Decorator] context, we do not parse ElementAccess as it could be part of a ComputedPropertyName if (!inDecoratorContext() && parseOptional(18 /* OpenBracketToken */)) { - var indexedAccess = createNode(157 /* ElementAccessExpression */, expression.pos); + var indexedAccess = createNode(159 /* ElementAccessExpression */, expression.pos); indexedAccess.expression = expression; // It's not uncommon for a user to write: "new Type[]". // Check for that common pattern and report a better error message. @@ -9256,7 +9582,7 @@ var ts; continue; } if (token === 10 /* NoSubstitutionTemplateLiteral */ || token === 11 /* TemplateHead */) { - var tagExpression = createNode(160 /* TaggedTemplateExpression */, expression.pos); + var tagExpression = createNode(162 /* TaggedTemplateExpression */, expression.pos); tagExpression.tag = expression; tagExpression.template = token === 10 /* NoSubstitutionTemplateLiteral */ ? parseLiteralNode() @@ -9279,7 +9605,7 @@ var ts; if (!typeArguments) { return expression; } - var callExpr = createNode(158 /* CallExpression */, expression.pos); + var callExpr = createNode(160 /* CallExpression */, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); @@ -9287,7 +9613,7 @@ var ts; continue; } else if (token === 16 /* OpenParenToken */) { - var callExpr = createNode(158 /* CallExpression */, expression.pos); + var callExpr = createNode(160 /* CallExpression */, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -9298,7 +9624,7 @@ var ts; } function parseArgumentList() { parseExpected(16 /* OpenParenToken */); - var result = parseDelimitedList(12 /* ArgumentExpressions */, parseArgumentExpression); + var result = parseDelimitedList(11 /* ArgumentExpressions */, parseArgumentExpression); parseExpected(17 /* CloseParenToken */); return result; } @@ -9306,7 +9632,7 @@ var ts; if (!parseOptional(24 /* LessThanToken */)) { return undefined; } - var typeArguments = parseDelimitedList(17 /* TypeArguments */, parseType); + var typeArguments = parseDelimitedList(16 /* TypeArguments */, parseType); if (!parseExpected(25 /* GreaterThanToken */)) { // If it doesn't have the closing > then it's definitely not an type argument list. return undefined; @@ -9389,41 +9715,41 @@ var ts; return parseIdentifier(ts.Diagnostics.Expression_expected); } function parseParenthesizedExpression() { - var node = createNode(162 /* ParenthesizedExpression */); + var node = createNode(164 /* ParenthesizedExpression */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); parseExpected(17 /* CloseParenToken */); return finishNode(node); } function parseSpreadElement() { - var node = createNode(174 /* SpreadElementExpression */); + var node = createNode(176 /* SpreadElementExpression */); parseExpected(21 /* DotDotDotToken */); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } function parseArgumentOrArrayLiteralElement() { return token === 21 /* DotDotDotToken */ ? parseSpreadElement() : - token === 23 /* CommaToken */ ? createNode(176 /* OmittedExpression */) : + token === 23 /* CommaToken */ ? createNode(178 /* OmittedExpression */) : parseAssignmentExpressionOrHigher(); } function parseArgumentExpression() { return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement); } function parseArrayLiteralExpression() { - var node = createNode(154 /* ArrayLiteralExpression */); + var node = createNode(156 /* ArrayLiteralExpression */); parseExpected(18 /* OpenBracketToken */); if (scanner.hasPrecedingLineBreak()) node.flags |= 512 /* MultiLine */; - node.elements = parseDelimitedList(14 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement); + node.elements = parseDelimitedList(13 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement); parseExpected(19 /* CloseBracketToken */); return finishNode(node); } function tryParseAccessorDeclaration(fullStart, decorators, modifiers) { if (parseContextualModifier(116 /* GetKeyword */)) { - return parseAccessorDeclaration(137 /* GetAccessor */, fullStart, decorators, modifiers); + return parseAccessorDeclaration(138 /* GetAccessor */, fullStart, decorators, modifiers); } - else if (parseContextualModifier(121 /* SetKeyword */)) { - return parseAccessorDeclaration(138 /* SetAccessor */, fullStart, decorators, modifiers); + else if (parseContextualModifier(122 /* SetKeyword */)) { + return parseAccessorDeclaration(139 /* SetAccessor */, fullStart, decorators, modifiers); } return undefined; } @@ -9446,13 +9772,13 @@ var ts; } // Parse to check if it is short-hand property assignment or normal property assignment if ((token === 23 /* CommaToken */ || token === 15 /* CloseBraceToken */) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(226 /* ShorthandPropertyAssignment */, fullStart); + var shorthandDeclaration = createNode(228 /* ShorthandPropertyAssignment */, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(225 /* PropertyAssignment */, fullStart); + var propertyAssignment = createNode(227 /* PropertyAssignment */, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; parseExpected(51 /* ColonToken */); @@ -9461,12 +9787,12 @@ var ts; } } function parseObjectLiteralExpression() { - var node = createNode(155 /* ObjectLiteralExpression */); + var node = createNode(157 /* ObjectLiteralExpression */); parseExpected(14 /* OpenBraceToken */); if (scanner.hasPrecedingLineBreak()) { node.flags |= 512 /* MultiLine */; } - node.properties = parseDelimitedList(13 /* ObjectLiteralMembers */, parseObjectLiteralElement, true); + node.properties = parseDelimitedList(12 /* ObjectLiteralMembers */, parseObjectLiteralElement, true); parseExpected(15 /* CloseBraceToken */); return finishNode(node); } @@ -9479,7 +9805,7 @@ var ts; if (saveDecoratorContext) { setDecoratorContext(false); } - var node = createNode(163 /* FunctionExpression */); + var node = createNode(165 /* FunctionExpression */); parseExpected(83 /* FunctionKeyword */); node.asteriskToken = parseOptionalToken(35 /* AsteriskToken */); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); @@ -9494,7 +9820,7 @@ var ts; return isIdentifier() ? parseIdentifier() : undefined; } function parseNewExpression() { - var node = createNode(159 /* NewExpression */); + var node = createNode(161 /* NewExpression */); parseExpected(88 /* NewKeyword */); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); @@ -9504,10 +9830,10 @@ var ts; return finishNode(node); } // STATEMENTS - function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { - var node = createNode(180 /* Block */); + function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) { + var node = createNode(182 /* Block */); if (parseExpected(14 /* OpenBraceToken */, diagnosticMessage) || ignoreMissingOpenBrace) { - node.statements = parseList(2 /* BlockStatements */, checkForStrictMode, parseStatement); + node.statements = parseList(1 /* BlockStatements */, parseStatement); parseExpected(15 /* CloseBraceToken */); } else { @@ -9524,7 +9850,7 @@ var ts; if (saveDecoratorContext) { setDecoratorContext(false); } - var block = parseBlock(ignoreMissingOpenBrace, true, diagnosticMessage); + var block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage); if (saveDecoratorContext) { setDecoratorContext(true); } @@ -9532,12 +9858,12 @@ var ts; return block; } function parseEmptyStatement() { - var node = createNode(182 /* EmptyStatement */); + var node = createNode(184 /* EmptyStatement */); parseExpected(22 /* SemicolonToken */); return finishNode(node); } function parseIfStatement() { - var node = createNode(184 /* IfStatement */); + var node = createNode(186 /* IfStatement */); parseExpected(84 /* IfKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); @@ -9547,7 +9873,7 @@ var ts; return finishNode(node); } function parseDoStatement() { - var node = createNode(185 /* DoStatement */); + var node = createNode(187 /* DoStatement */); parseExpected(75 /* DoKeyword */); node.statement = parseStatement(); parseExpected(100 /* WhileKeyword */); @@ -9562,7 +9888,7 @@ var ts; return finishNode(node); } function parseWhileStatement() { - var node = createNode(186 /* WhileStatement */); + var node = createNode(188 /* WhileStatement */); parseExpected(100 /* WhileKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); @@ -9585,21 +9911,21 @@ var ts; } var forOrForInOrForOfStatement; if (parseOptional(86 /* InKeyword */)) { - var forInStatement = createNode(188 /* ForInStatement */, pos); + var forInStatement = createNode(190 /* ForInStatement */, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); parseExpected(17 /* CloseParenToken */); forOrForInOrForOfStatement = forInStatement; } - else if (parseOptional(126 /* OfKeyword */)) { - var forOfStatement = createNode(189 /* ForOfStatement */, pos); + else if (parseOptional(127 /* OfKeyword */)) { + var forOfStatement = createNode(191 /* ForOfStatement */, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(17 /* CloseParenToken */); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(187 /* ForStatement */, pos); + var forStatement = createNode(189 /* ForStatement */, pos); forStatement.initializer = initializer; parseExpected(22 /* SemicolonToken */); if (token !== 22 /* SemicolonToken */ && token !== 17 /* CloseParenToken */) { @@ -9617,7 +9943,7 @@ var ts; } function parseBreakOrContinueStatement(kind) { var node = createNode(kind); - parseExpected(kind === 191 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */); + parseExpected(kind === 193 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */); if (!canParseSemicolon()) { node.label = parseIdentifier(); } @@ -9625,7 +9951,7 @@ var ts; return finishNode(node); } function parseReturnStatement() { - var node = createNode(192 /* ReturnStatement */); + var node = createNode(194 /* ReturnStatement */); parseExpected(90 /* ReturnKeyword */); if (!canParseSemicolon()) { node.expression = allowInAnd(parseExpression); @@ -9634,7 +9960,7 @@ var ts; return finishNode(node); } function parseWithStatement() { - var node = createNode(193 /* WithStatement */); + var node = createNode(195 /* WithStatement */); parseExpected(101 /* WithKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); @@ -9643,32 +9969,32 @@ var ts; return finishNode(node); } function parseCaseClause() { - var node = createNode(221 /* CaseClause */); + var node = createNode(223 /* CaseClause */); parseExpected(67 /* CaseKeyword */); node.expression = allowInAnd(parseExpression); parseExpected(51 /* ColonToken */); - node.statements = parseList(4 /* SwitchClauseStatements */, false, parseStatement); + node.statements = parseList(3 /* SwitchClauseStatements */, parseStatement); return finishNode(node); } function parseDefaultClause() { - var node = createNode(222 /* DefaultClause */); + var node = createNode(224 /* DefaultClause */); parseExpected(73 /* DefaultKeyword */); parseExpected(51 /* ColonToken */); - node.statements = parseList(4 /* SwitchClauseStatements */, false, parseStatement); + node.statements = parseList(3 /* SwitchClauseStatements */, parseStatement); return finishNode(node); } function parseCaseOrDefaultClause() { return token === 67 /* CaseKeyword */ ? parseCaseClause() : parseDefaultClause(); } function parseSwitchStatement() { - var node = createNode(194 /* SwitchStatement */); + var node = createNode(196 /* SwitchStatement */); parseExpected(92 /* SwitchKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = allowInAnd(parseExpression); parseExpected(17 /* CloseParenToken */); - var caseBlock = createNode(208 /* CaseBlock */, scanner.getStartPos()); + var caseBlock = createNode(210 /* CaseBlock */, scanner.getStartPos()); parseExpected(14 /* OpenBraceToken */); - caseBlock.clauses = parseList(3 /* SwitchClauses */, false, parseCaseOrDefaultClause); + caseBlock.clauses = parseList(2 /* SwitchClauses */, parseCaseOrDefaultClause); parseExpected(15 /* CloseBraceToken */); node.caseBlock = finishNode(caseBlock); return finishNode(node); @@ -9681,7 +10007,7 @@ var ts; // directly as that might consume an expression on the following line. // We just return 'undefined' in that case. The actual error will be reported in the // grammar walker. - var node = createNode(196 /* ThrowStatement */); + var node = createNode(198 /* ThrowStatement */); parseExpected(94 /* ThrowKeyword */); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); @@ -9689,30 +10015,30 @@ var ts; } // TODO: Review for error recovery function parseTryStatement() { - var node = createNode(197 /* TryStatement */); + var node = createNode(199 /* TryStatement */); parseExpected(96 /* TryKeyword */); - node.tryBlock = parseBlock(false, false); + node.tryBlock = parseBlock(false); node.catchClause = token === 68 /* CatchKeyword */ ? parseCatchClause() : undefined; // If we don't have a catch clause, then we must have a finally clause. Try to parse // one out no matter what. if (!node.catchClause || token === 81 /* FinallyKeyword */) { parseExpected(81 /* FinallyKeyword */); - node.finallyBlock = parseBlock(false, false); + node.finallyBlock = parseBlock(false); } return finishNode(node); } function parseCatchClause() { - var result = createNode(224 /* CatchClause */); + var result = createNode(226 /* CatchClause */); parseExpected(68 /* CatchKeyword */); if (parseExpected(16 /* OpenParenToken */)) { result.variableDeclaration = parseVariableDeclaration(); } parseExpected(17 /* CloseParenToken */); - result.block = parseBlock(false, false); + result.block = parseBlock(false); return finishNode(result); } function parseDebuggerStatement() { - var node = createNode(198 /* DebuggerStatement */); + var node = createNode(200 /* DebuggerStatement */); parseExpected(72 /* DebuggerKeyword */); parseSemicolon(); return finishNode(node); @@ -9724,13 +10050,13 @@ var ts; var fullStart = scanner.getStartPos(); var expression = allowInAnd(parseExpression); if (expression.kind === 65 /* Identifier */ && parseOptional(51 /* ColonToken */)) { - var labeledStatement = createNode(195 /* LabeledStatement */, fullStart); + var labeledStatement = createNode(197 /* LabeledStatement */, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(183 /* ExpressionStatement */, fullStart); + var expressionStatement = createNode(185 /* ExpressionStatement */, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); @@ -9743,7 +10069,11 @@ var ts; nextToken(); return isIdentifierOrKeyword() && !scanner.hasPrecedingLineBreak(); } - function parseDeclarationFlags() { + function nextTokenIsIdentifierOrKeywordOrNumberOnSameLine() { + nextToken(); + return (isIdentifierOrKeyword() || token === 7 /* NumericLiteral */) && !scanner.hasPrecedingLineBreak(); + } + function isDeclaration() { while (true) { switch (token) { case 98 /* VarKeyword */: @@ -9752,28 +10082,52 @@ var ts; case 83 /* FunctionKeyword */: case 69 /* ClassKeyword */: case 77 /* EnumKeyword */: - return 1 /* Statement */; + return true; + // 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers; + // however, an identifier cannot be followed by another identifier on the same line. This is what we + // count on to parse out the respective declarations. For instance, we exploit this to say that + // + // namespace n + // + // can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees + // + // namespace + // n + // + // as the identifier 'namespace' on one line followed by the identifier 'n' on another. + // We need to look one token ahead to see if it permissible to try parsing a declaration. + // + // *Note*: 'interface' is actually a strict mode reserved word. So while + // + // "use strict" + // interface + // I {} + // + // could be legal, it would add complexity for very little gain. case 103 /* InterfaceKeyword */: - case 124 /* TypeKeyword */: + case 125 /* TypeKeyword */: + return nextTokenIsIdentifierOnSameLine(); + case 118 /* ModuleKeyword */: + case 119 /* NamespaceKeyword */: + return nextTokenIsIdentifierOrStringLiteralOnSameLine(); + case 115 /* DeclareKeyword */: nextToken(); - return isIdentifierOrKeyword() ? 1 /* Statement */ : 0 /* None */; - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: - nextToken(); - return isIdentifierOrKeyword() || token === 8 /* StringLiteral */ ? 2 /* ModuleElement */ : 0 /* None */; + // ASI takes effect for this modifier. + if (scanner.hasPrecedingLineBreak()) { + return false; + } + continue; case 85 /* ImportKeyword */: nextToken(); return token === 8 /* StringLiteral */ || token === 35 /* AsteriskToken */ || - token === 14 /* OpenBraceToken */ || isIdentifierOrKeyword() ? - 2 /* ModuleElement */ : 0 /* None */; + token === 14 /* OpenBraceToken */ || isIdentifierOrKeyword(); case 78 /* ExportKeyword */: nextToken(); if (token === 53 /* EqualsToken */ || token === 35 /* AsteriskToken */ || token === 14 /* OpenBraceToken */ || token === 73 /* DefaultKeyword */) { - return 2 /* ModuleElement */; + return true; } continue; - case 115 /* DeclareKeyword */: case 108 /* PublicKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: @@ -9781,14 +10135,14 @@ var ts; nextToken(); continue; default: - return 0 /* None */; + return false; } } } - function getDeclarationFlags() { - return lookAhead(parseDeclarationFlags); + function isStartOfDeclaration() { + return lookAhead(isDeclaration); } - function getStatementFlags() { + function isStartOfStatement() { switch (token) { case 52 /* AtToken */: case 22 /* SemicolonToken */: @@ -9814,61 +10168,44 @@ var ts; // however, we say they are here so that we may gracefully parse them and error later. case 68 /* CatchKeyword */: case 81 /* FinallyKeyword */: - return 1 /* Statement */; + return true; case 70 /* ConstKeyword */: case 78 /* ExportKeyword */: case 85 /* ImportKeyword */: - return getDeclarationFlags(); + return isStartOfDeclaration(); case 115 /* DeclareKeyword */: case 103 /* InterfaceKeyword */: - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: - case 124 /* TypeKeyword */: + case 118 /* ModuleKeyword */: + case 119 /* NamespaceKeyword */: + case 125 /* TypeKeyword */: // When these don't start a declaration, they're an identifier in an expression statement - return getDeclarationFlags() || 1 /* Statement */; + return true; case 108 /* PublicKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: case 109 /* StaticKeyword */: // When these don't start a declaration, they may be the start of a class member if an identifier // immediately follows. Otherwise they're an identifier in an expression statement. - return getDeclarationFlags() || - (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? 0 /* None */ : 1 /* Statement */); + return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); default: - return isStartOfExpression() ? 1 /* Statement */ : 0 /* None */; + return isStartOfExpression(); } } - function isStartOfStatement() { - return (getStatementFlags() & 1 /* Statement */) !== 0; - } - function isStartOfModuleElement() { - return (getStatementFlags() & 3 /* StatementOrModuleElement */) !== 0; - } - function nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine() { + function nextTokenIsIdentifierOrStartOfDestructuring() { nextToken(); - return !scanner.hasPrecedingLineBreak() && - (isIdentifier() || token === 14 /* OpenBraceToken */ || token === 18 /* OpenBracketToken */); + return isIdentifier() || token === 14 /* OpenBraceToken */ || token === 18 /* OpenBracketToken */; } function isLetDeclaration() { - // It is let declaration if in strict mode or next token is identifier\open bracket\open curly on same line. - // otherwise it needs to be treated like identifier - return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine); + // In ES6 'let' always starts a lexical declaration if followed by an identifier or { + // or [. + return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring); } function parseStatement() { - return parseModuleElementOfKind(1 /* Statement */); - } - function parseModuleElement() { - return parseModuleElementOfKind(3 /* StatementOrModuleElement */); - } - function parseSourceElement() { - return parseModuleElementOfKind(3 /* StatementOrModuleElement */); - } - function parseModuleElementOfKind(flags) { switch (token) { case 22 /* SemicolonToken */: return parseEmptyStatement(); case 14 /* OpenBraceToken */: - return parseBlock(false, false); + return parseBlock(false); case 98 /* VarKeyword */: return parseVariableStatement(scanner.getStartPos(), undefined, undefined); case 104 /* LetKeyword */: @@ -9889,9 +10226,9 @@ var ts; case 82 /* ForKeyword */: return parseForOrForInOrForOfStatement(); case 71 /* ContinueKeyword */: - return parseBreakOrContinueStatement(190 /* ContinueStatement */); + return parseBreakOrContinueStatement(192 /* ContinueStatement */); case 66 /* BreakKeyword */: - return parseBreakOrContinueStatement(191 /* BreakStatement */); + return parseBreakOrContinueStatement(193 /* BreakStatement */); case 90 /* ReturnKeyword */: return parseReturnStatement(); case 101 /* WithKeyword */: @@ -9901,7 +10238,7 @@ var ts; case 94 /* ThrowKeyword */: return parseThrowStatement(); case 96 /* TryKeyword */: - // Include the next two for error recovery. + // Include 'catch' and 'finally' for error recovery. case 68 /* CatchKeyword */: case 81 /* FinallyKeyword */: return parseTryStatement(); @@ -9909,20 +10246,20 @@ var ts; return parseDebuggerStatement(); case 52 /* AtToken */: return parseDeclaration(); - case 70 /* ConstKeyword */: + case 103 /* InterfaceKeyword */: + case 125 /* TypeKeyword */: + case 118 /* ModuleKeyword */: + case 119 /* NamespaceKeyword */: case 115 /* DeclareKeyword */: + case 70 /* ConstKeyword */: case 77 /* EnumKeyword */: case 78 /* ExportKeyword */: case 85 /* ImportKeyword */: - case 103 /* InterfaceKeyword */: - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: case 108 /* PublicKeyword */: case 109 /* StaticKeyword */: - case 124 /* TypeKeyword */: - if (getDeclarationFlags() & flags) { + if (isStartOfDeclaration()) { return parseDeclaration(); } break; @@ -9944,12 +10281,12 @@ var ts; return parseClassDeclaration(fullStart, decorators, modifiers); case 103 /* InterfaceKeyword */: return parseInterfaceDeclaration(fullStart, decorators, modifiers); - case 124 /* TypeKeyword */: + case 125 /* TypeKeyword */: return parseTypeAliasDeclaration(fullStart, decorators, modifiers); case 77 /* EnumKeyword */: return parseEnumDeclaration(fullStart, decorators, modifiers); - case 117 /* ModuleKeyword */: - case 118 /* NamespaceKeyword */: + case 118 /* ModuleKeyword */: + case 119 /* NamespaceKeyword */: return parseModuleDeclaration(fullStart, decorators, modifiers); case 85 /* ImportKeyword */: return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers); @@ -9959,10 +10296,10 @@ var ts; parseExportAssignment(fullStart, decorators, modifiers) : parseExportDeclaration(fullStart, decorators, modifiers); default: - if (decorators) { + if (decorators || modifiers) { // We reached this point because we encountered decorators and/or modifiers and assumed a declaration // would follow. For recovery and error reporting purposes, return an incomplete declaration. - var node = createMissingNode(219 /* MissingDeclaration */, true, ts.Diagnostics.Declaration_expected); + var node = createMissingNode(221 /* MissingDeclaration */, true, ts.Diagnostics.Declaration_expected); node.pos = fullStart; node.decorators = decorators; setModifiers(node, modifiers); @@ -9970,6 +10307,10 @@ var ts; } } } + function nextTokenIsIdentifierOrStringLiteralOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token === 8 /* StringLiteral */); + } function parseFunctionBlockOrSemicolon(isGenerator, diagnosticMessage) { if (token !== 14 /* OpenBraceToken */ && canParseSemicolon()) { parseSemicolon(); @@ -9980,16 +10321,16 @@ var ts; // DECLARATIONS function parseArrayBindingElement() { if (token === 23 /* CommaToken */) { - return createNode(176 /* OmittedExpression */); + return createNode(178 /* OmittedExpression */); } - var node = createNode(153 /* BindingElement */); + var node = createNode(155 /* BindingElement */); node.dotDotDotToken = parseOptionalToken(21 /* DotDotDotToken */); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(false); return finishNode(node); } function parseObjectBindingElement() { - var node = createNode(153 /* BindingElement */); + var node = createNode(155 /* BindingElement */); // TODO(andersh): Handle computed properties var tokenIsIdentifier = isIdentifier(); var propertyName = parsePropertyName(); @@ -10005,16 +10346,16 @@ var ts; return finishNode(node); } function parseObjectBindingPattern() { - var node = createNode(151 /* ObjectBindingPattern */); + var node = createNode(153 /* ObjectBindingPattern */); parseExpected(14 /* OpenBraceToken */); - node.elements = parseDelimitedList(10 /* ObjectBindingElements */, parseObjectBindingElement); + node.elements = parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement); parseExpected(15 /* CloseBraceToken */); return finishNode(node); } function parseArrayBindingPattern() { - var node = createNode(152 /* ArrayBindingPattern */); + var node = createNode(154 /* ArrayBindingPattern */); parseExpected(18 /* OpenBracketToken */); - node.elements = parseDelimitedList(11 /* ArrayBindingElements */, parseArrayBindingElement); + node.elements = parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement); parseExpected(19 /* CloseBracketToken */); return finishNode(node); } @@ -10031,7 +10372,7 @@ var ts; return parseIdentifier(); } function parseVariableDeclaration() { - var node = createNode(199 /* VariableDeclaration */); + var node = createNode(201 /* VariableDeclaration */); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -10040,7 +10381,7 @@ var ts; return finishNode(node); } function parseVariableDeclarationList(inForStatementInitializer) { - var node = createNode(200 /* VariableDeclarationList */); + var node = createNode(202 /* VariableDeclarationList */); switch (token) { case 98 /* VarKeyword */: break; @@ -10063,13 +10404,13 @@ var ts; // So we need to look ahead to determine if 'of' should be treated as a keyword in // this context. // The checker will then give an error that there is an empty declaration list. - if (token === 126 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) { + if (token === 127 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) { node.declarations = createMissingList(); } else { var savedDisallowIn = inDisallowInContext(); setDisallowInContext(inForStatementInitializer); - node.declarations = parseDelimitedList(9 /* VariableDeclarations */, parseVariableDeclaration); + node.declarations = parseDelimitedList(8 /* VariableDeclarations */, parseVariableDeclaration); setDisallowInContext(savedDisallowIn); } return finishNode(node); @@ -10078,7 +10419,7 @@ var ts; return nextTokenIsIdentifier() && nextToken() === 17 /* CloseParenToken */; } function parseVariableStatement(fullStart, decorators, modifiers) { - var node = createNode(181 /* VariableStatement */, fullStart); + var node = createNode(183 /* VariableStatement */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(false); @@ -10086,7 +10427,7 @@ var ts; return finishNode(node); } function parseFunctionDeclaration(fullStart, decorators, modifiers) { - var node = createNode(201 /* FunctionDeclaration */, fullStart); + var node = createNode(203 /* FunctionDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(83 /* FunctionKeyword */); @@ -10097,7 +10438,7 @@ var ts; return finishNode(node); } function parseConstructorDeclaration(pos, decorators, modifiers) { - var node = createNode(136 /* Constructor */, pos); + var node = createNode(137 /* Constructor */, pos); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(114 /* ConstructorKeyword */); @@ -10106,7 +10447,7 @@ var ts; return finishNode(node); } function parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { - var method = createNode(135 /* MethodDeclaration */, fullStart); + var method = createNode(136 /* MethodDeclaration */, fullStart); method.decorators = decorators; setModifiers(method, modifiers); method.asteriskToken = asteriskToken; @@ -10117,7 +10458,7 @@ var ts; return finishNode(method); } function parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken) { - var property = createNode(133 /* PropertyDeclaration */, fullStart); + var property = createNode(134 /* PropertyDeclaration */, fullStart); property.decorators = decorators; setModifiers(property, modifiers); property.name = name; @@ -10209,7 +10550,7 @@ var ts; // If we were able to get any potential identifier... if (idToken !== undefined) { // If we have a non-keyword identifier, or if we have an accessor, then it's safe to parse. - if (!ts.isKeyword(idToken) || idToken === 121 /* SetKeyword */ || idToken === 116 /* GetKeyword */) { + if (!ts.isKeyword(idToken) || idToken === 122 /* SetKeyword */ || idToken === 116 /* GetKeyword */) { return true; } // If it *is* a keyword, but not an accessor, check a little farther along @@ -10243,7 +10584,7 @@ var ts; decorators = []; decorators.pos = scanner.getStartPos(); } - var decorator = createNode(131 /* Decorator */, decoratorStart); + var decorator = createNode(132 /* Decorator */, decoratorStart); decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher); decorators.push(finishNode(decorator)); } @@ -10276,7 +10617,7 @@ var ts; } function parseClassElement() { if (token === 22 /* SemicolonToken */) { - var result = createNode(179 /* SemicolonClassElement */); + var result = createNode(181 /* SemicolonClassElement */); nextToken(); return finishNode(result); } @@ -10302,7 +10643,7 @@ var ts; token === 18 /* OpenBracketToken */) { return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers); } - if (decorators) { + if (decorators || modifiers) { // treat this as a property declaration with a missing name. var name_6 = createMissingNode(65 /* Identifier */, true, ts.Diagnostics.Declaration_expected); return parsePropertyDeclaration(fullStart, decorators, modifiers, name_6, undefined); @@ -10314,15 +10655,12 @@ var ts; return parseClassDeclarationOrExpression( /*fullStart*/ scanner.getStartPos(), /*decorators*/ undefined, - /*modifiers*/ undefined, 175 /* ClassExpression */); + /*modifiers*/ undefined, 177 /* ClassExpression */); } function parseClassDeclaration(fullStart, decorators, modifiers) { - return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 202 /* ClassDeclaration */); + return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 204 /* ClassDeclaration */); } function parseClassDeclarationOrExpression(fullStart, decorators, modifiers, kind) { - // In ES6 specification, All parts of a ClassDeclaration or a ClassExpression are strict mode code - var savedStrictModeContext = inStrictModeContext(); - setStrictModeContext(true); var node = createNode(kind, fullStart); node.decorators = decorators; setModifiers(node, modifiers); @@ -10342,9 +10680,7 @@ var ts; else { node.members = createMissingList(); } - var finishedNode = finishNode(node); - setStrictModeContext(savedStrictModeContext); - return finishedNode; + return finishNode(node); } function parseHeritageClauses(isClassHeritageClause) { // ClassTail[Yield,GeneratorParameter] : See 14.5 @@ -10358,23 +10694,23 @@ var ts; return undefined; } function parseHeritageClausesWorker() { - return parseList(19 /* HeritageClauses */, false, parseHeritageClause); + return parseList(18 /* HeritageClauses */, parseHeritageClause); } function parseHeritageClause() { if (token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */) { - var node = createNode(223 /* HeritageClause */); + var node = createNode(225 /* HeritageClause */); node.token = token; nextToken(); - node.types = parseDelimitedList(8 /* HeritageClauseElement */, parseExpressionWithTypeArguments); + node.types = parseDelimitedList(7 /* HeritageClauseElement */, parseExpressionWithTypeArguments); return finishNode(node); } return undefined; } function parseExpressionWithTypeArguments() { - var node = createNode(177 /* ExpressionWithTypeArguments */); + var node = createNode(179 /* ExpressionWithTypeArguments */); node.expression = parseLeftHandSideExpressionOrHigher(); if (token === 24 /* LessThanToken */) { - node.typeArguments = parseBracketedList(17 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); + node.typeArguments = parseBracketedList(16 /* TypeArguments */, parseType, 24 /* LessThanToken */, 25 /* GreaterThanToken */); } return finishNode(node); } @@ -10382,10 +10718,10 @@ var ts; return token === 79 /* ExtendsKeyword */ || token === 102 /* ImplementsKeyword */; } function parseClassMembers() { - return parseList(6 /* ClassMembers */, false, parseClassElement); + return parseList(5 /* ClassMembers */, parseClassElement); } function parseInterfaceDeclaration(fullStart, decorators, modifiers) { - var node = createNode(203 /* InterfaceDeclaration */, fullStart); + var node = createNode(205 /* InterfaceDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(103 /* InterfaceKeyword */); @@ -10396,11 +10732,12 @@ var ts; return finishNode(node); } function parseTypeAliasDeclaration(fullStart, decorators, modifiers) { - var node = createNode(204 /* TypeAliasDeclaration */, fullStart); + var node = createNode(206 /* TypeAliasDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); - parseExpected(124 /* TypeKeyword */); + parseExpected(125 /* TypeKeyword */); node.name = parseIdentifier(); + node.typeParameters = parseTypeParameters(); parseExpected(53 /* EqualsToken */); node.type = parseType(); parseSemicolon(); @@ -10411,19 +10748,19 @@ var ts; // ConstantEnumMemberSection, which starts at the beginning of an enum declaration // or any time an integer literal initializer is encountered. function parseEnumMember() { - var node = createNode(227 /* EnumMember */, scanner.getStartPos()); + var node = createNode(229 /* EnumMember */, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart, decorators, modifiers) { - var node = createNode(205 /* EnumDeclaration */, fullStart); + var node = createNode(207 /* EnumDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); parseExpected(77 /* EnumKeyword */); node.name = parseIdentifier(); if (parseExpected(14 /* OpenBraceToken */)) { - node.members = parseDelimitedList(7 /* EnumMembers */, parseEnumMember); + node.members = parseDelimitedList(6 /* EnumMembers */, parseEnumMember); parseExpected(15 /* CloseBraceToken */); } else { @@ -10432,9 +10769,9 @@ var ts; return finishNode(node); } function parseModuleBlock() { - var node = createNode(207 /* ModuleBlock */, scanner.getStartPos()); + var node = createNode(209 /* ModuleBlock */, scanner.getStartPos()); if (parseExpected(14 /* OpenBraceToken */)) { - node.statements = parseList(1 /* ModuleElements */, false, parseModuleElement); + node.statements = parseList(1 /* BlockStatements */, parseStatement); parseExpected(15 /* CloseBraceToken */); } else { @@ -10443,7 +10780,7 @@ var ts; return finishNode(node); } function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) { - var node = createNode(206 /* ModuleDeclaration */, fullStart); + var node = createNode(208 /* ModuleDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.flags |= flags; @@ -10454,7 +10791,7 @@ var ts; return finishNode(node); } function parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers) { - var node = createNode(206 /* ModuleDeclaration */, fullStart); + var node = createNode(208 /* ModuleDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); node.name = parseLiteralNode(true); @@ -10463,11 +10800,11 @@ var ts; } function parseModuleDeclaration(fullStart, decorators, modifiers) { var flags = modifiers ? modifiers.flags : 0; - if (parseOptional(118 /* NamespaceKeyword */)) { + if (parseOptional(119 /* NamespaceKeyword */)) { flags |= 32768 /* Namespace */; } else { - parseExpected(117 /* ModuleKeyword */); + parseExpected(118 /* ModuleKeyword */); if (token === 8 /* StringLiteral */) { return parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers); } @@ -10475,7 +10812,7 @@ var ts; return parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags); } function isExternalModuleReference() { - return token === 119 /* RequireKeyword */ && + return token === 120 /* RequireKeyword */ && lookAhead(nextTokenIsOpenParen); } function nextTokenIsOpenParen() { @@ -10484,7 +10821,7 @@ var ts; function nextTokenIsCommaOrFromKeyword() { nextToken(); return token === 23 /* CommaToken */ || - token === 125 /* FromKeyword */; + token === 126 /* FromKeyword */; } function parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers) { parseExpected(85 /* ImportKeyword */); @@ -10492,11 +10829,11 @@ var ts; var identifier; if (isIdentifier()) { identifier = parseIdentifier(); - if (token !== 23 /* CommaToken */ && token !== 125 /* FromKeyword */) { + if (token !== 23 /* CommaToken */ && token !== 126 /* FromKeyword */) { // ImportEquals declaration of type: // import x = require("mod"); or // import x = M.x; - var importEqualsDeclaration = createNode(209 /* ImportEqualsDeclaration */, fullStart); + var importEqualsDeclaration = createNode(211 /* ImportEqualsDeclaration */, fullStart); importEqualsDeclaration.decorators = decorators; setModifiers(importEqualsDeclaration, modifiers); importEqualsDeclaration.name = identifier; @@ -10507,7 +10844,7 @@ var ts; } } // Import statement - var importDeclaration = createNode(210 /* ImportDeclaration */, fullStart); + var importDeclaration = createNode(212 /* ImportDeclaration */, fullStart); importDeclaration.decorators = decorators; setModifiers(importDeclaration, modifiers); // ImportDeclaration: @@ -10517,7 +10854,7 @@ var ts; token === 35 /* AsteriskToken */ || token === 14 /* OpenBraceToken */) { importDeclaration.importClause = parseImportClause(identifier, afterImportPos); - parseExpected(125 /* FromKeyword */); + parseExpected(126 /* FromKeyword */); } importDeclaration.moduleSpecifier = parseModuleSpecifier(); parseSemicolon(); @@ -10530,7 +10867,7 @@ var ts; // NamedImports // ImportedDefaultBinding, NameSpaceImport // ImportedDefaultBinding, NamedImports - var importClause = createNode(211 /* ImportClause */, fullStart); + var importClause = createNode(213 /* ImportClause */, fullStart); if (identifier) { // ImportedDefaultBinding: // ImportedBinding @@ -10540,7 +10877,7 @@ var ts; // parse namespace or named imports if (!importClause.name || parseOptional(23 /* CommaToken */)) { - importClause.namedBindings = token === 35 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(213 /* NamedImports */); + importClause.namedBindings = token === 35 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(215 /* NamedImports */); } return finishNode(importClause); } @@ -10550,8 +10887,8 @@ var ts; : parseEntityName(false); } function parseExternalModuleReference() { - var node = createNode(220 /* ExternalModuleReference */); - parseExpected(119 /* RequireKeyword */); + var node = createNode(222 /* ExternalModuleReference */); + parseExpected(120 /* RequireKeyword */); parseExpected(16 /* OpenParenToken */); node.expression = parseModuleSpecifier(); parseExpected(17 /* CloseParenToken */); @@ -10572,7 +10909,7 @@ var ts; function parseNamespaceImport() { // NameSpaceImport: // * as ImportedBinding - var namespaceImport = createNode(212 /* NamespaceImport */); + var namespaceImport = createNode(214 /* NamespaceImport */); parseExpected(35 /* AsteriskToken */); parseExpected(111 /* AsKeyword */); namespaceImport.name = parseIdentifier(); @@ -10587,14 +10924,14 @@ var ts; // ImportsList: // ImportSpecifier // ImportsList, ImportSpecifier - node.elements = parseBracketedList(20 /* ImportOrExportSpecifiers */, kind === 213 /* NamedImports */ ? parseImportSpecifier : parseExportSpecifier, 14 /* OpenBraceToken */, 15 /* CloseBraceToken */); + node.elements = parseBracketedList(19 /* ImportOrExportSpecifiers */, kind === 215 /* NamedImports */ ? parseImportSpecifier : parseExportSpecifier, 14 /* OpenBraceToken */, 15 /* CloseBraceToken */); return finishNode(node); } function parseExportSpecifier() { - return parseImportOrExportSpecifier(218 /* ExportSpecifier */); + return parseImportOrExportSpecifier(220 /* ExportSpecifier */); } function parseImportSpecifier() { - return parseImportOrExportSpecifier(214 /* ImportSpecifier */); + return parseImportOrExportSpecifier(216 /* ImportSpecifier */); } function parseImportOrExportSpecifier(kind) { var node = createNode(kind); @@ -10619,23 +10956,23 @@ var ts; else { node.name = identifierName; } - if (kind === 214 /* ImportSpecifier */ && checkIdentifierIsKeyword) { + if (kind === 216 /* ImportSpecifier */ && checkIdentifierIsKeyword) { // Report error identifier expected parseErrorAtPosition(checkIdentifierStart, checkIdentifierEnd - checkIdentifierStart, ts.Diagnostics.Identifier_expected); } return finishNode(node); } function parseExportDeclaration(fullStart, decorators, modifiers) { - var node = createNode(216 /* ExportDeclaration */, fullStart); + var node = createNode(218 /* ExportDeclaration */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); if (parseOptional(35 /* AsteriskToken */)) { - parseExpected(125 /* FromKeyword */); + parseExpected(126 /* FromKeyword */); node.moduleSpecifier = parseModuleSpecifier(); } else { - node.exportClause = parseNamedImportsOrExports(217 /* NamedExports */); - if (parseOptional(125 /* FromKeyword */)) { + node.exportClause = parseNamedImportsOrExports(219 /* NamedExports */); + if (parseOptional(126 /* FromKeyword */)) { node.moduleSpecifier = parseModuleSpecifier(); } } @@ -10643,7 +10980,7 @@ var ts; return finishNode(node); } function parseExportAssignment(fullStart, decorators, modifiers) { - var node = createNode(215 /* ExportAssignment */, fullStart); + var node = createNode(217 /* ExportAssignment */, fullStart); node.decorators = decorators; setModifiers(node, modifiers); if (parseOptional(53 /* EqualsToken */)) { @@ -10711,15 +11048,15 @@ var ts; } sourceFile.referencedFiles = referencedFiles; sourceFile.amdDependencies = amdDependencies; - sourceFile.amdModuleName = amdModuleName; + sourceFile.moduleName = amdModuleName; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { return node.flags & 1 /* Export */ - || node.kind === 209 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 220 /* ExternalModuleReference */ - || node.kind === 210 /* ImportDeclaration */ - || node.kind === 215 /* ExportAssignment */ - || node.kind === 216 /* ExportDeclaration */ + || node.kind === 211 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 222 /* ExternalModuleReference */ + || node.kind === 212 /* ImportDeclaration */ + || node.kind === 217 /* ExportAssignment */ + || node.kind === 218 /* ExportDeclaration */ ? node : undefined; }); @@ -10727,31 +11064,30 @@ var ts; var ParsingContext; (function (ParsingContext) { ParsingContext[ParsingContext["SourceElements"] = 0] = "SourceElements"; - ParsingContext[ParsingContext["ModuleElements"] = 1] = "ModuleElements"; - ParsingContext[ParsingContext["BlockStatements"] = 2] = "BlockStatements"; - ParsingContext[ParsingContext["SwitchClauses"] = 3] = "SwitchClauses"; - ParsingContext[ParsingContext["SwitchClauseStatements"] = 4] = "SwitchClauseStatements"; - ParsingContext[ParsingContext["TypeMembers"] = 5] = "TypeMembers"; - ParsingContext[ParsingContext["ClassMembers"] = 6] = "ClassMembers"; - ParsingContext[ParsingContext["EnumMembers"] = 7] = "EnumMembers"; - ParsingContext[ParsingContext["HeritageClauseElement"] = 8] = "HeritageClauseElement"; - ParsingContext[ParsingContext["VariableDeclarations"] = 9] = "VariableDeclarations"; - ParsingContext[ParsingContext["ObjectBindingElements"] = 10] = "ObjectBindingElements"; - ParsingContext[ParsingContext["ArrayBindingElements"] = 11] = "ArrayBindingElements"; - ParsingContext[ParsingContext["ArgumentExpressions"] = 12] = "ArgumentExpressions"; - ParsingContext[ParsingContext["ObjectLiteralMembers"] = 13] = "ObjectLiteralMembers"; - ParsingContext[ParsingContext["ArrayLiteralMembers"] = 14] = "ArrayLiteralMembers"; - ParsingContext[ParsingContext["Parameters"] = 15] = "Parameters"; - ParsingContext[ParsingContext["TypeParameters"] = 16] = "TypeParameters"; - ParsingContext[ParsingContext["TypeArguments"] = 17] = "TypeArguments"; - ParsingContext[ParsingContext["TupleElementTypes"] = 18] = "TupleElementTypes"; - ParsingContext[ParsingContext["HeritageClauses"] = 19] = "HeritageClauses"; - ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 20] = "ImportOrExportSpecifiers"; - ParsingContext[ParsingContext["JSDocFunctionParameters"] = 21] = "JSDocFunctionParameters"; - ParsingContext[ParsingContext["JSDocTypeArguments"] = 22] = "JSDocTypeArguments"; - ParsingContext[ParsingContext["JSDocRecordMembers"] = 23] = "JSDocRecordMembers"; - ParsingContext[ParsingContext["JSDocTupleTypes"] = 24] = "JSDocTupleTypes"; - ParsingContext[ParsingContext["Count"] = 25] = "Count"; // Number of parsing contexts + ParsingContext[ParsingContext["BlockStatements"] = 1] = "BlockStatements"; + ParsingContext[ParsingContext["SwitchClauses"] = 2] = "SwitchClauses"; + ParsingContext[ParsingContext["SwitchClauseStatements"] = 3] = "SwitchClauseStatements"; + ParsingContext[ParsingContext["TypeMembers"] = 4] = "TypeMembers"; + ParsingContext[ParsingContext["ClassMembers"] = 5] = "ClassMembers"; + ParsingContext[ParsingContext["EnumMembers"] = 6] = "EnumMembers"; + ParsingContext[ParsingContext["HeritageClauseElement"] = 7] = "HeritageClauseElement"; + ParsingContext[ParsingContext["VariableDeclarations"] = 8] = "VariableDeclarations"; + ParsingContext[ParsingContext["ObjectBindingElements"] = 9] = "ObjectBindingElements"; + ParsingContext[ParsingContext["ArrayBindingElements"] = 10] = "ArrayBindingElements"; + ParsingContext[ParsingContext["ArgumentExpressions"] = 11] = "ArgumentExpressions"; + ParsingContext[ParsingContext["ObjectLiteralMembers"] = 12] = "ObjectLiteralMembers"; + ParsingContext[ParsingContext["ArrayLiteralMembers"] = 13] = "ArrayLiteralMembers"; + ParsingContext[ParsingContext["Parameters"] = 14] = "Parameters"; + ParsingContext[ParsingContext["TypeParameters"] = 15] = "TypeParameters"; + ParsingContext[ParsingContext["TypeArguments"] = 16] = "TypeArguments"; + ParsingContext[ParsingContext["TupleElementTypes"] = 17] = "TupleElementTypes"; + ParsingContext[ParsingContext["HeritageClauses"] = 18] = "HeritageClauses"; + ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 19] = "ImportOrExportSpecifiers"; + ParsingContext[ParsingContext["JSDocFunctionParameters"] = 20] = "JSDocFunctionParameters"; + ParsingContext[ParsingContext["JSDocTypeArguments"] = 21] = "JSDocTypeArguments"; + ParsingContext[ParsingContext["JSDocRecordMembers"] = 22] = "JSDocRecordMembers"; + ParsingContext[ParsingContext["JSDocTupleTypes"] = 23] = "JSDocTupleTypes"; + ParsingContext[ParsingContext["Count"] = 24] = "Count"; // Number of parsing contexts })(ParsingContext || (ParsingContext = {})); var Tristate; (function (Tristate) { @@ -10793,7 +11129,7 @@ var ts; scanner.setText(sourceText, start, length); // Prime the first token for us to start processing. token = nextToken(); - var result = createNode(229 /* JSDocTypeExpression */); + var result = createNode(231 /* JSDocTypeExpression */); parseExpected(14 /* OpenBraceToken */); result.type = parseJSDocTopLevelType(); parseExpected(15 /* CloseBraceToken */); @@ -10804,12 +11140,12 @@ var ts; function parseJSDocTopLevelType() { var type = parseJSDocType(); if (token === 44 /* BarToken */) { - var unionType = createNode(233 /* JSDocUnionType */, type.pos); + var unionType = createNode(235 /* JSDocUnionType */, type.pos); unionType.types = parseJSDocTypeList(type); type = finishNode(unionType); } if (token === 53 /* EqualsToken */) { - var optionalType = createNode(240 /* JSDocOptionalType */, type.pos); + var optionalType = createNode(242 /* JSDocOptionalType */, type.pos); nextToken(); optionalType.type = type; type = finishNode(optionalType); @@ -10820,20 +11156,20 @@ var ts; var type = parseBasicTypeExpression(); while (true) { if (token === 18 /* OpenBracketToken */) { - var arrayType = createNode(232 /* JSDocArrayType */, type.pos); + var arrayType = createNode(234 /* JSDocArrayType */, type.pos); arrayType.elementType = type; nextToken(); parseExpected(19 /* CloseBracketToken */); type = finishNode(arrayType); } else if (token === 50 /* QuestionToken */) { - var nullableType = createNode(235 /* JSDocNullableType */, type.pos); + var nullableType = createNode(237 /* JSDocNullableType */, type.pos); nullableType.type = type; nextToken(); type = finishNode(nullableType); } else if (token === 46 /* ExclamationToken */) { - var nonNullableType = createNode(236 /* JSDocNonNullableType */, type.pos); + var nonNullableType = createNode(238 /* JSDocNonNullableType */, type.pos); nonNullableType.type = type; nextToken(); type = finishNode(nonNullableType); @@ -10867,40 +11203,40 @@ var ts; case 93 /* ThisKeyword */: return parseJSDocThisType(); case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: + case 123 /* StringKeyword */: + case 121 /* NumberKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: case 99 /* VoidKeyword */: return parseTokenNode(); } return parseJSDocTypeReference(); } function parseJSDocThisType() { - var result = createNode(244 /* JSDocThisType */); + var result = createNode(246 /* JSDocThisType */); nextToken(); parseExpected(51 /* ColonToken */); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocConstructorType() { - var result = createNode(243 /* JSDocConstructorType */); + var result = createNode(245 /* JSDocConstructorType */); nextToken(); parseExpected(51 /* ColonToken */); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocVariadicType() { - var result = createNode(242 /* JSDocVariadicType */); + var result = createNode(244 /* JSDocVariadicType */); nextToken(); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocFunctionType() { - var result = createNode(241 /* JSDocFunctionType */); + var result = createNode(243 /* JSDocFunctionType */); nextToken(); parseExpected(16 /* OpenParenToken */); - result.parameters = parseDelimitedList(21 /* JSDocFunctionParameters */, parseJSDocParameter); + result.parameters = parseDelimitedList(20 /* JSDocFunctionParameters */, parseJSDocParameter); checkForTrailingComma(result.parameters); parseExpected(17 /* CloseParenToken */); if (token === 51 /* ColonToken */) { @@ -10910,18 +11246,18 @@ var ts; return finishNode(result); } function parseJSDocParameter() { - var parameter = createNode(130 /* Parameter */); + var parameter = createNode(131 /* Parameter */); parameter.type = parseJSDocType(); return finishNode(parameter); } function parseJSDocOptionalType(type) { - var result = createNode(240 /* JSDocOptionalType */, type.pos); + var result = createNode(242 /* JSDocOptionalType */, type.pos); nextToken(); result.type = type; return finishNode(result); } function parseJSDocTypeReference() { - var result = createNode(239 /* JSDocTypeReference */); + var result = createNode(241 /* JSDocTypeReference */); result.name = parseSimplePropertyName(); while (parseOptional(20 /* DotToken */)) { if (token === 24 /* LessThanToken */) { @@ -10937,7 +11273,7 @@ var ts; function parseTypeArguments() { // Move past the < nextToken(); - var typeArguments = parseDelimitedList(22 /* JSDocTypeArguments */, parseJSDocType); + var typeArguments = parseDelimitedList(21 /* JSDocTypeArguments */, parseJSDocType); checkForTrailingComma(typeArguments); checkForEmptyTypeArgumentList(typeArguments); parseExpected(25 /* GreaterThanToken */); @@ -10951,21 +11287,21 @@ var ts; } } function parseQualifiedName(left) { - var result = createNode(127 /* QualifiedName */, left.pos); + var result = createNode(128 /* QualifiedName */, left.pos); result.left = left; result.right = parseIdentifierName(); return finishNode(result); } function parseJSDocRecordType() { - var result = createNode(237 /* JSDocRecordType */); + var result = createNode(239 /* JSDocRecordType */); nextToken(); - result.members = parseDelimitedList(23 /* JSDocRecordMembers */, parseJSDocRecordMember); + result.members = parseDelimitedList(22 /* JSDocRecordMembers */, parseJSDocRecordMember); checkForTrailingComma(result.members); parseExpected(15 /* CloseBraceToken */); return finishNode(result); } function parseJSDocRecordMember() { - var result = createNode(238 /* JSDocRecordMember */); + var result = createNode(240 /* JSDocRecordMember */); result.name = parseSimplePropertyName(); if (token === 51 /* ColonToken */) { nextToken(); @@ -10974,15 +11310,15 @@ var ts; return finishNode(result); } function parseJSDocNonNullableType() { - var result = createNode(236 /* JSDocNonNullableType */); + var result = createNode(238 /* JSDocNonNullableType */); nextToken(); result.type = parseJSDocType(); return finishNode(result); } function parseJSDocTupleType() { - var result = createNode(234 /* JSDocTupleType */); + var result = createNode(236 /* JSDocTupleType */); nextToken(); - result.types = parseDelimitedList(24 /* JSDocTupleTypes */, parseJSDocType); + result.types = parseDelimitedList(23 /* JSDocTupleTypes */, parseJSDocType); checkForTrailingComma(result.types); parseExpected(19 /* CloseBracketToken */); return finishNode(result); @@ -10994,7 +11330,7 @@ var ts; } } function parseJSDocUnionType() { - var result = createNode(233 /* JSDocUnionType */); + var result = createNode(235 /* JSDocUnionType */); nextToken(); result.types = parseJSDocTypeList(parseJSDocType()); parseExpected(17 /* CloseParenToken */); @@ -11012,7 +11348,7 @@ var ts; return types; } function parseJSDocAllType() { - var result = createNode(230 /* JSDocAllType */); + var result = createNode(232 /* JSDocAllType */); nextToken(); return finishNode(result); } @@ -11035,11 +11371,11 @@ var ts; token === 25 /* GreaterThanToken */ || token === 53 /* EqualsToken */ || token === 44 /* BarToken */) { - var result = createNode(231 /* JSDocUnknownType */, pos); + var result = createNode(233 /* JSDocUnknownType */, pos); return finishNode(result); } else { - var result = createNode(235 /* JSDocNullableType */, pos); + var result = createNode(237 /* JSDocNullableType */, pos); result.type = parseJSDocType(); return finishNode(result); } @@ -11127,7 +11463,7 @@ var ts; if (!tags) { return undefined; } - var result = createNode(245 /* JSDocComment */, start); + var result = createNode(247 /* JSDocComment */, start); result.tags = tags; return finishNode(result, end); } @@ -11165,7 +11501,7 @@ var ts; return undefined; } function handleUnknownTag(atToken, tagName) { - var result = createNode(246 /* JSDocTag */, atToken.pos); + var result = createNode(248 /* JSDocTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; return finishNode(result, pos); @@ -11217,7 +11553,7 @@ var ts; if (!typeExpression) { typeExpression = tryParseTypeExpression(); } - var result = createNode(247 /* JSDocParameterTag */, atToken.pos); + var result = createNode(249 /* JSDocParameterTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.preParameterName = preName; @@ -11227,27 +11563,27 @@ var ts; return finishNode(result, pos); } function handleReturnTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 248 /* JSDocReturnTag */; })) { + if (ts.forEach(tags, function (t) { return t.kind === 250 /* JSDocReturnTag */; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } - var result = createNode(248 /* JSDocReturnTag */, atToken.pos); + var result = createNode(250 /* JSDocReturnTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeExpression = tryParseTypeExpression(); return finishNode(result, pos); } function handleTypeTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 249 /* JSDocTypeTag */; })) { + if (ts.forEach(tags, function (t) { return t.kind === 251 /* JSDocTypeTag */; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } - var result = createNode(249 /* JSDocTypeTag */, atToken.pos); + var result = createNode(251 /* JSDocTypeTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeExpression = tryParseTypeExpression(); return finishNode(result, pos); } function handleTemplateTag(atToken, tagName) { - if (ts.forEach(tags, function (t) { return t.kind === 250 /* JSDocTemplateTag */; })) { + if (ts.forEach(tags, function (t) { return t.kind === 252 /* JSDocTemplateTag */; })) { parseErrorAtPosition(tagName.pos, pos - tagName.pos, ts.Diagnostics._0_tag_already_specified, tagName.text); } var typeParameters = []; @@ -11260,7 +11596,7 @@ var ts; parseErrorAtPosition(startPos, 0, ts.Diagnostics.Identifier_expected); return undefined; } - var typeParameter = createNode(129 /* TypeParameter */, name_7.pos); + var typeParameter = createNode(130 /* TypeParameter */, name_7.pos); typeParameter.name = name_7; finishNode(typeParameter, pos); typeParameters.push(typeParameter); @@ -11271,7 +11607,7 @@ var ts; pos++; } typeParameters.end = pos; - var result = createNode(250 /* JSDocTemplateTag */, atToken.pos); + var result = createNode(252 /* JSDocTemplateTag */, atToken.pos); result.atToken = atToken; result.tagName = tagName; result.typeParameters = typeParameters; @@ -11857,8 +12193,8 @@ var ts; emptyGenericType.instantiations = {}; var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); - var anySignature = createSignature(undefined, undefined, emptyArray, anyType, 0, false, false); - var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, 0, false, false); + var anySignature = createSignature(undefined, undefined, emptyArray, anyType, undefined, 0, false, false); + var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, undefined, 0, false, false); var globals = {}; var globalESSymbolConstructorSymbol; var globalObjectType; @@ -11909,6 +12245,11 @@ var ts; flags: 2097152 /* ESSymbol */ } }; + var subtypeRelation = {}; + var assignableRelation = {}; + var identityRelation = {}; + initializeTypeChecker(); + return checker; function getEmitResolver(sourceFile) { // Ensure we have all the type information in place for this file so that all the // emitter questions of this resolver will return the right information. @@ -12051,10 +12392,10 @@ var ts; return nodeLinks[nodeId] || (nodeLinks[nodeId] = {}); } function getSourceFile(node) { - return ts.getAncestor(node, 228 /* SourceFile */); + return ts.getAncestor(node, 230 /* SourceFile */); } function isGlobalSourceFile(node) { - return node.kind === 228 /* SourceFile */ && !ts.isExternalModule(node); + return node.kind === 230 /* SourceFile */ && !ts.isExternalModule(node); } function getSymbol(symbols, name, meaning) { if (meaning && ts.hasProperty(symbols, name)) { @@ -12111,40 +12452,54 @@ var ts; } } switch (location.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (!ts.isExternalModule(location)) break; - case 206 /* ModuleDeclaration */: - if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931 /* ModuleMember */)) { - if (result.flags & meaning || !(result.flags & 8388608 /* Alias */ && getDeclarationOfAliasSymbol(result).kind === 218 /* ExportSpecifier */)) { - break loop; + case 208 /* ModuleDeclaration */: + var moduleExports = getSymbolOfNode(location).exports; + if (location.kind === 230 /* SourceFile */ || + (location.kind === 208 /* ModuleDeclaration */ && location.name.kind === 8 /* StringLiteral */)) { + // It's an external module. Because of module/namespace merging, a module's exports are in scope, + // yet we never want to treat an export specifier as putting a member in scope. Therefore, + // if the name we find is purely an export specifier, it is not actually considered in scope. + // Two things to note about this: + // 1. We have to check this without calling getSymbol. The problem with calling getSymbol + // on an export specifier is that it might find the export specifier itself, and try to + // resolve it as an alias. This will cause the checker to consider the export specifier + // a circular alias reference when it might not be. + // 2. We check === SymbolFlags.Alias in order to check that the symbol is *purely* + // an alias. If we used &, we'd be throwing out symbols that have non alias aspects, + // which is not the desired behavior. + if (ts.hasProperty(moduleExports, name) && + moduleExports[name].flags === 8388608 /* Alias */ && + ts.getDeclarationOfKind(moduleExports[name], 220 /* ExportSpecifier */)) { + break; } - result = undefined; - } - else if (location.kind === 228 /* SourceFile */ || - (location.kind === 206 /* ModuleDeclaration */ && location.name.kind === 8 /* StringLiteral */)) { - result = getSymbolOfNode(location).exports["default"]; + result = moduleExports["default"]; var localSymbol = ts.getLocalSymbolForExportDefault(result); if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) { break loop; } result = undefined; } + if (result = getSymbol(moduleExports, name, meaning & 8914931 /* ModuleMember */)) { + break loop; + } break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8 /* EnumMember */)) { break loop; } break; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: // TypeScript 1.0 spec (April 2014): 8.4.1 // Initializer expressions for instance member variables are evaluated in the scope // of the class constructor body but are not permitted to reference parameters or // local variables of the constructor. This effectively means that entities from outer scopes // by the same name as a constructor parameter or local variable are inaccessible // in initializer expressions for instance member variables. - if (location.parent.kind === 202 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) { + if (location.parent.kind === 204 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455 /* Value */)) { @@ -12154,8 +12509,8 @@ var ts; } } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056 /* Type */)) { if (lastLocation && lastLocation.flags & 128 /* Static */) { // TypeScript 1.0 spec (April 2014): 3.4.1 @@ -12175,9 +12530,9 @@ var ts; // [foo()]() { } // <-- Reference to T from class's own computed property // } // - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: grandparent = location.parent.parent; - if (grandparent.kind === 202 /* ClassDeclaration */ || grandparent.kind === 203 /* InterfaceDeclaration */) { + if (grandparent.kind === 204 /* ClassDeclaration */ || grandparent.kind === 205 /* InterfaceDeclaration */) { // A reference to this grandparent's type parameters would be an error if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056 /* Type */)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); @@ -12185,19 +12540,19 @@ var ts; } } break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: if (meaning & 3 /* Variable */ && name === "arguments") { result = argumentsSymbol; break loop; } break; - case 163 /* FunctionExpression */: + case 165 /* FunctionExpression */: if (meaning & 3 /* Variable */ && name === "arguments") { result = argumentsSymbol; break loop; @@ -12210,7 +12565,7 @@ var ts; } } break; - case 175 /* ClassExpression */: + case 177 /* ClassExpression */: if (meaning & 32 /* Class */) { var className = location.name; if (className && name === className.text) { @@ -12219,7 +12574,7 @@ var ts; } } break; - case 131 /* Decorator */: + case 132 /* Decorator */: // Decorators are resolved at the class declaration. Resolving at the parameter // or member would result in looking up locals in the method. // @@ -12228,7 +12583,7 @@ var ts; // method(@y x, y) {} // <-- decorator y should be resolved at the class declaration, not the parameter. // } // - if (location.parent && location.parent.kind === 130 /* Parameter */) { + if (location.parent && location.parent.kind === 131 /* Parameter */) { location = location.parent; } // @@ -12284,16 +12639,16 @@ var ts; // for (let x in x) // for (let x of x) // climb up to the variable declaration skipping binding patterns - var variableDeclaration = ts.getAncestor(declaration, 199 /* VariableDeclaration */); + var variableDeclaration = ts.getAncestor(declaration, 201 /* VariableDeclaration */); var container = ts.getEnclosingBlockScopeContainer(variableDeclaration); - if (variableDeclaration.parent.parent.kind === 181 /* VariableStatement */ || - variableDeclaration.parent.parent.kind === 187 /* ForStatement */) { + if (variableDeclaration.parent.parent.kind === 183 /* VariableStatement */ || + variableDeclaration.parent.parent.kind === 189 /* ForStatement */) { // variable statement/for statement case, // use site should not be inside variable declaration (initializer of declaration or binding element) isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, variableDeclaration, container); } - else if (variableDeclaration.parent.parent.kind === 189 /* ForOfStatement */ || - variableDeclaration.parent.parent.kind === 188 /* ForInStatement */) { + else if (variableDeclaration.parent.parent.kind === 191 /* ForOfStatement */ || + variableDeclaration.parent.parent.kind === 190 /* ForInStatement */) { // ForIn/ForOf case - use site should not be used in expression part var expression = variableDeclaration.parent.parent.expression; isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, expression, container); @@ -12320,10 +12675,10 @@ var ts; } function getAnyImportSyntax(node) { if (ts.isAliasSymbolDeclaration(node)) { - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 211 /* ImportEqualsDeclaration */) { return node; } - while (node && node.kind !== 210 /* ImportDeclaration */) { + while (node && node.kind !== 212 /* ImportDeclaration */) { node = node.parent; } return node; @@ -12333,7 +12688,7 @@ var ts; return ts.forEach(symbol.declarations, function (d) { return ts.isAliasSymbolDeclaration(d) ? d : undefined; }); } function getTargetOfImportEqualsDeclaration(node) { - if (node.moduleReference.kind === 220 /* ExternalModuleReference */) { + if (node.moduleReference.kind === 222 /* ExternalModuleReference */) { return resolveExternalModuleSymbol(resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node))); } return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); @@ -12440,17 +12795,17 @@ var ts; } function getTargetOfAliasDeclaration(node) { switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return getTargetOfImportEqualsDeclaration(node); - case 211 /* ImportClause */: + case 213 /* ImportClause */: return getTargetOfImportClause(node); - case 212 /* NamespaceImport */: + case 214 /* NamespaceImport */: return getTargetOfNamespaceImport(node); - case 214 /* ImportSpecifier */: + case 216 /* ImportSpecifier */: return getTargetOfImportSpecifier(node); - case 218 /* ExportSpecifier */: + case 220 /* ExportSpecifier */: return getTargetOfExportSpecifier(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return getTargetOfExportAssignment(node); } } @@ -12495,11 +12850,11 @@ var ts; if (!links.referenced) { links.referenced = true; var node = getDeclarationOfAliasSymbol(symbol); - if (node.kind === 215 /* ExportAssignment */) { + if (node.kind === 217 /* ExportAssignment */) { // export default checkExpressionCached(node.expression); } - else if (node.kind === 218 /* ExportSpecifier */) { + else if (node.kind === 220 /* ExportSpecifier */) { // export { } or export { as foo } checkExpressionCached(node.propertyName || node.name); } @@ -12512,7 +12867,7 @@ var ts; // This function is only for imports with entity names function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { if (!importDeclaration) { - importDeclaration = ts.getAncestor(entityName, 209 /* ImportEqualsDeclaration */); + importDeclaration = ts.getAncestor(entityName, 211 /* ImportEqualsDeclaration */); ts.Debug.assert(importDeclaration !== undefined); } // There are three things we might try to look for. In the following examples, @@ -12525,13 +12880,13 @@ var ts; entityName = entityName.parent; } // Check for case 1 and 3 in the above example - if (entityName.kind === 65 /* Identifier */ || entityName.parent.kind === 127 /* QualifiedName */) { + if (entityName.kind === 65 /* Identifier */ || entityName.parent.kind === 128 /* QualifiedName */) { return resolveEntityName(entityName, 1536 /* Namespace */); } else { // Case 2 in above example // entityName.kind could be a QualifiedName or a Missing identifier - ts.Debug.assert(entityName.parent.kind === 209 /* ImportEqualsDeclaration */); + ts.Debug.assert(entityName.parent.kind === 211 /* ImportEqualsDeclaration */); return resolveEntityName(entityName, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */); } } @@ -12551,9 +12906,9 @@ var ts; return undefined; } } - else if (name.kind === 127 /* QualifiedName */ || name.kind === 156 /* PropertyAccessExpression */) { - var left = name.kind === 127 /* QualifiedName */ ? name.left : name.expression; - var right = name.kind === 127 /* QualifiedName */ ? name.right : name.name; + else if (name.kind === 128 /* QualifiedName */ || name.kind === 158 /* PropertyAccessExpression */) { + var left = name.kind === 128 /* QualifiedName */ ? name.left : name.expression; + var right = name.kind === 128 /* QualifiedName */ ? name.right : name.name; var namespace = resolveEntityName(left, 1536 /* Namespace */); if (!namespace || namespace === unknownSymbol || ts.nodeIsMissing(right)) { return undefined; @@ -12714,7 +13069,7 @@ var ts; var members = node.members; for (var _i = 0; _i < members.length; _i++) { var member = members[_i]; - if (member.kind === 136 /* Constructor */ && ts.nodeIsPresent(member.body)) { + if (member.kind === 137 /* Constructor */ && ts.nodeIsPresent(member.body)) { return member; } } @@ -12784,17 +13139,17 @@ var ts; } } switch (location_1.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (!ts.isExternalModule(location_1)) { break; } - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: if (result = callback(getSymbolOfNode(location_1).exports)) { return result; } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: if (result = callback(getSymbolOfNode(location_1).members)) { return result; } @@ -12943,8 +13298,8 @@ var ts; } } function hasExternalModuleSymbol(declaration) { - return (declaration.kind === 206 /* ModuleDeclaration */ && declaration.name.kind === 8 /* StringLiteral */) || - (declaration.kind === 228 /* SourceFile */ && ts.isExternalModule(declaration)); + return (declaration.kind === 208 /* ModuleDeclaration */ && declaration.name.kind === 8 /* StringLiteral */) || + (declaration.kind === 230 /* SourceFile */ && ts.isExternalModule(declaration)); } function hasVisibleDeclarations(symbol) { var aliasesToMakeVisible; @@ -12980,12 +13335,12 @@ var ts; function isEntityNameVisible(entityName, enclosingDeclaration) { // get symbol of the first identifier of the entityName var meaning; - if (entityName.parent.kind === 145 /* TypeQuery */) { + if (entityName.parent.kind === 147 /* TypeQuery */) { // Typeof value meaning = 107455 /* Value */ | 1048576 /* ExportValue */; } - else if (entityName.kind === 127 /* QualifiedName */ || entityName.kind === 156 /* PropertyAccessExpression */ || - entityName.parent.kind === 209 /* ImportEqualsDeclaration */) { + else if (entityName.kind === 128 /* QualifiedName */ || entityName.kind === 158 /* PropertyAccessExpression */ || + entityName.parent.kind === 211 /* ImportEqualsDeclaration */) { // Left identifier from type reference or TypeAlias // Entity name of the import declaration meaning = 1536 /* Namespace */; @@ -13019,6 +13374,13 @@ var ts; ts.releaseStringWriter(writer); return result; } + function signatureToString(signature, enclosingDeclaration, flags) { + var writer = ts.getSingleLineStringWriter(); + getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); + var result = writer.string(); + ts.releaseStringWriter(writer); + return result; + } function typeToString(type, enclosingDeclaration, flags) { var writer = ts.getSingleLineStringWriter(); getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); @@ -13033,10 +13395,10 @@ var ts; function getTypeAliasForTypeLiteral(type) { if (type.symbol && type.symbol.flags & 2048 /* TypeLiteral */) { var node = type.symbol.declarations[0].parent; - while (node.kind === 150 /* ParenthesizedType */) { + while (node.kind === 152 /* ParenthesizedType */) { node = node.parent; } - if (node.kind === 204 /* TypeAliasDeclaration */) { + if (node.kind === 206 /* TypeAliasDeclaration */) { return getSymbolOfNode(node); } } @@ -13286,7 +13648,7 @@ var ts; var isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) && (symbol.parent || ts.forEach(symbol.declarations, function (declaration) { - return declaration.parent.kind === 228 /* SourceFile */ || declaration.parent.kind === 207 /* ModuleBlock */; + return declaration.parent.kind === 230 /* SourceFile */ || declaration.parent.kind === 209 /* ModuleBlock */; })); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { // typeof is allowed only for static/non local functions @@ -13364,7 +13726,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 0 /* String */, "x")); writePunctuation(writer, 51 /* ColonToken */); writeSpace(writer); - writeKeyword(writer, 122 /* StringKeyword */); + writeKeyword(writer, 123 /* StringKeyword */); writePunctuation(writer, 19 /* CloseBracketToken */); writePunctuation(writer, 51 /* ColonToken */); writeSpace(writer); @@ -13378,7 +13740,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 1 /* Number */, "x")); writePunctuation(writer, 51 /* ColonToken */); writeSpace(writer); - writeKeyword(writer, 120 /* NumberKeyword */); + writeKeyword(writer, 121 /* NumberKeyword */); writePunctuation(writer, 19 /* CloseBracketToken */); writePunctuation(writer, 51 /* ColonToken */); writeSpace(writer); @@ -13421,7 +13783,7 @@ var ts; function buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaraiton, flags) { var targetSymbol = getTargetSymbol(symbol); if (targetSymbol.flags & 32 /* Class */ || targetSymbol.flags & 64 /* Interface */) { - buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags); + buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), writer, enclosingDeclaraiton, flags); } } function buildTypeParameterDisplay(tp, writer, enclosingDeclaration, flags, symbolStack) { @@ -13525,12 +13887,12 @@ var ts; function isDeclarationVisible(node) { function getContainingExternalModule(node) { for (; node; node = node.parent) { - if (node.kind === 206 /* ModuleDeclaration */) { + if (node.kind === 208 /* ModuleDeclaration */) { if (node.name.kind === 8 /* StringLiteral */) { return node; } } - else if (node.kind === 228 /* SourceFile */) { + else if (node.kind === 230 /* SourceFile */) { return ts.isExternalModule(node) ? node : undefined; } } @@ -13579,69 +13941,69 @@ var ts; } function determineIfDeclarationIsVisible() { switch (node.kind) { - case 153 /* BindingElement */: + case 155 /* BindingElement */: return isDeclarationVisible(node.parent.parent); - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: if (ts.isBindingPattern(node.name) && !node.name.elements.length) { // If the binding pattern is empty, this variable declaration is not visible return false; } // Otherwise fall through - case 206 /* ModuleDeclaration */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 201 /* FunctionDeclaration */: - case 205 /* EnumDeclaration */: - case 209 /* ImportEqualsDeclaration */: + case 208 /* ModuleDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 203 /* FunctionDeclaration */: + case 207 /* EnumDeclaration */: + case 211 /* ImportEqualsDeclaration */: var parent_4 = getDeclarationContainer(node); // If the node is not exported or it is not ambient module element (except import declaration) if (!(ts.getCombinedNodeFlags(node) & 1 /* Export */) && - !(node.kind !== 209 /* ImportEqualsDeclaration */ && parent_4.kind !== 228 /* SourceFile */ && ts.isInAmbientContext(parent_4))) { + !(node.kind !== 211 /* ImportEqualsDeclaration */ && parent_4.kind !== 230 /* SourceFile */ && ts.isInAmbientContext(parent_4))) { return isGlobalSourceFile(parent_4); } // Exported members/ambient module elements (exception import declaration) are visible if parent is visible return isDeclarationVisible(parent_4); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (node.flags & (32 /* Private */ | 64 /* Protected */)) { // Private/protected properties/methods are not visible return false; } // Public properties/methods are visible if its parents are visible, so let it fall into next case statement - case 136 /* Constructor */: - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 141 /* IndexSignature */: - case 130 /* Parameter */: - case 207 /* ModuleBlock */: - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 146 /* TypeLiteral */: - case 142 /* TypeReference */: - case 147 /* ArrayType */: - case 148 /* TupleType */: - case 149 /* UnionType */: - case 150 /* ParenthesizedType */: + case 137 /* Constructor */: + case 141 /* ConstructSignature */: + case 140 /* CallSignature */: + case 142 /* IndexSignature */: + case 131 /* Parameter */: + case 209 /* ModuleBlock */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 148 /* TypeLiteral */: + case 144 /* TypeReference */: + case 149 /* ArrayType */: + case 150 /* TupleType */: + case 151 /* UnionType */: + case 152 /* ParenthesizedType */: return isDeclarationVisible(node.parent); // Default binding, import specifier and namespace import is visible // only on demand so by default it is not visible - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: + case 213 /* ImportClause */: + case 214 /* NamespaceImport */: + case 216 /* ImportSpecifier */: return false; // Type parameters are always visible - case 129 /* TypeParameter */: + case 130 /* TypeParameter */: // Source file is always visible - case 228 /* SourceFile */: + case 230 /* SourceFile */: return true; // Export assignements do not create name bindings outside the module - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return false; default: ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); @@ -13657,10 +14019,10 @@ var ts; } function collectLinkedAliases(node) { var exportSymbol; - if (node.parent && node.parent.kind === 215 /* ExportAssignment */) { + if (node.parent && node.parent.kind === 217 /* ExportAssignment */) { exportSymbol = resolveName(node.parent, node.text, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */, ts.Diagnostics.Cannot_find_name_0, node); } - else if (node.parent.kind === 218 /* ExportSpecifier */) { + else if (node.parent.kind === 220 /* ExportSpecifier */) { exportSymbol = getTargetOfExportSpecifier(node.parent); } var result = []; @@ -13718,7 +14080,7 @@ var ts; node = ts.getRootDeclaration(node); // Parent chain: // VaribleDeclaration -> VariableDeclarationList -> VariableStatement -> 'Declaration Container' - return node.kind === 199 /* VariableDeclaration */ ? node.parent.parent.parent : node.parent; + return node.kind === 201 /* VariableDeclaration */ ? node.parent.parent.parent : node.parent; } function getTypeOfPrototypeProperty(prototype) { // TypeScript 1.0 spec (April 2014): 8.4 @@ -13754,7 +14116,7 @@ var ts; return parentType; } var type; - if (pattern.kind === 151 /* ObjectBindingPattern */) { + if (pattern.kind === 153 /* ObjectBindingPattern */) { // Use explicitly specified property name ({ p: xxx } form), or otherwise the implied name ({ p } form) var name_9 = declaration.propertyName || declaration.name; // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature, @@ -13801,10 +14163,10 @@ var ts; // Return the inferred type for a variable, parameter, or property declaration function getTypeForVariableLikeDeclaration(declaration) { // A variable declared in a for..in statement is always of type any - if (declaration.parent.parent.kind === 188 /* ForInStatement */) { + if (declaration.parent.parent.kind === 190 /* ForInStatement */) { return anyType; } - if (declaration.parent.parent.kind === 189 /* ForOfStatement */) { + if (declaration.parent.parent.kind === 191 /* ForOfStatement */) { // checkRightHandSideOfForOf will return undefined if the for-of expression type was // missing properties/signatures required to get its iteratedType (like // [Symbol.iterator] or next). This may be because we accessed properties from anyType, @@ -13818,11 +14180,11 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130 /* Parameter */) { + if (declaration.kind === 131 /* Parameter */) { var func = declaration.parent; // For a parameter of a set accessor, use the type of the get accessor if one is present - if (func.kind === 138 /* SetAccessor */ && !ts.hasDynamicName(func)) { - var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 137 /* GetAccessor */); + if (func.kind === 139 /* SetAccessor */ && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 138 /* GetAccessor */); if (getter) { return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); } @@ -13838,7 +14200,7 @@ var ts; return checkExpressionCached(declaration.initializer); } // If it is a short-hand property assignment, use the type of the identifier - if (declaration.kind === 226 /* ShorthandPropertyAssignment */) { + if (declaration.kind === 228 /* ShorthandPropertyAssignment */) { return checkIdentifier(declaration.name); } // No type specified and nothing can be inferred @@ -13873,7 +14235,7 @@ var ts; var hasSpreadElement = false; var elementTypes = []; ts.forEach(pattern.elements, function (e) { - elementTypes.push(e.kind === 176 /* OmittedExpression */ || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + elementTypes.push(e.kind === 178 /* OmittedExpression */ || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); if (e.dotDotDotToken) { hasSpreadElement = true; } @@ -13896,7 +14258,7 @@ var ts; // parameter with no type annotation or initializer, the type implied by the binding pattern becomes the type of // the parameter. function getTypeFromBindingPattern(pattern) { - return pattern.kind === 151 /* ObjectBindingPattern */ + return pattern.kind === 153 /* ObjectBindingPattern */ ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); } @@ -13918,7 +14280,7 @@ var ts; // During a normal type check we'll never get to here with a property assignment (the check of the containing // object literal uses a different path). We exclude widening only so that language services and type verification // tools see the actual type. - return declaration.kind !== 225 /* PropertyAssignment */ ? getWidenedType(type) : type; + return declaration.kind !== 227 /* PropertyAssignment */ ? getWidenedType(type) : type; } // If no type was specified and nothing could be inferred, and if the declaration specifies a binding pattern, use // the type implied by the binding pattern @@ -13930,7 +14292,7 @@ var ts; // Report implicit any errors unless this is a private property within an ambient declaration if (reportErrors && compilerOptions.noImplicitAny) { var root = ts.getRootDeclaration(declaration); - if (!isPrivateWithinAmbient(root) && !(root.kind === 130 /* Parameter */ && isPrivateWithinAmbient(root.parent))) { + if (!isPrivateWithinAmbient(root) && !(root.kind === 131 /* Parameter */ && isPrivateWithinAmbient(root.parent))) { reportImplicitAnyError(declaration, type); } } @@ -13945,11 +14307,11 @@ var ts; } // Handle catch clause variables var declaration = symbol.valueDeclaration; - if (declaration.parent.kind === 224 /* CatchClause */) { + if (declaration.parent.kind === 226 /* CatchClause */) { return links.type = anyType; } // Handle export default expressions - if (declaration.kind === 215 /* ExportAssignment */) { + if (declaration.kind === 217 /* ExportAssignment */) { return links.type = checkExpression(declaration.expression); } // Handle variable, parameter or property @@ -13980,7 +14342,7 @@ var ts; } function getAnnotatedAccessorType(accessor) { if (accessor) { - if (accessor.kind === 137 /* GetAccessor */) { + if (accessor.kind === 138 /* GetAccessor */) { return accessor.type && getTypeFromTypeNode(accessor.type); } else { @@ -13996,8 +14358,8 @@ var ts; if (!pushTypeResolution(symbol)) { return unknownType; } - var getter = ts.getDeclarationOfKind(symbol, 137 /* GetAccessor */); - var setter = ts.getDeclarationOfKind(symbol, 138 /* SetAccessor */); + var getter = ts.getDeclarationOfKind(symbol, 138 /* GetAccessor */); + var setter = ts.getDeclarationOfKind(symbol, 139 /* SetAccessor */); var type; // First try to see if the user specified a return type on the get-accessor. var getterReturnType = getAnnotatedAccessorType(getter); @@ -14026,7 +14388,7 @@ var ts; if (!popTypeResolution()) { type = anyType; if (compilerOptions.noImplicitAny) { - var getter_1 = ts.getDeclarationOfKind(symbol, 137 /* GetAccessor */); + var getter_1 = ts.getDeclarationOfKind(symbol, 138 /* GetAccessor */); error(getter_1, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); } } @@ -14126,9 +14488,9 @@ var ts; if (!node) { return typeParameters; } - if (node.kind === 202 /* ClassDeclaration */ || node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */ || node.kind === 135 /* MethodDeclaration */ || - node.kind === 164 /* ArrowFunction */) { + if (node.kind === 204 /* ClassDeclaration */ || node.kind === 203 /* FunctionDeclaration */ || + node.kind === 165 /* FunctionExpression */ || node.kind === 136 /* MethodDeclaration */ || + node.kind === 166 /* ArrowFunction */) { var declarations = node.typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); @@ -14138,15 +14500,16 @@ var ts; } // The outer type parameters are those defined by enclosing generic classes, methods, or functions. function getOuterTypeParametersOfClassOrInterface(symbol) { - var kind = symbol.flags & 32 /* Class */ ? 202 /* ClassDeclaration */ : 203 /* InterfaceDeclaration */; + var kind = symbol.flags & 32 /* Class */ ? 204 /* ClassDeclaration */ : 205 /* InterfaceDeclaration */; return appendOuterTypeParameters(undefined, ts.getDeclarationOfKind(symbol, kind)); } - // The local type parameters are the combined set of type parameters from all declarations of the class or interface. - function getLocalTypeParametersOfClassOrInterface(symbol) { + // The local type parameters are the combined set of type parameters from all declarations of the class, + // interface, or type alias. + function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) { var result; for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { var node = _a[_i]; - if (node.kind === 203 /* InterfaceDeclaration */ || node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 205 /* InterfaceDeclaration */ || node.kind === 204 /* ClassDeclaration */ || node.kind === 206 /* TypeAliasDeclaration */) { var declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -14158,56 +14521,122 @@ var ts; // The full set of type parameters for a generic class or interface type consists of its outer type parameters plus // its locally declared type parameters. function getTypeParametersOfClassOrInterface(symbol) { - return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterface(symbol)); + return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol)); + } + function isConstructorType(type) { + return type.flags & 48128 /* ObjectType */ && getSignaturesOfType(type, 1 /* Construct */).length > 0; + } + function getBaseTypeNodeOfClass(type) { + return ts.getClassExtendsHeritageClauseElement(type.symbol.valueDeclaration); + } + function getConstructorsForTypeArguments(type, typeArgumentNodes) { + var typeArgCount = typeArgumentNodes ? typeArgumentNodes.length : 0; + return ts.filter(getSignaturesOfType(type, 1 /* Construct */), function (sig) { return (sig.typeParameters ? sig.typeParameters.length : 0) === typeArgCount; }); + } + function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes) { + var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes); + if (typeArgumentNodes) { + var typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode); + signatures = ts.map(signatures, function (sig) { return getSignatureInstantiation(sig, typeArguments); }); + } + return signatures; + } + // The base constructor of a class can resolve to + // undefinedType if the class has no extends clause, + // unknownType if an error occurred during resolution of the extends expression, + // nullType if the extends expression is the null value, or + // an object type with at least one construct signature. + function getBaseConstructorTypeOfClass(type) { + if (!type.resolvedBaseConstructorType) { + var baseTypeNode = getBaseTypeNodeOfClass(type); + if (!baseTypeNode) { + return type.resolvedBaseConstructorType = undefinedType; + } + if (!pushTypeResolution(type)) { + return unknownType; + } + var baseConstructorType = checkExpression(baseTypeNode.expression); + if (baseConstructorType.flags & 48128 /* ObjectType */) { + // Resolving the members of a class requires us to resolve the base class of that class. + // We force resolution here such that we catch circularities now. + resolveObjectOrUnionTypeMembers(baseConstructorType); + } + if (!popTypeResolution()) { + error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol)); + return type.resolvedBaseConstructorType = unknownType; + } + if (baseConstructorType !== unknownType && baseConstructorType !== nullType && !isConstructorType(baseConstructorType)) { + error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType)); + return type.resolvedBaseConstructorType = unknownType; + } + type.resolvedBaseConstructorType = baseConstructorType; + } + return type.resolvedBaseConstructorType; } function getBaseTypes(type) { - var typeWithBaseTypes = type; - if (!typeWithBaseTypes.baseTypes) { + if (!type.resolvedBaseTypes) { if (type.symbol.flags & 32 /* Class */) { - resolveBaseTypesOfClass(typeWithBaseTypes); + resolveBaseTypesOfClass(type); } else if (type.symbol.flags & 64 /* Interface */) { - resolveBaseTypesOfInterface(typeWithBaseTypes); + resolveBaseTypesOfInterface(type); } else { ts.Debug.fail("type must be class or interface"); } } - return typeWithBaseTypes.baseTypes; + return type.resolvedBaseTypes; } function resolveBaseTypesOfClass(type) { - type.baseTypes = []; - var declaration = ts.getDeclarationOfKind(type.symbol, 202 /* ClassDeclaration */); - var baseTypeNode = ts.getClassExtendsHeritageClauseElement(declaration); - if (baseTypeNode) { - var baseType = getTypeFromTypeNode(baseTypeNode); - if (baseType !== unknownType) { - if (getTargetType(baseType).flags & 1024 /* Class */) { - if (type !== baseType && !hasBaseType(baseType, type)) { - type.baseTypes.push(baseType); - } - else { - error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */)); - } - } - else { - error(baseTypeNode, ts.Diagnostics.A_class_may_only_extend_another_class); - } - } + type.resolvedBaseTypes = emptyArray; + var baseContructorType = getBaseConstructorTypeOfClass(type); + if (!(baseContructorType.flags & 48128 /* ObjectType */)) { + return; } + var baseTypeNode = getBaseTypeNodeOfClass(type); + var baseType; + if (baseContructorType.symbol && baseContructorType.symbol.flags & 32 /* Class */) { + // When base constructor type is a class we know that the constructors all have the same type parameters as the + // class and all return the instance type of the class. There is no need for further checks and we can apply the + // type arguments in the same manner as a type reference to get the same error reporting experience. + baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseContructorType.symbol); + } + else { + // The class derives from a "class-like" constructor function, check that we have at least one construct signature + // with a matching number of type parameters and use the return type of the first instantiated signature. Elsewhere + // we check that all instantiated signatures return the same type. + var constructors = getInstantiatedConstructorsForTypeArguments(baseContructorType, baseTypeNode.typeArguments); + if (!constructors.length) { + error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments); + return; + } + baseType = getReturnTypeOfSignature(constructors[0]); + } + if (baseType === unknownType) { + return; + } + if (!(getTargetType(baseType).flags & (1024 /* Class */ | 2048 /* Interface */))) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructor_return_type_0_is_not_a_class_or_interface_type, typeToString(baseType)); + return; + } + if (type === baseType || hasBaseType(baseType, type)) { + error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */)); + return; + } + type.resolvedBaseTypes = [baseType]; } function resolveBaseTypesOfInterface(type) { - type.baseTypes = []; + type.resolvedBaseTypes = []; for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { var declaration = _a[_i]; - if (declaration.kind === 203 /* InterfaceDeclaration */ && ts.getInterfaceBaseTypeNodes(declaration)) { + if (declaration.kind === 205 /* InterfaceDeclaration */ && ts.getInterfaceBaseTypeNodes(declaration)) { for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) { var node = _c[_b]; var baseType = getTypeFromTypeNode(node); if (baseType !== unknownType) { if (getTargetType(baseType).flags & (1024 /* Class */ | 2048 /* Interface */)) { if (type !== baseType && !hasBaseType(baseType, type)) { - type.baseTypes.push(baseType); + type.resolvedBaseTypes.push(baseType); } else { error(declaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */)); @@ -14227,7 +14656,7 @@ var ts; var kind = symbol.flags & 32 /* Class */ ? 1024 /* Class */ : 2048 /* Interface */; var type = links.declaredType = createObjectType(kind, symbol); var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol); - var localTypeParameters = getLocalTypeParametersOfClassOrInterface(symbol); + var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); if (outerTypeParameters || localTypeParameters) { type.flags |= 4096 /* Reference */; type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters); @@ -14249,9 +14678,18 @@ var ts; if (!pushTypeResolution(links)) { return unknownType; } - var declaration = ts.getDeclarationOfKind(symbol, 204 /* TypeAliasDeclaration */); + var declaration = ts.getDeclarationOfKind(symbol, 206 /* TypeAliasDeclaration */); var type = getTypeFromTypeNode(declaration.type); - if (!popTypeResolution()) { + if (popTypeResolution()) { + links.typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (links.typeParameters) { + // Initialize the instantiation cache for generic type aliases. The declared type corresponds to + // an instantiation of the type alias with the type parameters supplied as type arguments. + links.instantiations = {}; + links.instantiations[getTypeListId(links.typeParameters)] = type; + } + } + else { type = unknownType; error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } @@ -14273,7 +14711,7 @@ var ts; if (!links.declaredType) { var type = createType(512 /* TypeParameter */); type.symbol = symbol; - if (!ts.getDeclarationOfKind(symbol, 129 /* TypeParameter */).constraint) { + if (!ts.getDeclarationOfKind(symbol, 130 /* TypeParameter */).constraint) { type.constraint = noConstraintType; } links.declaredType = type; @@ -14388,34 +14826,42 @@ var ts; }); setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } - function createSignature(declaration, typeParameters, parameters, resolvedReturnType, minArgumentCount, hasRestParameter, hasStringLiterals) { + function createSignature(declaration, typeParameters, parameters, resolvedReturnType, typePredicate, minArgumentCount, hasRestParameter, hasStringLiterals) { var sig = new Signature(checker); sig.declaration = declaration; sig.typeParameters = typeParameters; sig.parameters = parameters; sig.resolvedReturnType = resolvedReturnType; + sig.typePredicate = typePredicate; sig.minArgumentCount = minArgumentCount; sig.hasRestParameter = hasRestParameter; sig.hasStringLiterals = hasStringLiterals; return sig; } function cloneSignature(sig) { - return createSignature(sig.declaration, sig.typeParameters, sig.parameters, sig.resolvedReturnType, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); + return createSignature(sig.declaration, sig.typeParameters, sig.parameters, sig.resolvedReturnType, sig.typePredicate, sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals); } function getDefaultConstructSignatures(classType) { - var baseTypes = getBaseTypes(classType); - if (baseTypes.length) { - var baseType = baseTypes[0]; - var baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), 1 /* Construct */); - return ts.map(baseSignatures, function (baseSignature) { - var signature = baseType.flags & 4096 /* Reference */ ? - getSignatureInstantiation(baseSignature, baseType.typeArguments) : cloneSignature(baseSignature); - signature.typeParameters = classType.localTypeParameters; - signature.resolvedReturnType = classType; - return signature; - }); + if (!getBaseTypes(classType).length) { + return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)]; } - return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, 0, false, false)]; + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + var baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */); + var baseTypeNode = getBaseTypeNodeOfClass(classType); + var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode); + var typeArgCount = typeArguments ? typeArguments.length : 0; + var result = []; + for (var _i = 0; _i < baseSignatures.length; _i++) { + var baseSig = baseSignatures[_i]; + var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0; + if (typeParamCount === typeArgCount) { + var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig); + sig.typeParameters = classType.localTypeParameters; + sig.resolvedReturnType = classType; + result.push(sig); + } + } + return result; } function createTupleTypeMemberSymbols(memberTypes) { var members = {}; @@ -14521,10 +14967,10 @@ var ts; if (!constructSignatures.length) { constructSignatures = getDefaultConstructSignatures(classType); } - var baseTypes = getBaseTypes(classType); - if (baseTypes.length) { + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + if (baseConstructorType.flags & 48128 /* ObjectType */) { members = createSymbolTable(getNamedMembers(members)); - addInheritedMembers(members, getPropertiesOfObjectType(getTypeOfSymbol(baseTypes[0].symbol))); + addInheritedMembers(members, getPropertiesOfObjectType(baseConstructorType)); } } stringIndexType = undefined; @@ -14745,7 +15191,7 @@ var ts; function getSignatureFromDeclaration(declaration) { var links = getNodeLinks(declaration); if (!links.resolvedSignature) { - var classType = declaration.kind === 136 /* Constructor */ ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; + var classType = declaration.kind === 137 /* Constructor */ ? getDeclaredTypeOfClassOrInterface(declaration.parent.symbol) : undefined; var typeParameters = classType ? classType.localTypeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; var parameters = []; @@ -14767,24 +15213,33 @@ var ts; minArgumentCount = declaration.parameters.length; } var returnType; + var typePredicate; if (classType) { returnType = classType; } else if (declaration.type) { returnType = getTypeFromTypeNode(declaration.type); + if (declaration.type.kind === 143 /* TypePredicate */) { + var typePredicateNode = declaration.type; + typePredicate = { + parameterName: typePredicateNode.parameterName ? typePredicateNode.parameterName.text : undefined, + parameterIndex: typePredicateNode.parameterName ? getTypePredicateParameterIndex(declaration.parameters, typePredicateNode.parameterName) : undefined, + type: getTypeFromTypeNode(typePredicateNode.type) + }; + } } else { // TypeScript 1.0 spec (April 2014): // If only one accessor includes a type annotation, the other behaves as if it had the same type annotation. - if (declaration.kind === 137 /* GetAccessor */ && !ts.hasDynamicName(declaration)) { - var setter = ts.getDeclarationOfKind(declaration.symbol, 138 /* SetAccessor */); + if (declaration.kind === 138 /* GetAccessor */ && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 139 /* SetAccessor */); returnType = getAnnotatedAccessorType(setter); } if (!returnType && ts.nodeIsMissing(declaration.body)) { returnType = anyType; } } - links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals); + links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, typePredicate, minArgumentCount, ts.hasRestParameter(declaration), hasStringLiterals); } return links.resolvedSignature; } @@ -14795,19 +15250,19 @@ var ts; for (var i = 0, len = symbol.declarations.length; i < len; i++) { var node = symbol.declarations[i]; switch (node.kind) { - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: // Don't include signature if node is the implementation of an overloaded function. A node is considered // an implementation node if it has a body and the previous node is of the same kind and immediately // precedes the implementation node (i.e. has the same parent and ends where the implementation starts). @@ -14884,7 +15339,7 @@ var ts; // object type literal or interface (using the new keyword). Each way of declaring a constructor // will result in a different declaration kind. if (!signature.isolatedSignatureType) { - var isConstructor = signature.declaration.kind === 136 /* Constructor */ || signature.declaration.kind === 140 /* ConstructSignature */; + var isConstructor = signature.declaration.kind === 137 /* Constructor */ || signature.declaration.kind === 141 /* ConstructSignature */; var type = createObjectType(32768 /* Anonymous */ | 131072 /* FromSignature */); type.members = emptySymbols; type.properties = emptyArray; @@ -14898,7 +15353,7 @@ var ts; return symbol.members["__index"]; } function getIndexDeclarationOfSymbol(symbol, kind) { - var syntaxKind = kind === 1 /* Number */ ? 120 /* NumberKeyword */ : 122 /* StringKeyword */; + var syntaxKind = kind === 1 /* Number */ ? 121 /* NumberKeyword */ : 123 /* StringKeyword */; var indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { var len = indexSymbol.declarations.length; @@ -14928,13 +15383,13 @@ var ts; type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; } else { - type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 129 /* TypeParameter */).constraint); + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 130 /* TypeParameter */).constraint); } } return type.constraint === noConstraintType ? undefined : type.constraint; } function getParentSymbolOfTypeParameter(typeParameter) { - return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 129 /* TypeParameter */).parent); + return getSymbolOfNode(ts.getDeclarationOfKind(typeParameter.symbol, 130 /* TypeParameter */).parent); } function getTypeListId(types) { switch (types.length) { @@ -14987,13 +15442,13 @@ var ts; currentNode = currentNode.parent; } // if last step was made from the type parameter this means that path has started somewhere in constraint which is illegal - links.isIllegalTypeReferenceInConstraint = currentNode.kind === 129 /* TypeParameter */; + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 130 /* TypeParameter */; return links.isIllegalTypeReferenceInConstraint; } function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { var typeParameterSymbol; function check(n) { - if (n.kind === 142 /* TypeReference */ && n.typeName.kind === 65 /* Identifier */) { + if (n.kind === 144 /* TypeReference */ && n.typeName.kind === 65 /* Identifier */) { var links = getNodeLinks(n); if (links.isIllegalTypeReferenceInConstraint === undefined) { var symbol = resolveName(typeParameter, n.typeName.text, 793056 /* Type */, undefined, undefined); @@ -15005,7 +15460,7 @@ var ts; // -> typeParameter and symbol.declaration originate from the same type parameter list // -> illegal for all declarations in symbol // forEach === exists - links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent == typeParameter.parent; }); + links.isIllegalTypeReferenceInConstraint = ts.forEach(symbol.declarations, function (d) { return d.parent === typeParameter.parent; }); } } if (links.isIllegalTypeReferenceInConstraint) { @@ -15019,62 +15474,82 @@ var ts; check(typeParameter.constraint); } } - function getTypeFromTypeReferenceOrExpressionWithTypeArguments(node) { - var links = getNodeLinks(node); - if (!links.resolvedType) { - var type; - // We don't currently support heritage clauses with complex expressions in them. - // For these cases, we just set the type to be the unknownType. - if (node.kind !== 177 /* ExpressionWithTypeArguments */ || ts.isSupportedExpressionWithTypeArguments(node)) { - var typeNameOrExpression = node.kind === 142 /* TypeReference */ - ? node.typeName - : node.expression; - var symbol = resolveEntityName(typeNameOrExpression, 793056 /* Type */); - if (symbol) { - if ((symbol.flags & 262144 /* TypeParameter */) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { - // TypeScript 1.0 spec (April 2014): 3.4.1 - // Type parameters declared in a particular type parameter list - // may not be referenced in constraints in that type parameter list - // Implementation: such type references are resolved to 'unknown' type that usually denotes error - type = unknownType; - } - else { - type = createTypeReferenceIfGeneric(getDeclaredTypeOfSymbol(symbol), node, node.typeArguments); - } - } + // Get type from reference to class or interface + function getTypeFromClassOrInterfaceReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var typeParameters = type.localTypeParameters; + if (typeParameters) { + if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */), typeParameters.length); + return unknownType; } - links.resolvedType = type || unknownType; - } - return links.resolvedType; - } - function createTypeReferenceIfGeneric(type, node, typeArguments) { - if (type.flags & (1024 /* Class */ | 2048 /* Interface */) && type.flags & 4096 /* Reference */) { // In a type reference, the outer type parameters of the referenced class or interface are automatically // supplied as type arguments and the type reference only specifies arguments for the local type parameters // of the class or interface. - var localTypeParameters = type.localTypeParameters; - var expectedTypeArgCount = localTypeParameters ? localTypeParameters.length : 0; - var typeArgCount = typeArguments ? typeArguments.length : 0; - if (typeArgCount === expectedTypeArgCount) { - // When no type arguments are expected we already have the right type because all outer type parameters - // have themselves as default type arguments. - if (typeArgCount) { - return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(typeArguments, getTypeFromTypeNode))); - } - } - else { - error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1 /* WriteArrayAsGenericType */), expectedTypeArgCount); - return undefined; - } + return createTypeReference(type, ts.concatenate(type.outerTypeParameters, ts.map(node.typeArguments, getTypeFromTypeNode))); } - else { - if (typeArguments) { - error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); - return undefined; - } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); + return unknownType; } return type; } + // Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include + // references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the + // declared type. Instantiations are cached using the type identities of the type arguments as the key. + function getTypeFromTypeAliasReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(symbol); + var links = getSymbolLinks(symbol); + var typeParameters = links.typeParameters; + if (typeParameters) { + if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, symbolToString(symbol), typeParameters.length); + return unknownType; + } + var typeArguments = ts.map(node.typeArguments, getTypeFromTypeNode); + var id = getTypeListId(typeArguments); + return links.instantiations[id] || (links.instantiations[id] = instantiateType(type, createTypeMapper(typeParameters, typeArguments))); + } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol)); + return unknownType; + } + return type; + } + // Get type from reference to named type that cannot be generic (enum or type parameter) + function getTypeFromNonGenericTypeReference(node, symbol) { + if (symbol.flags & 262144 /* TypeParameter */ && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { + // TypeScript 1.0 spec (April 2014): 3.4.1 + // Type parameters declared in a particular type parameter list + // may not be referenced in constraints in that type parameter list + // Implementation: such type references are resolved to 'unknown' type that usually denotes error + return unknownType; + } + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbolToString(symbol)); + return unknownType; + } + return getDeclaredTypeOfSymbol(symbol); + } + function getTypeFromTypeReference(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + // We only support expressions that are simple qualified names. For other expressions this produces undefined. + var typeNameOrExpression = node.kind === 144 /* TypeReference */ ? node.typeName : + ts.isSupportedExpressionWithTypeArguments(node) ? node.expression : + undefined; + var symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, 793056 /* Type */) || unknownSymbol; + var type = symbol === unknownSymbol ? unknownType : + symbol.flags & (32 /* Class */ | 64 /* Interface */) ? getTypeFromClassOrInterfaceReference(node, symbol) : + symbol.flags & 524288 /* TypeAlias */ ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); + // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the + // type reference in checkTypeReferenceOrExpressionWithTypeArguments. + links.resolvedSymbol = symbol; + links.resolvedType = type; + } + return links.resolvedType; + } function getTypeFromTypeQueryNode(node) { var links = getNodeLinks(node); if (!links.resolvedType) { @@ -15082,7 +15557,7 @@ var ts; // The expression is processed as an identifier expression (section 4.3) // or property access expression(section 4.10), // the widened type(section 3.9) of which becomes the result. - links.resolvedType = getWidenedType(checkExpressionOrQualifiedName(node.exprName)); + links.resolvedType = getWidenedType(checkExpression(node.exprName)); } return links.resolvedType; } @@ -15092,9 +15567,9 @@ var ts; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; switch (declaration.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: return declaration; } } @@ -15307,40 +15782,42 @@ var ts; switch (node.kind) { case 112 /* AnyKeyword */: return anyType; - case 122 /* StringKeyword */: + case 123 /* StringKeyword */: return stringType; - case 120 /* NumberKeyword */: + case 121 /* NumberKeyword */: return numberType; case 113 /* BooleanKeyword */: return booleanType; - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: return esSymbolType; case 99 /* VoidKeyword */: return voidType; case 8 /* StringLiteral */: return getTypeFromStringLiteral(node); - case 142 /* TypeReference */: - return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 177 /* ExpressionWithTypeArguments */: - return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); - case 145 /* TypeQuery */: + case 144 /* TypeReference */: + return getTypeFromTypeReference(node); + case 143 /* TypePredicate */: + return booleanType; + case 179 /* ExpressionWithTypeArguments */: + return getTypeFromTypeReference(node); + case 147 /* TypeQuery */: return getTypeFromTypeQueryNode(node); - case 147 /* ArrayType */: + case 149 /* ArrayType */: return getTypeFromArrayTypeNode(node); - case 148 /* TupleType */: + case 150 /* TupleType */: return getTypeFromTupleTypeNode(node); - case 149 /* UnionType */: + case 151 /* UnionType */: return getTypeFromUnionTypeNode(node); - case 150 /* ParenthesizedType */: + case 152 /* ParenthesizedType */: return getTypeFromTypeNode(node.type); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 146 /* TypeLiteral */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 148 /* TypeLiteral */: return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); // This function assumes that an identifier or qualified name is a type expression // Callers should first ensure this by calling isTypeNode case 65 /* Identifier */: - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: var symbol = getSymbolInfo(node); return symbol && getDeclaredTypeOfSymbol(symbol); default: @@ -15430,11 +15907,19 @@ var ts; } function instantiateSignature(signature, mapper, eraseTypeParameters) { var freshTypeParameters; + var freshTypePredicate; if (signature.typeParameters && !eraseTypeParameters) { freshTypeParameters = instantiateList(signature.typeParameters, mapper, instantiateTypeParameter); mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper); } - var result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); + if (signature.typePredicate) { + freshTypePredicate = { + parameterName: signature.typePredicate.parameterName, + parameterIndex: signature.typePredicate.parameterIndex, + type: instantiateType(signature.typePredicate.type, mapper) + }; + } + var result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, freshTypePredicate, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); result.target = signature; result.mapper = mapper; return result; @@ -15499,27 +15984,27 @@ var ts; // Returns true if the given expression contains (at any level of nesting) a function or arrow expression // that is subject to contextual typing. function isContextSensitive(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); switch (node.kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: return isContextSensitiveFunctionLikeDeclaration(node); - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return ts.forEach(node.properties, isContextSensitive); - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return ts.forEach(node.elements, isContextSensitive); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return node.operatorToken.kind === 49 /* BarBarToken */ && (isContextSensitive(node.left) || isContextSensitive(node.right)); - case 225 /* PropertyAssignment */: + case 227 /* PropertyAssignment */: return isContextSensitive(node.initializer); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return isContextSensitiveFunctionLikeDeclaration(node); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return isContextSensitive(node.expression); } return false; @@ -15527,14 +16012,14 @@ var ts; function isContextSensitiveFunctionLikeDeclaration(node) { return !node.typeParameters && node.parameters.length && !ts.forEach(node.parameters, function (p) { return p.type; }); } - function getTypeWithoutConstructors(type) { + function getTypeWithoutSignatures(type) { if (type.flags & 48128 /* ObjectType */) { var resolved = resolveObjectOrUnionTypeMembers(type); if (resolved.constructSignatures.length) { var result = createObjectType(32768 /* Anonymous */, type.symbol); result.members = resolved.members; result.properties = resolved.properties; - result.callSignatures = resolved.callSignatures; + result.callSignatures = emptyArray; result.constructSignatures = emptyArray; type = result; } @@ -15542,9 +16027,6 @@ var ts; return type; } // TYPE CHECKING - var subtypeRelation = {}; - var assignableRelation = {}; - var identityRelation = {}; function isTypeIdenticalTo(source, target) { return checkTypeRelatedTo(source, target, identityRelation, undefined); } @@ -15821,9 +16303,9 @@ var ts; maybeStack[depth][id] = 1 /* Succeeded */; depth++; var saveExpandingFlags = expandingFlags; - if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack)) + if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack, depth)) expandingFlags |= 1; - if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack)) + if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack, depth)) expandingFlags |= 2; var result; if (expandingFlags === 3) { @@ -15859,27 +16341,6 @@ var ts; } return result; } - // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case - // when structural type comparisons have been started for 10 or more instantiations of the same generic type. It is possible, - // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely expanding. - // Effectively, we will generate a false positive when two types are structurally equal to at least 10 levels, but unequal at - // some level beyond that. - function isDeeplyNestedGeneric(type, stack) { - // We track type references (created by createTypeReference) and instantiated types (created by instantiateType) - if (type.flags & (4096 /* Reference */ | 65536 /* Instantiated */) && depth >= 10) { - var symbol = type.symbol; - var count = 0; - for (var i = 0; i < depth; i++) { - var t = stack[i]; - if (t.flags & (4096 /* Reference */ | 65536 /* Instantiated */) && t.symbol === symbol) { - count++; - if (count >= 10) - return true; - } - } - } - return false; - } function propertiesRelatedTo(source, target, reportErrors) { if (relation === identityRelation) { return propertiesIdenticalTo(source, target); @@ -16060,6 +16521,33 @@ var ts; } result &= related; } + if (source.typePredicate && target.typePredicate) { + var hasDifferentParameterIndex = source.typePredicate.parameterIndex !== target.typePredicate.parameterIndex; + var hasDifferentTypes; + if (hasDifferentParameterIndex || + (hasDifferentTypes = !isTypeIdenticalTo(source.typePredicate.type, target.typePredicate.type))) { + if (reportErrors) { + var sourceParamText = source.typePredicate.parameterName; + var targetParamText = target.typePredicate.parameterName; + var sourceTypeText = typeToString(source.typePredicate.type); + var targetTypeText = typeToString(target.typePredicate.type); + if (hasDifferentParameterIndex) { + reportError(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, sourceParamText, targetParamText); + } + else if (hasDifferentTypes) { + reportError(ts.Diagnostics.Type_0_is_not_assignable_to_type_1, sourceTypeText, targetTypeText); + } + reportError(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, sourceParamText + " is " + sourceTypeText, targetParamText + " is " + targetTypeText); + } + return 0 /* False */; + } + } + else if (!source.typePredicate && target.typePredicate) { + if (reportErrors) { + reportError(ts.Diagnostics.Signature_0_must_have_a_type_predicate, signatureToString(source)); + } + return 0 /* False */; + } var t = getReturnTypeOfSignature(target); if (t === voidType) return result; @@ -16150,6 +16638,27 @@ var ts; return 0 /* False */; } } + // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case + // when structural type comparisons have been started for 10 or more instantiations of the same generic type. It is possible, + // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely expanding. + // Effectively, we will generate a false positive when two types are structurally equal to at least 10 levels, but unequal at + // some level beyond that. + function isDeeplyNestedGeneric(type, stack, depth) { + // We track type references (created by createTypeReference) and instantiated types (created by instantiateType) + if (type.flags & (4096 /* Reference */ | 65536 /* Instantiated */) && depth >= 5) { + var symbol = type.symbol; + var count = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (t.flags & (4096 /* Reference */ | 65536 /* Instantiated */) && t.symbol === symbol) { + count++; + if (count >= 5) + return true; + } + } + } + return false; + } function isPropertyIdenticalTo(sourceProp, targetProp) { return compareProperties(sourceProp, targetProp, compareTypes) !== 0 /* False */; } @@ -16356,22 +16865,22 @@ var ts; var typeAsString = typeToString(getWidenedType(type)); var diagnostic; switch (declaration.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; break; - case 130 /* Parameter */: + case 131 /* Parameter */: diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; break; - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: if (!declaration.name) { error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); return; @@ -16444,20 +16953,6 @@ var ts; } return false; } - function isWithinDepthLimit(type, stack) { - if (depth >= 5) { - var target_1 = type.target; - var count = 0; - for (var i = 0; i < depth; i++) { - var t = stack[i]; - if (t.flags & 4096 /* Reference */ && t.target === target_1) { - count++; - } - } - return count < 5; - } - return true; - } function inferFromTypes(source, target) { if (source === anyFunctionType) { return; @@ -16527,22 +17022,26 @@ var ts; else if (source.flags & 48128 /* ObjectType */ && (target.flags & (4096 /* Reference */ | 8192 /* Tuple */) || (target.flags & 32768 /* Anonymous */) && target.symbol && target.symbol.flags & (8192 /* Method */ | 2048 /* TypeLiteral */))) { // If source is an object type, and target is a type reference, a tuple type, the type of a method, or a type literal, infer from members - if (!isInProcess(source, target) && isWithinDepthLimit(source, sourceStack) && isWithinDepthLimit(target, targetStack)) { - if (depth === 0) { - sourceStack = []; - targetStack = []; - } - sourceStack[depth] = source; - targetStack[depth] = target; - depth++; - inferFromProperties(source, target); - inferFromSignatures(source, target, 0 /* Call */); - inferFromSignatures(source, target, 1 /* Construct */); - inferFromIndexTypes(source, target, 0 /* String */, 0 /* String */); - inferFromIndexTypes(source, target, 1 /* Number */, 1 /* Number */); - inferFromIndexTypes(source, target, 0 /* String */, 1 /* Number */); - depth--; + if (isInProcess(source, target)) { + return; } + if (isDeeplyNestedGeneric(source, sourceStack, depth) && isDeeplyNestedGeneric(target, targetStack, depth)) { + return; + } + if (depth === 0) { + sourceStack = []; + targetStack = []; + } + sourceStack[depth] = source; + targetStack[depth] = target; + depth++; + inferFromProperties(source, target); + inferFromSignatures(source, target, 0 /* Call */); + inferFromSignatures(source, target, 1 /* Construct */); + inferFromIndexTypes(source, target, 0 /* String */, 0 /* String */); + inferFromIndexTypes(source, target, 1 /* Number */, 1 /* Number */); + inferFromIndexTypes(source, target, 0 /* String */, 1 /* Number */); + depth--; } } function inferFromProperties(source, target) { @@ -16567,7 +17066,17 @@ var ts; } function inferFromSignature(source, target) { forEachMatchingParameterType(source, target, inferFromTypes); - inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + if (source.typePredicate && target.typePredicate) { + if (target.typePredicate.parameterIndex === source.typePredicate.parameterIndex) { + // Return types from type predicates are treated as booleans. In order to infer types + // from type predicates we would need to infer using the type within the type predicate + // (i.e. 'Foo' from 'x is Foo'). + inferFromTypes(source.typePredicate.type, target.typePredicate.type); + } + } + else { + inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } } function inferFromIndexTypes(source, target, sourceKind, targetKind) { var targetIndexType = getIndexTypeOfType(target, targetKind); @@ -16640,10 +17149,10 @@ var ts; // The expression is restricted to a single identifier or a sequence of identifiers separated by periods while (node) { switch (node.kind) { - case 145 /* TypeQuery */: + case 147 /* TypeQuery */: return true; case 65 /* Identifier */: - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: node = node.parent; continue; default: @@ -16691,7 +17200,7 @@ var ts; function isAssignedInBinaryExpression(node) { if (node.operatorToken.kind >= 53 /* FirstAssignment */ && node.operatorToken.kind <= 64 /* LastAssignment */) { var n = node.left; - while (n.kind === 162 /* ParenthesizedExpression */) { + while (n.kind === 164 /* ParenthesizedExpression */) { n = n.expression; } if (n.kind === 65 /* Identifier */ && getResolvedSymbol(n) === symbol) { @@ -16708,46 +17217,46 @@ var ts; } function isAssignedIn(node) { switch (node.kind) { - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return isAssignedInBinaryExpression(node); - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: return isAssignedInVariableDeclaration(node); - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 168 /* PrefixUnaryExpression */: - case 165 /* DeleteExpression */: - case 166 /* TypeOfExpression */: - case 167 /* VoidExpression */: - case 169 /* PostfixUnaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 180 /* Block */: - case 181 /* VariableStatement */: - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 192 /* ReturnStatement */: - case 193 /* WithStatement */: - case 194 /* SwitchStatement */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 196 /* ThrowStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: + case 156 /* ArrayLiteralExpression */: + case 157 /* ObjectLiteralExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 163 /* TypeAssertionExpression */: + case 164 /* ParenthesizedExpression */: + case 170 /* PrefixUnaryExpression */: + case 167 /* DeleteExpression */: + case 168 /* TypeOfExpression */: + case 169 /* VoidExpression */: + case 171 /* PostfixUnaryExpression */: + case 173 /* ConditionalExpression */: + case 176 /* SpreadElementExpression */: + case 182 /* Block */: + case 183 /* VariableStatement */: + case 185 /* ExpressionStatement */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 194 /* ReturnStatement */: + case 195 /* WithStatement */: + case 196 /* SwitchStatement */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: + case 197 /* LabeledStatement */: + case 198 /* ThrowStatement */: + case 199 /* TryStatement */: + case 226 /* CatchClause */: return ts.forEachChild(node, isAssignedIn); } return false; @@ -16800,19 +17309,19 @@ var ts; node = node.parent; var narrowedType = type; switch (node.kind) { - case 184 /* IfStatement */: + case 186 /* IfStatement */: // In a branch of an if statement, narrow based on controlling expression if (child !== node.expression) { narrowedType = narrowType(type, node.expression, child === node.thenStatement); } break; - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: // In a branch of a conditional expression, narrow based on controlling condition if (child !== node.condition) { narrowedType = narrowType(type, node.condition, child === node.whenTrue); } break; - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: // In the right operand of an && or ||, narrow based on left operand if (child === node.right) { if (node.operatorToken.kind === 48 /* AmpersandAmpersandToken */) { @@ -16823,14 +17332,14 @@ var ts; } } break; - case 228 /* SourceFile */: - case 206 /* ModuleDeclaration */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: + case 230 /* SourceFile */: + case 208 /* ModuleDeclaration */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 137 /* Constructor */: // Stop at the first containing function or module declaration break loop; } @@ -16847,7 +17356,7 @@ var ts; return type; function narrowTypeByEquality(type, expr, assumeTrue) { // Check that we have 'typeof ' on the left and string literal on the right - if (expr.left.kind !== 166 /* TypeOfExpression */ || expr.right.kind !== 8 /* StringLiteral */) { + if (expr.left.kind !== 168 /* TypeOfExpression */ || expr.right.kind !== 8 /* StringLiteral */) { return type; } var left = expr.left; @@ -16923,7 +17432,7 @@ var ts; var targetType; var prototypeProperty = getPropertyOfType(rightType, "prototype"); if (prototypeProperty) { - // Target type is type of the protoype property + // Target type is type of the prototype property var prototypePropertyType = getTypeOfSymbol(prototypeProperty); if (!isTypeAny(prototypePropertyType)) { targetType = prototypePropertyType; @@ -16943,14 +17452,36 @@ var ts; } } if (targetType) { - // Narrow to the target type if it's a subtype of the current type - if (isTypeSubtypeOf(targetType, type)) { - return targetType; - } - // If the current type is a union type, remove all constituents that aren't subtypes of the target. - if (type.flags & 16384 /* Union */) { - return getUnionType(ts.filter(type.types, function (t) { return isTypeSubtypeOf(t, targetType); })); + return getNarrowedType(type, targetType); + } + return type; + } + function getNarrowedType(originalType, narrowedTypeCandidate) { + // Narrow to the target type if it's a subtype of the current type + if (isTypeSubtypeOf(narrowedTypeCandidate, originalType)) { + return narrowedTypeCandidate; + } + // If the current type is a union type, remove all constituents that aren't subtypes of the target. + if (originalType.flags & 16384 /* Union */) { + return getUnionType(ts.filter(originalType.types, function (t) { return isTypeSubtypeOf(t, narrowedTypeCandidate); })); + } + return originalType; + } + function narrowTypeByTypePredicate(type, expr, assumeTrue) { + if (type.flags & 1 /* Any */) { + return type; + } + var signature = getResolvedSignature(expr); + if (signature.typePredicate && + expr.arguments[signature.typePredicate.parameterIndex] && + getSymbolAtLocation(expr.arguments[signature.typePredicate.parameterIndex]) === symbol) { + if (!assumeTrue) { + if (type.flags & 16384 /* Union */) { + return getUnionType(ts.filter(type.types, function (t) { return !isTypeSubtypeOf(t, signature.typePredicate.type); })); + } + return type; } + return getNarrowedType(type, signature.typePredicate.type); } return type; } @@ -16958,9 +17489,11 @@ var ts; // will be a subtype or the same type as the argument. function narrowType(type, expr, assumeTrue) { switch (expr.kind) { - case 162 /* ParenthesizedExpression */: + case 160 /* CallExpression */: + return narrowTypeByTypePredicate(type, expr, assumeTrue); + case 164 /* ParenthesizedExpression */: return narrowType(type, expr.expression, assumeTrue); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: var operator = expr.operatorToken.kind; if (operator === 30 /* EqualsEqualsEqualsToken */ || operator === 31 /* ExclamationEqualsEqualsToken */) { return narrowTypeByEquality(type, expr, assumeTrue); @@ -16975,7 +17508,7 @@ var ts; return narrowTypeByInstanceof(type, expr, assumeTrue); } break; - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: if (expr.operator === 46 /* ExclamationToken */) { return narrowType(type, expr.operand, !assumeTrue); } @@ -16992,7 +17525,7 @@ var ts; // will be bound to non-arrow function that contain this arrow function. This results in inconsistent behavior. // To avoid that we will give an error to users if they use arguments objects in arrow function so that they // can explicitly bound arguments objects - if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 164 /* ArrowFunction */ && languageVersion < 2 /* ES6 */) { + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 166 /* ArrowFunction */ && languageVersion < 2 /* ES6 */) { error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); } if (symbol.flags & 8388608 /* Alias */ && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) { @@ -17016,7 +17549,7 @@ var ts; function checkBlockScopedBindingCapturedInLoop(node, symbol) { if (languageVersion >= 2 /* ES6 */ || (symbol.flags & 2 /* BlockScopedVariable */) === 0 || - symbol.valueDeclaration.parent.kind === 224 /* CatchClause */) { + symbol.valueDeclaration.parent.kind === 226 /* CatchClause */) { return; } // - check if binding is used in some function @@ -17025,12 +17558,12 @@ var ts; // nesting structure: // (variable declaration or binding element) -> variable declaration list -> container var container = symbol.valueDeclaration; - while (container.kind !== 200 /* VariableDeclarationList */) { + while (container.kind !== 202 /* VariableDeclarationList */) { container = container.parent; } // get the parent of variable declaration list container = container.parent; - if (container.kind === 181 /* VariableStatement */) { + if (container.kind === 183 /* VariableStatement */) { // if parent is variable statement - get its parent container = container.parent; } @@ -17049,9 +17582,9 @@ var ts; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 202 /* ClassDeclaration */ ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 204 /* ClassDeclaration */ ? container.parent : undefined; getNodeLinks(node).flags |= 2 /* LexicalThis */; - if (container.kind === 133 /* PropertyDeclaration */ || container.kind === 136 /* Constructor */) { + if (container.kind === 134 /* PropertyDeclaration */ || container.kind === 137 /* Constructor */) { getNodeLinks(classNode).flags |= 4 /* CaptureThis */; } else { @@ -17064,39 +17597,39 @@ var ts; var container = ts.getThisContainer(node, true); var needToCaptureLexicalThis = false; // Now skip arrow functions to get the "real" owner of 'this'. - if (container.kind === 164 /* ArrowFunction */) { + if (container.kind === 166 /* ArrowFunction */) { container = ts.getThisContainer(container, false); // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code needToCaptureLexicalThis = (languageVersion < 2 /* ES6 */); } switch (container.kind) { - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body); // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks break; - case 136 /* Constructor */: + case 137 /* Constructor */: if (isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); } break; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: if (container.flags & 128 /* Static */) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); } break; - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name); break; } if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 202 /* ClassDeclaration */ ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 204 /* ClassDeclaration */ ? container.parent : undefined; if (classNode) { var symbol = getSymbolOfNode(classNode); return container.flags & 128 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); @@ -17105,23 +17638,21 @@ var ts; } function isInConstructorArgumentInitializer(node, constructorDecl) { for (var n = node; n && n !== constructorDecl; n = n.parent) { - if (n.kind === 130 /* Parameter */) { + if (n.kind === 131 /* Parameter */) { return true; } } return false; } function checkSuperExpression(node) { - var isCallExpression = node.parent.kind === 158 /* CallExpression */ && node.parent.expression === node; - var enclosingClass = ts.getAncestor(node, 202 /* ClassDeclaration */); - var baseClass; - if (enclosingClass && ts.getClassExtendsHeritageClauseElement(enclosingClass)) { - var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); - var baseTypes = getBaseTypes(classType); - baseClass = baseTypes.length && baseTypes[0]; - } - if (!baseClass) { - error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + var isCallExpression = node.parent.kind === 160 /* CallExpression */ && node.parent.expression === node; + var classDeclaration = ts.getAncestor(node, 204 /* ClassDeclaration */); + var classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); + var baseClassType = classType && getBaseTypes(classType)[0]; + if (!baseClassType) { + if (!classDeclaration || !ts.getClassExtendsHeritageClauseElement(classDeclaration)) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + } return unknownType; } var container = ts.getSuperContainer(node, true); @@ -17131,7 +17662,7 @@ var ts; if (isCallExpression) { // TS 1.0 SPEC (April 2014): 4.8.1 // Super calls are only permitted in constructors of derived classes - canUseSuperExpression = container.kind === 136 /* Constructor */; + canUseSuperExpression = container.kind === 137 /* Constructor */; } else { // TS 1.0 SPEC (April 2014) @@ -17140,28 +17671,28 @@ var ts; // - In a static member function or static member accessor // super property access might appear in arrow functions with arbitrary deep nesting needToCaptureLexicalThis = false; - while (container && container.kind === 164 /* ArrowFunction */) { + while (container && container.kind === 166 /* ArrowFunction */) { container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = languageVersion < 2 /* ES6 */; } // topmost container must be something that is directly nested in the class declaration - if (container && container.parent && container.parent.kind === 202 /* ClassDeclaration */) { + if (container && container.parent && container.parent.kind === 204 /* ClassDeclaration */) { if (container.flags & 128 /* Static */) { canUseSuperExpression = - container.kind === 135 /* MethodDeclaration */ || - container.kind === 134 /* MethodSignature */ || - container.kind === 137 /* GetAccessor */ || - container.kind === 138 /* SetAccessor */; + container.kind === 136 /* MethodDeclaration */ || + container.kind === 135 /* MethodSignature */ || + container.kind === 138 /* GetAccessor */ || + container.kind === 139 /* SetAccessor */; } else { canUseSuperExpression = - container.kind === 135 /* MethodDeclaration */ || - container.kind === 134 /* MethodSignature */ || - container.kind === 137 /* GetAccessor */ || - container.kind === 138 /* SetAccessor */ || - container.kind === 133 /* PropertyDeclaration */ || - container.kind === 132 /* PropertySignature */ || - container.kind === 136 /* Constructor */; + container.kind === 136 /* MethodDeclaration */ || + container.kind === 135 /* MethodSignature */ || + container.kind === 138 /* GetAccessor */ || + container.kind === 139 /* SetAccessor */ || + container.kind === 134 /* PropertyDeclaration */ || + container.kind === 133 /* PropertySignature */ || + container.kind === 137 /* Constructor */; } } } @@ -17169,13 +17700,13 @@ var ts; var returnType; if ((container.flags & 128 /* Static */) || isCallExpression) { getNodeLinks(node).flags |= 32 /* SuperStatic */; - returnType = getTypeOfSymbol(baseClass.symbol); + returnType = getBaseConstructorTypeOfClass(classType); } else { getNodeLinks(node).flags |= 16 /* SuperInstance */; - returnType = baseClass; + returnType = baseClassType; } - if (container.kind === 136 /* Constructor */ && isInConstructorArgumentInitializer(node, container)) { + if (container.kind === 137 /* Constructor */ && isInConstructorArgumentInitializer(node, container)) { // issue custom error message for super property access in constructor arguments (to be aligned with old compiler) error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); returnType = unknownType; @@ -17189,7 +17720,7 @@ var ts; return returnType; } } - if (container && container.kind === 128 /* ComputedPropertyName */) { + if (container && container.kind === 129 /* ComputedPropertyName */) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); } else if (isCallExpression) { @@ -17234,7 +17765,7 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 130 /* Parameter */) { + if (declaration.kind === 131 /* Parameter */) { var type = getContextuallyTypedParameterType(declaration); if (type) { return type; @@ -17269,8 +17800,8 @@ var ts; // If the containing function has a return type annotation, is a constructor, or is a get accessor whose // corresponding set accessor has a type annotation, return statements in the function are contextually typed if (functionDecl.type || - functionDecl.kind === 136 /* Constructor */ || - functionDecl.kind === 137 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 138 /* SetAccessor */))) { + functionDecl.kind === 137 /* Constructor */ || + functionDecl.kind === 138 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(functionDecl.symbol, 139 /* SetAccessor */))) { return getReturnTypeOfSignature(getSignatureFromDeclaration(functionDecl)); } // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature @@ -17292,7 +17823,7 @@ var ts; return undefined; } function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { - if (template.parent.kind === 160 /* TaggedTemplateExpression */) { + if (template.parent.kind === 162 /* TaggedTemplateExpression */) { return getContextualTypeForArgument(template.parent, substitutionExpression); } return undefined; @@ -17423,34 +17954,34 @@ var ts; } var parent = node.parent; switch (parent.kind) { - case 199 /* VariableDeclaration */: - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 131 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 155 /* BindingElement */: return getContextualTypeForInitializerExpression(node); - case 164 /* ArrowFunction */: - case 192 /* ReturnStatement */: + case 166 /* ArrowFunction */: + case 194 /* ReturnStatement */: return getContextualTypeForReturnExpression(node); - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: return getContextualTypeForYieldOperand(parent); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return getContextualTypeForArgument(parent, node); - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return getTypeFromTypeNode(parent.type); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return getContextualTypeForBinaryOperand(node); - case 225 /* PropertyAssignment */: + case 227 /* PropertyAssignment */: return getContextualTypeForObjectLiteralElement(parent); - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return getContextualTypeForElementExpression(node); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return getContextualTypeForConditionalOperand(node); - case 178 /* TemplateSpan */: - ts.Debug.assert(parent.parent.kind === 172 /* TemplateExpression */); + case 180 /* TemplateSpan */: + ts.Debug.assert(parent.parent.kind === 174 /* TemplateExpression */); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return getContextualType(parent); } return undefined; @@ -17467,7 +17998,7 @@ var ts; } } function isFunctionExpressionOrArrowFunction(node) { - return node.kind === 163 /* FunctionExpression */ || node.kind === 164 /* ArrowFunction */; + return node.kind === 165 /* FunctionExpression */ || node.kind === 166 /* ArrowFunction */; } function getContextualSignatureForFunctionLikeDeclaration(node) { // Only function expressions, arrow functions, and object literal methods are contextually typed. @@ -17481,7 +18012,7 @@ var ts; // all identical ignoring their return type, the result is same signature but with return type as // union type of return types from these signatures function getContextualSignature(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); @@ -17537,13 +18068,13 @@ var ts; // an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ p: a}] = xxx'. function isAssignmentTarget(node) { var parent = node.parent; - if (parent.kind === 170 /* BinaryExpression */ && parent.operatorToken.kind === 53 /* EqualsToken */ && parent.left === node) { + if (parent.kind === 172 /* BinaryExpression */ && parent.operatorToken.kind === 53 /* EqualsToken */ && parent.left === node) { return true; } - if (parent.kind === 225 /* PropertyAssignment */) { + if (parent.kind === 227 /* PropertyAssignment */) { return isAssignmentTarget(parent.parent); } - if (parent.kind === 154 /* ArrayLiteralExpression */) { + if (parent.kind === 156 /* ArrayLiteralExpression */) { return isAssignmentTarget(parent); } return false; @@ -17568,7 +18099,7 @@ var ts; var inDestructuringPattern = isAssignmentTarget(node); for (var _i = 0; _i < elements.length; _i++) { var e = elements[_i]; - if (inDestructuringPattern && e.kind === 174 /* SpreadElementExpression */) { + if (inDestructuringPattern && e.kind === 176 /* SpreadElementExpression */) { // Given the following situation: // var c: {}; // [...c] = ["", 0]; @@ -17592,7 +18123,7 @@ var ts; var type = checkExpression(e, contextualMapper); elementTypes.push(type); } - hasSpreadElement = hasSpreadElement || e.kind === 174 /* SpreadElementExpression */; + hasSpreadElement = hasSpreadElement || e.kind === 176 /* SpreadElementExpression */; } if (!hasSpreadElement) { var contextualType = getContextualType(node); @@ -17603,7 +18134,7 @@ var ts; return createArrayType(getUnionType(elementTypes)); } function isNumericName(name) { - return name.kind === 128 /* ComputedPropertyName */ ? isNumericComputedName(name) : isNumericLiteralName(name.text); + return name.kind === 129 /* ComputedPropertyName */ ? isNumericComputedName(name) : isNumericLiteralName(name.text); } function isNumericComputedName(name) { // It seems odd to consider an expression of type Any to result in a numeric name, @@ -17662,18 +18193,18 @@ var ts; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var memberDecl = _a[_i]; var member = memberDecl.symbol; - if (memberDecl.kind === 225 /* PropertyAssignment */ || - memberDecl.kind === 226 /* ShorthandPropertyAssignment */ || + if (memberDecl.kind === 227 /* PropertyAssignment */ || + memberDecl.kind === 228 /* ShorthandPropertyAssignment */ || ts.isObjectLiteralMethod(memberDecl)) { var type = void 0; - if (memberDecl.kind === 225 /* PropertyAssignment */) { + if (memberDecl.kind === 227 /* PropertyAssignment */) { type = checkPropertyAssignment(memberDecl, contextualMapper); } - else if (memberDecl.kind === 135 /* MethodDeclaration */) { + else if (memberDecl.kind === 136 /* MethodDeclaration */) { type = checkObjectLiteralMethod(memberDecl, contextualMapper); } else { - ts.Debug.assert(memberDecl.kind === 226 /* ShorthandPropertyAssignment */); + ts.Debug.assert(memberDecl.kind === 228 /* ShorthandPropertyAssignment */); type = checkExpression(memberDecl.name, contextualMapper); } typeFlags |= type.flags; @@ -17693,7 +18224,7 @@ var ts; // an ordinary function declaration(section 6.1) with no parameters. // A set accessor declaration is processed in the same manner // as an ordinary function declaration with a single parameter and a Void return type. - ts.Debug.assert(memberDecl.kind === 137 /* GetAccessor */ || memberDecl.kind === 138 /* SetAccessor */); + ts.Debug.assert(memberDecl.kind === 138 /* GetAccessor */ || memberDecl.kind === 139 /* SetAccessor */); checkAccessorDeclaration(memberDecl); } if (!ts.hasDynamicName(memberDecl)) { @@ -17732,7 +18263,7 @@ var ts; // If a symbol is a synthesized symbol with no value declaration, we assume it is a property. Example of this are the synthesized // '.prototype' property as well as synthesized tuple index properties. function getDeclarationKindFromSymbol(s) { - return s.valueDeclaration ? s.valueDeclaration.kind : 133 /* PropertyDeclaration */; + return s.valueDeclaration ? s.valueDeclaration.kind : 134 /* PropertyDeclaration */; } function getDeclarationFlagsFromSymbol(s) { return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 16 /* Public */ | 128 /* Static */ : 0; @@ -17745,7 +18276,7 @@ var ts; } // Property is known to be private or protected at this point // Get the declaring and enclosing class instance types - var enclosingClassDeclaration = ts.getAncestor(node, 202 /* ClassDeclaration */); + var enclosingClassDeclaration = ts.getAncestor(node, 204 /* ClassDeclaration */); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); // Private property is accessible if declaring and enclosing class are the same @@ -17781,7 +18312,7 @@ var ts; return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right); } function checkPropertyAccessExpressionOrQualifiedName(node, left, right) { - var type = checkExpressionOrQualifiedName(left); + var type = checkExpression(left); if (isTypeAny(type)) { return type; } @@ -17806,7 +18337,7 @@ var ts; // - In a static member function or static member accessor // where this references the constructor function object of a derived class, // a super property access is permitted and must specify a public static member function of the base class. - if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 135 /* MethodDeclaration */) { + if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 136 /* MethodDeclaration */) { error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { @@ -17816,14 +18347,14 @@ var ts; return getTypeOfSymbol(prop); } function isValidPropertyAccess(node, propertyName) { - var left = node.kind === 156 /* PropertyAccessExpression */ + var left = node.kind === 158 /* PropertyAccessExpression */ ? node.expression : node.left; - var type = checkExpressionOrQualifiedName(left); + var type = checkExpression(left); if (type !== unknownType && !isTypeAny(type)) { var prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & 32 /* Class */) { - if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 135 /* MethodDeclaration */) { + if (left.kind === 91 /* SuperKeyword */ && getDeclarationKindFromSymbol(prop) !== 136 /* MethodDeclaration */) { return false; } else { @@ -17839,7 +18370,7 @@ var ts; // Grammar checking if (!node.argumentExpression) { var sourceFile = getSourceFile(node); - if (node.parent.kind === 159 /* NewExpression */ && node.parent.expression === node) { + if (node.parent.kind === 161 /* NewExpression */ && node.parent.expression === node) { var start = ts.skipTrivia(sourceFile.text, node.expression.end); var end = node.end; grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead); @@ -17968,7 +18499,7 @@ var ts; return true; } function resolveUntypedCall(node) { - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 162 /* TaggedTemplateExpression */) { checkExpression(node.template); } else { @@ -18036,7 +18567,7 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 174 /* SpreadElementExpression */) { + if (args[i].kind === 176 /* SpreadElementExpression */) { return i; } } @@ -18046,13 +18577,13 @@ var ts; var adjustedArgCount; // Apparent number of arguments we will have in this call var typeArguments; // Type arguments (undefined if none) var callIsIncomplete; // In incomplete call we want to be lenient when we have too few arguments - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 162 /* TaggedTemplateExpression */) { var tagExpression = node; // Even if the call is incomplete, we'll have a missing expression as our last argument, // so we can say the count is just the arg list length adjustedArgCount = args.length; typeArguments = undefined; - if (tagExpression.template.kind === 172 /* TemplateExpression */) { + if (tagExpression.template.kind === 174 /* TemplateExpression */) { // If a tagged template expression lacks a tail literal, the call is incomplete. // Specifically, a template only can end in a TemplateTail or a Missing literal. var templateExpression = tagExpression.template; @@ -18073,7 +18604,7 @@ var ts; var callExpression = node; if (!callExpression.arguments) { // This only happens when we have something of the form: 'new C' - ts.Debug.assert(callExpression.kind === 159 /* NewExpression */); + ts.Debug.assert(callExpression.kind === 161 /* NewExpression */); return signature.minArgumentCount === 0; } // For IDE scenarios we may have an incomplete call, so a trailing comma is tantamount to adding another argument. @@ -18150,10 +18681,10 @@ var ts; // wildcards for all context sensitive function expressions. for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176 /* OmittedExpression */) { + if (arg.kind !== 178 /* OmittedExpression */) { var paramType = getTypeAtPosition(signature, i); var argType = void 0; - if (i === 0 && args[i].parent.kind === 160 /* TaggedTemplateExpression */) { + if (i === 0 && args[i].parent.kind === 162 /* TaggedTemplateExpression */) { argType = globalTemplateStringsArrayType; } else { @@ -18200,12 +18731,12 @@ var ts; function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 176 /* OmittedExpression */) { + if (arg.kind !== 178 /* OmittedExpression */) { // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) var paramType = getTypeAtPosition(signature, i); // A tagged template expression provides a special first argument, and string literals get string literal types // unless we're reporting errors - var argType = i === 0 && node.kind === 160 /* TaggedTemplateExpression */ + var argType = i === 0 && node.kind === 162 /* TaggedTemplateExpression */ ? globalTemplateStringsArrayType : arg.kind === 8 /* StringLiteral */ && !reportErrors ? getStringLiteralType(arg) @@ -18227,10 +18758,10 @@ var ts; */ function getEffectiveCallArguments(node) { var args; - if (node.kind === 160 /* TaggedTemplateExpression */) { + if (node.kind === 162 /* TaggedTemplateExpression */) { var template = node.template; args = [template]; - if (template.kind === 172 /* TemplateExpression */) { + if (template.kind === 174 /* TemplateExpression */) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); @@ -18241,32 +18772,11 @@ var ts; } return args; } - /** - * In a 'super' call, type arguments are not provided within the CallExpression node itself. - * Instead, they must be fetched from the class declaration's base type node. - * - * If 'node' is a 'super' call (e.g. super(...), new super(...)), then we attempt to fetch - * the type arguments off the containing class's first heritage clause (if one exists). Note that if - * type arguments are supplied on the 'super' call, they are ignored (though this is syntactically incorrect). - * - * In all other cases, the call's explicit type arguments are returned. - */ - function getEffectiveTypeArguments(callExpression) { - if (callExpression.expression.kind === 91 /* SuperKeyword */) { - var containingClass = ts.getAncestor(callExpression, 202 /* ClassDeclaration */); - var baseClassTypeNode = containingClass && ts.getClassExtendsHeritageClauseElement(containingClass); - return baseClassTypeNode && baseClassTypeNode.typeArguments; - } - else { - // Ordinary case - simple function invocation. - return callExpression.typeArguments; - } - } function resolveCall(node, signatures, candidatesOutArray) { - var isTaggedTemplate = node.kind === 160 /* TaggedTemplateExpression */; + var isTaggedTemplate = node.kind === 162 /* TaggedTemplateExpression */; var typeArguments; if (!isTaggedTemplate) { - typeArguments = getEffectiveTypeArguments(node); + typeArguments = node.typeArguments; // We already perform checking on the type arguments on the class declaration itself. if (node.expression.kind !== 91 /* SuperKeyword */) { ts.forEach(typeArguments, checkSourceElement); @@ -18361,8 +18871,8 @@ var ts; checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && node.typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true); + if (!isTaggedTemplate && typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], true); } else { ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); @@ -18456,7 +18966,11 @@ var ts; if (node.expression.kind === 91 /* SuperKeyword */) { var superType = checkSuperExpression(node.expression); if (superType !== unknownType) { - return resolveCall(node, getSignaturesOfType(superType, 1 /* Construct */), candidatesOutArray); + // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated + // with the type arguments specified in the extends clause. + var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getAncestor(node, 204 /* ClassDeclaration */)); + var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); + return resolveCall(node, baseConstructors, candidatesOutArray); } return resolveUntypedCall(node); } @@ -18578,13 +19092,13 @@ var ts; // to correctly fill the candidatesOutArray. if (!links.resolvedSignature || candidatesOutArray) { links.resolvedSignature = anySignature; - if (node.kind === 158 /* CallExpression */) { + if (node.kind === 160 /* CallExpression */) { links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); } - else if (node.kind === 159 /* NewExpression */) { + else if (node.kind === 161 /* NewExpression */) { links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); } - else if (node.kind === 160 /* TaggedTemplateExpression */) { + else if (node.kind === 162 /* TaggedTemplateExpression */) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } else { @@ -18600,12 +19114,12 @@ var ts; if (node.expression.kind === 91 /* SuperKeyword */) { return voidType; } - if (node.kind === 159 /* NewExpression */) { + if (node.kind === 161 /* NewExpression */) { var declaration = signature.declaration; if (declaration && - declaration.kind !== 136 /* Constructor */ && - declaration.kind !== 140 /* ConstructSignature */ && - declaration.kind !== 144 /* ConstructorType */) { + declaration.kind !== 137 /* Constructor */ && + declaration.kind !== 141 /* ConstructSignature */ && + declaration.kind !== 146 /* ConstructorType */) { // When resolved signature is a call signature (and not a construct signature) the result type is any if (compilerOptions.noImplicitAny) { error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); @@ -18653,7 +19167,7 @@ var ts; return unknownType; } var type; - if (func.body.kind !== 180 /* Block */) { + if (func.body.kind !== 182 /* Block */) { type = checkExpressionCached(func.body, contextualMapper); } else { @@ -18733,7 +19247,7 @@ var ts; }); } function bodyContainsSingleThrowStatement(body) { - return (body.statements.length === 1) && (body.statements[0].kind === 196 /* ThrowStatement */); + return (body.statements.length === 1) && (body.statements[0].kind === 198 /* ThrowStatement */); } // TypeScript Specification 1.0 (6.3) - July 2014 // An explicitly typed function whose return type isn't the Void or the Any type @@ -18748,7 +19262,7 @@ var ts; return; } // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check. - if (ts.nodeIsMissing(func.body) || func.body.kind !== 180 /* Block */) { + if (ts.nodeIsMissing(func.body) || func.body.kind !== 182 /* Block */) { return; } var bodyBlock = func.body; @@ -18766,11 +19280,11 @@ var ts; error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement); } function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); // Grammar checking - var hasGrammarError = checkGrammarDeclarationNameInStrictMode(node) || checkGrammarFunctionLikeDeclaration(node); - if (!hasGrammarError && node.kind === 163 /* FunctionExpression */) { - checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); + var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); + if (!hasGrammarError && node.kind === 165 /* FunctionExpression */) { + checkGrammarForGenerator(node); } // The identityMapper object is used to indicate that function expressions are wildcards if (contextualMapper === identityMapper && isContextSensitive(node)) { @@ -18801,14 +19315,14 @@ var ts; checkSignatureDeclaration(node); } } - if (produceDiagnostics && node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { + if (produceDiagnostics && node.kind !== 136 /* MethodDeclaration */ && node.kind !== 135 /* MethodSignature */) { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); } return type; } function checkFunctionExpressionOrObjectLiteralMethodBody(node) { - ts.Debug.assert(node.kind !== 135 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 136 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node)); if (node.type && !node.asteriskToken) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } @@ -18821,7 +19335,7 @@ var ts; // checkFunctionExpressionBodies). So it must be done now. getReturnTypeOfSignature(getSignatureFromDeclaration(node)); } - if (node.body.kind === 180 /* Block */) { + if (node.body.kind === 182 /* Block */) { checkSourceElement(node.body); } else { @@ -18863,17 +19377,17 @@ var ts; // An identifier expression that references any other kind of entity is classified as a value(and therefore cannot be the target of an assignment). return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3 /* Variable */) !== 0; } - case 156 /* PropertyAccessExpression */: { + case 158 /* PropertyAccessExpression */: { var symbol = findSymbol(n); // TypeScript 1.0 spec (April 2014): 4.10 // A property access expression is always classified as a reference. // NOTE (not in spec): assignment to enum members should not be allowed return !symbol || symbol === unknownSymbol || (symbol.flags & ~8 /* EnumMember */) !== 0; } - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: // old compiler doesn't check indexed assess return true; - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return isReferenceOrErrorExpression(n.expression); default: return false; @@ -18882,11 +19396,11 @@ var ts; function isConstVariableReference(n) { switch (n.kind) { case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: { + case 158 /* PropertyAccessExpression */: { var symbol = findSymbol(n); return symbol && (symbol.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 8192 /* Const */) !== 0; } - case 157 /* ElementAccessExpression */: { + case 159 /* ElementAccessExpression */: { var index = n.argumentExpression; var symbol = findSymbol(n.expression); if (symbol && index && index.kind === 8 /* StringLiteral */) { @@ -18896,7 +19410,7 @@ var ts; } return false; } - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return isConstVariableReference(n.expression); default: return false; @@ -18913,13 +19427,7 @@ var ts; return true; } function checkDeleteExpression(node) { - // Grammar checking - if (node.parserContextFlags & 1 /* StrictMode */ && node.expression.kind === 65 /* 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(node.expression, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode); - } - var operandType = checkExpression(node.expression); + checkExpression(node.expression); return booleanType; } function checkTypeOfExpression(node) { @@ -18931,13 +19439,6 @@ var ts; return undefinedType; } function checkPrefixUnaryExpression(node) { - // Grammar checking - // 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 ((node.operator === 38 /* PlusPlusToken */ || node.operator === 39 /* MinusMinusToken */)) { - checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); - } var operandType = checkExpression(node.operand); switch (node.operator) { case 33 /* PlusToken */: @@ -18961,11 +19462,6 @@ var ts; return unknownType; } function checkPostfixUnaryExpression(node) { - // Grammar checking - // 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. - checkGrammarEvalOrArgumentsInStrictMode(node, node.operand); var operandType = checkExpression(node.operand); var ok = checkArithmeticOperandType(node.operand, operandType, ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type); if (ok) { @@ -19047,7 +19543,7 @@ var ts; var properties = node.properties; for (var _i = 0; _i < properties.length; _i++) { var p = properties[_i]; - if (p.kind === 225 /* PropertyAssignment */ || p.kind === 226 /* ShorthandPropertyAssignment */) { + if (p.kind === 227 /* PropertyAssignment */ || p.kind === 228 /* ShorthandPropertyAssignment */) { // TODO(andersh): Computed property support var name_12 = p.name; var type = isTypeAny(sourceType) @@ -19076,8 +19572,8 @@ var ts; var elements = node.elements; for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176 /* OmittedExpression */) { - if (e.kind !== 174 /* SpreadElementExpression */) { + if (e.kind !== 178 /* OmittedExpression */) { + if (e.kind !== 176 /* SpreadElementExpression */) { var propName = "" + i; var type = isTypeAny(sourceType) ? sourceType @@ -19102,7 +19598,7 @@ var ts; } else { var restExpression = e.expression; - if (restExpression.kind === 170 /* BinaryExpression */ && restExpression.operatorToken.kind === 53 /* EqualsToken */) { + if (restExpression.kind === 172 /* BinaryExpression */ && restExpression.operatorToken.kind === 53 /* EqualsToken */) { error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } else { @@ -19115,14 +19611,14 @@ var ts; return sourceType; } function checkDestructuringAssignment(target, sourceType, contextualMapper) { - if (target.kind === 170 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { + if (target.kind === 172 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { checkBinaryExpression(target, contextualMapper); target = target.left; } - if (target.kind === 155 /* ObjectLiteralExpression */) { + if (target.kind === 157 /* ObjectLiteralExpression */) { return checkObjectLiteralAssignment(target, sourceType, contextualMapper); } - if (target.kind === 154 /* ArrayLiteralExpression */) { + if (target.kind === 156 /* ArrayLiteralExpression */) { return checkArrayLiteralAssignment(target, sourceType, contextualMapper); } return checkReferenceAssignment(target, sourceType, contextualMapper); @@ -19135,14 +19631,8 @@ var ts; return sourceType; } function checkBinaryExpression(node, contextualMapper) { - // Grammar checking - if (ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { - // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an - // Assignment operator(11.13) or of a PostfixExpression(11.3) - checkGrammarEvalOrArgumentsInStrictMode(node, node.left); - } var operator = node.operatorToken.kind; - if (operator === 53 /* EqualsToken */ && (node.left.kind === 155 /* ObjectLiteralExpression */ || node.left.kind === 154 /* ArrayLiteralExpression */)) { + if (operator === 53 /* EqualsToken */ && (node.left.kind === 157 /* ObjectLiteralExpression */ || node.left.kind === 156 /* ArrayLiteralExpression */)) { return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); } var leftType = checkExpression(node.left, contextualMapper); @@ -19317,7 +19807,7 @@ var ts; if (ts.isFunctionLike(parent) && current === parent.body) { return false; } - else if (current.kind === 202 /* ClassDeclaration */ || current.kind === 175 /* ClassExpression */) { + else if (current.kind === 204 /* ClassDeclaration */ || current.kind === 177 /* ClassExpression */) { return true; } current = parent; @@ -19393,7 +19883,7 @@ var ts; // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { checkComputedPropertyName(node.name); } return checkExpression(node.initializer, contextualMapper); @@ -19404,7 +19894,7 @@ var ts; // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { checkComputedPropertyName(node.name); } var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); @@ -19425,10 +19915,6 @@ var ts; } return type; } - function checkExpression(node, contextualMapper) { - checkGrammarIdentifierInStrictMode(node); - return checkExpressionOrQualifiedName(node, contextualMapper); - } // Checks an expression and returns its type. The contextualMapper parameter serves two purposes: When // contextualMapper is not undefined and not equal to the identityMapper function object it indicates that the // expression is being inferentially typed (section 4.12.2 in spec) and provides the type mapper to use in @@ -19436,9 +19922,9 @@ var ts; // object, it serves as an indicator that all contained function and arrow expressions should be considered to // have the wildcard function type; this form of type check is used during overload resolution to exclude // contextually typed function and arrow expressions in the initial phase. - function checkExpressionOrQualifiedName(node, contextualMapper) { + function checkExpression(node, contextualMapper) { var type; - if (node.kind == 127 /* QualifiedName */) { + if (node.kind === 128 /* QualifiedName */) { type = checkQualifiedName(node); } else { @@ -19450,9 +19936,9 @@ var ts; // - 'left' in property access // - 'object' in indexed access // - target in rhs of import statement - var ok = (node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.expression === node) || - (node.parent.kind === 157 /* ElementAccessExpression */ && node.parent.expression === node) || - ((node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */) && isInRightSideOfImportOrExportAssignment(node)); + var ok = (node.parent.kind === 158 /* PropertyAccessExpression */ && node.parent.expression === node) || + (node.parent.kind === 159 /* ElementAccessExpression */ && node.parent.expression === node) || + ((node.kind === 65 /* Identifier */ || node.kind === 128 /* QualifiedName */) && isInRightSideOfImportOrExportAssignment(node)); if (!ok) { error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment); } @@ -19479,61 +19965,60 @@ var ts; return booleanType; case 7 /* NumericLiteral */: return checkNumericLiteral(node); - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: return checkTemplateExpression(node); case 8 /* StringLiteral */: case 10 /* NoSubstitutionTemplateLiteral */: return stringType; case 9 /* RegularExpressionLiteral */: return globalRegExpType; - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return checkArrayLiteral(node, contextualMapper); - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return checkObjectLiteral(node, contextualMapper); - case 156 /* PropertyAccessExpression */: + case 158 /* PropertyAccessExpression */: return checkPropertyAccessExpression(node); - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: return checkIndexedAccess(node); - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return checkCallExpression(node); - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: return checkTaggedTemplateExpression(node); - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return checkTypeAssertion(node); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return checkExpression(node.expression, contextualMapper); - case 175 /* ClassExpression */: + case 177 /* ClassExpression */: return checkClassExpression(node); - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); - case 166 /* TypeOfExpression */: + case 168 /* TypeOfExpression */: return checkTypeOfExpression(node); - case 165 /* DeleteExpression */: + case 167 /* DeleteExpression */: return checkDeleteExpression(node); - case 167 /* VoidExpression */: + case 169 /* VoidExpression */: return checkVoidExpression(node); - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: return checkPrefixUnaryExpression(node); - case 169 /* PostfixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: return checkPostfixUnaryExpression(node); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return checkBinaryExpression(node, contextualMapper); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return checkConditionalExpression(node, contextualMapper); - case 174 /* SpreadElementExpression */: + case 176 /* SpreadElementExpression */: return checkSpreadElementExpression(node, contextualMapper); - case 176 /* OmittedExpression */: + case 178 /* OmittedExpression */: return undefinedType; - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: return checkYieldExpression(node); } return unknownType; } // DECLARATION AND STATEMENT TYPE CHECKING function checkTypeParameter(node) { - checkGrammarDeclarationNameInStrictMode(node); // Grammar Checking if (node.expression) { grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected); @@ -19550,15 +20035,13 @@ var ts; // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code // or if its FunctionBody is strict code(11.1.5). - // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a - // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) // Grammar checking - checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + checkGrammarDecorators(node) || checkGrammarModifiers(node); checkVariableLikeDeclaration(node); var func = ts.getContainingFunction(node); if (node.flags & 112 /* AccessibilityModifier */) { func = ts.getContainingFunction(node); - if (!(func.kind === 136 /* Constructor */ && ts.nodeIsPresent(func.body))) { + if (!(func.kind === 137 /* Constructor */ && ts.nodeIsPresent(func.body))) { error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } @@ -19575,33 +20058,107 @@ var ts; if (!node.asteriskToken || !node.body) { return false; } - return node.kind === 135 /* MethodDeclaration */ || - node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */; + return node.kind === 136 /* MethodDeclaration */ || + node.kind === 203 /* FunctionDeclaration */ || + node.kind === 165 /* FunctionExpression */; + } + function getTypePredicateParameterIndex(parameterList, parameter) { + if (parameterList) { + for (var i = 0; i < parameterList.length; i++) { + var param = parameterList[i]; + if (param.name.kind === 65 /* Identifier */ && + param.name.text === parameter.text) { + return i; + } + } + } + return -1; + } + function isInLegalTypePredicatePosition(node) { + switch (node.parent.kind) { + case 166 /* ArrowFunction */: + case 140 /* CallSignature */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 145 /* FunctionType */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + return node === node.parent.type; + } + return false; } function checkSignatureDeclaration(node) { // Grammar checking - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 142 /* IndexSignature */) { checkGrammarIndexSignature(node); } - else if (node.kind === 143 /* FunctionType */ || node.kind === 201 /* FunctionDeclaration */ || node.kind === 144 /* ConstructorType */ || - node.kind === 139 /* CallSignature */ || node.kind === 136 /* Constructor */ || - node.kind === 140 /* ConstructSignature */) { + else if (node.kind === 145 /* FunctionType */ || node.kind === 203 /* FunctionDeclaration */ || node.kind === 146 /* ConstructorType */ || + node.kind === 140 /* CallSignature */ || node.kind === 137 /* Constructor */ || + node.kind === 141 /* ConstructSignature */) { checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); ts.forEach(node.parameters, checkParameter); if (node.type) { - checkSourceElement(node.type); + if (node.type.kind === 143 /* TypePredicate */) { + var typePredicate = getSignatureFromDeclaration(node).typePredicate; + var typePredicateNode = node.type; + if (isInLegalTypePredicatePosition(typePredicateNode)) { + if (typePredicate.parameterIndex >= 0) { + if (node.parameters[typePredicate.parameterIndex].dotDotDotToken) { + error(typePredicateNode.parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter); + } + else { + checkTypeAssignableTo(typePredicate.type, getTypeAtLocation(node.parameters[typePredicate.parameterIndex]), typePredicateNode.type); + } + } + else if (typePredicateNode.parameterName) { + var hasReportedError = false; + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var param = _a[_i]; + if (hasReportedError) { + break; + } + if (param.name.kind === 153 /* ObjectBindingPattern */ || + param.name.kind === 154 /* ArrayBindingPattern */) { + (function checkBindingPattern(pattern) { + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (element.name.kind === 65 /* Identifier */ && + element.name.text === typePredicate.parameterName) { + error(typePredicateNode.parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, typePredicate.parameterName); + hasReportedError = true; + break; + } + else if (element.name.kind === 154 /* ArrayBindingPattern */ || + element.name.kind === 153 /* ObjectBindingPattern */) { + checkBindingPattern(element.name); + } + } + })(param.name); + } + } + if (!hasReportedError) { + error(typePredicateNode.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName); + } + } + } + else { + error(typePredicateNode, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + } + } + else { + checkSourceElement(node.type); + } } if (produceDiagnostics) { checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; - case 139 /* CallSignature */: + case 140 /* CallSignature */: error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; } @@ -19629,7 +20186,7 @@ var ts; checkSpecializedSignatureDeclaration(node); } function checkTypeForDuplicateIndexSignatures(node) { - if (node.kind === 203 /* InterfaceDeclaration */) { + if (node.kind === 205 /* InterfaceDeclaration */) { var nodeSymbol = getSymbolOfNode(node); // in case of merging interface declaration it is possible that we'll enter this check procedure several times for every declaration // to prevent this run check only for the first declaration of a given kind @@ -19649,7 +20206,7 @@ var ts; var declaration = decl; if (declaration.parameters.length === 1 && declaration.parameters[0].type) { switch (declaration.parameters[0].type.kind) { - case 122 /* StringKeyword */: + case 123 /* StringKeyword */: if (!seenStringIndexer) { seenStringIndexer = true; } @@ -19657,7 +20214,7 @@ var ts; error(declaration, ts.Diagnostics.Duplicate_string_index_signature); } break; - case 120 /* NumberKeyword */: + case 121 /* NumberKeyword */: if (!seenNumericIndexer) { seenNumericIndexer = true; } @@ -19701,17 +20258,17 @@ var ts; return; } function isSuperCallExpression(n) { - return n.kind === 158 /* CallExpression */ && n.expression.kind === 91 /* SuperKeyword */; + return n.kind === 160 /* CallExpression */ && n.expression.kind === 91 /* SuperKeyword */; } function containsSuperCall(n) { if (isSuperCallExpression(n)) { return true; } switch (n.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 155 /* ObjectLiteralExpression */: return false; + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: + case 157 /* ObjectLiteralExpression */: return false; default: return ts.forEachChild(n, containsSuperCall); } } @@ -19719,12 +20276,12 @@ var ts; if (n.kind === 93 /* ThisKeyword */) { error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); } - else if (n.kind !== 163 /* FunctionExpression */ && n.kind !== 201 /* FunctionDeclaration */) { + else if (n.kind !== 165 /* FunctionExpression */ && n.kind !== 203 /* FunctionDeclaration */) { ts.forEachChild(n, markThisReferencesAsErrors); } } function isInstancePropertyWithInitializer(n) { - return n.kind === 133 /* PropertyDeclaration */ && + return n.kind === 134 /* PropertyDeclaration */ && !(n.flags & 128 /* Static */) && !!n.initializer; } @@ -19741,7 +20298,7 @@ var ts; ts.forEach(node.parameters, function (p) { return p.flags & (16 /* Public */ | 32 /* Private */ | 64 /* Protected */); }); if (superCallShouldBeFirst) { var statements = node.body.statements; - if (!statements.length || statements[0].kind !== 183 /* ExpressionStatement */ || !isSuperCallExpression(statements[0].expression)) { + if (!statements.length || statements[0].kind !== 185 /* ExpressionStatement */ || !isSuperCallExpression(statements[0].expression)) { error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties); } else { @@ -19759,7 +20316,7 @@ var ts; if (produceDiagnostics) { // Grammar checking accessors checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); - if (node.kind === 137 /* GetAccessor */) { + if (node.kind === 138 /* GetAccessor */) { if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) { error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement); } @@ -19767,7 +20324,7 @@ var ts; if (!ts.hasDynamicName(node)) { // TypeScript 1.0 spec (April 2014): 8.4.3 // Accessors for the same member name must specify the same accessibility. - var otherKind = node.kind === 137 /* GetAccessor */ ? 138 /* SetAccessor */ : 137 /* GetAccessor */; + var otherKind = node.kind === 138 /* GetAccessor */ ? 139 /* SetAccessor */ : 138 /* GetAccessor */; var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); if (otherAccessor) { if (((node.flags & 112 /* AccessibilityModifier */) !== (otherAccessor.flags & 112 /* AccessibilityModifier */))) { @@ -19791,28 +20348,27 @@ var ts; function checkMissingDeclaration(node) { checkDecorators(node); } + function checkTypeArgumentConstraints(typeParameters, typeArguments) { + var result = true; + for (var i = 0; i < typeParameters.length; i++) { + var constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + var typeArgument = typeArguments[i]; + result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + } + } + return result; + } function checkTypeReferenceNode(node) { - checkGrammarTypeReferenceInStrictMode(node.typeName); - return checkTypeReferenceOrExpressionWithTypeArguments(node); - } - function checkExpressionWithTypeArguments(node) { - checkGrammarExpressionWithTypeArgumentsInStrictMode(node.expression); - return checkTypeReferenceOrExpressionWithTypeArguments(node); - } - function checkTypeReferenceOrExpressionWithTypeArguments(node) { - // Grammar checking checkGrammarTypeArguments(node, node.typeArguments); - var type = getTypeFromTypeReferenceOrExpressionWithTypeArguments(node); + var type = getTypeFromTypeReference(node); if (type !== unknownType && node.typeArguments) { // Do type argument local checks only if referenced type is successfully resolved - var len = node.typeArguments.length; - for (var i = 0; i < len; i++) { - checkSourceElement(node.typeArguments[i]); - var constraint = getConstraintOfTypeParameter(type.target.typeParameters[i]); - if (produceDiagnostics && constraint) { - var typeArgument = type.typeArguments[i]; - checkTypeAssignableTo(typeArgument, constraint, node, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); - } + ts.forEach(node.typeArguments, checkSourceElement); + if (produceDiagnostics) { + var symbol = getNodeLinks(node).resolvedSymbol; + var typeParameters = symbol.flags & 524288 /* TypeAlias */ ? getSymbolLinks(symbol).typeParameters : type.target.localTypeParameters; + checkTypeArgumentConstraints(typeParameters, node.typeArguments); } } } @@ -19864,9 +20420,9 @@ var ts; var signaturesToCheck; // Unnamed (call\construct) signatures in interfaces are inherited and not shadowed so examining just node symbol won't give complete answer. // Use declaring type to obtain full list of signatures. - if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 203 /* InterfaceDeclaration */) { - ts.Debug.assert(signatureDeclarationNode.kind === 139 /* CallSignature */ || signatureDeclarationNode.kind === 140 /* ConstructSignature */); - var signatureKind = signatureDeclarationNode.kind === 139 /* CallSignature */ ? 0 /* Call */ : 1 /* Construct */; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 205 /* InterfaceDeclaration */) { + ts.Debug.assert(signatureDeclarationNode.kind === 140 /* CallSignature */ || signatureDeclarationNode.kind === 141 /* ConstructSignature */); + var signatureKind = signatureDeclarationNode.kind === 140 /* CallSignature */ ? 0 /* Call */ : 1 /* Construct */; var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); var containingType = getDeclaredTypeOfSymbol(containingSymbol); signaturesToCheck = getSignaturesOfType(containingType, signatureKind); @@ -19884,7 +20440,7 @@ var ts; } function getEffectiveDeclarationFlags(n, flagsToCheck) { var flags = ts.getCombinedNodeFlags(n); - if (n.parent.kind !== 203 /* InterfaceDeclaration */ && ts.isInAmbientContext(n)) { + if (n.parent.kind !== 205 /* InterfaceDeclaration */ && ts.isInAmbientContext(n)) { if (!(flags & 2 /* Ambient */)) { // It is nested in an ambient context, which means it is automatically exported flags |= 1 /* Export */; @@ -19967,7 +20523,7 @@ var ts; // TODO(jfreeman): These are methods, so handle computed name case if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { // the only situation when this is possible (same kind\same name but different symbol) - mixed static and instance class members - ts.Debug.assert(node.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */); + ts.Debug.assert(node.kind === 136 /* MethodDeclaration */ || node.kind === 135 /* MethodSignature */); ts.Debug.assert((node.flags & 128 /* Static */) !== (subsequentNode.flags & 128 /* Static */)); var diagnostic = node.flags & 128 /* Static */ ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static; error(errorNode_1, diagnostic); @@ -19996,7 +20552,7 @@ var ts; var current = declarations[_i]; var node = current; var inAmbientContext = ts.isInAmbientContext(node); - var inAmbientContextOrInterface = node.parent.kind === 203 /* InterfaceDeclaration */ || node.parent.kind === 146 /* TypeLiteral */ || inAmbientContext; + var inAmbientContextOrInterface = node.parent.kind === 205 /* InterfaceDeclaration */ || node.parent.kind === 148 /* TypeLiteral */ || inAmbientContext; if (inAmbientContextOrInterface) { // check if declarations are consecutive only if they are non-ambient // 1. ambient declarations can be interleaved @@ -20007,7 +20563,7 @@ var ts; // 2. mixing ambient and non-ambient declarations is a separate error that will be reported - do not want to report an extra one previousDeclaration = undefined; } - if (node.kind === 201 /* FunctionDeclaration */ || node.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */ || node.kind === 136 /* Constructor */) { + if (node.kind === 203 /* FunctionDeclaration */ || node.kind === 136 /* MethodDeclaration */ || node.kind === 135 /* MethodSignature */ || node.kind === 137 /* Constructor */) { var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); someNodeFlags |= currentNodeFlags; allNodeFlags &= currentNodeFlags; @@ -20130,16 +20686,16 @@ var ts; } function getDeclarationSpaces(d) { switch (d.kind) { - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return 2097152 /* ExportType */; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return d.name.kind === 8 /* StringLiteral */ || ts.getModuleInstanceState(d) !== 0 /* NonInstantiated */ ? 4194304 /* ExportNamespace */ | 1048576 /* ExportValue */ : 4194304 /* ExportNamespace */; - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: return 2097152 /* ExportType */ | 1048576 /* ExportValue */; - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: var result = 0; var target = resolveAlias(getSymbolOfNode(d)); ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); @@ -20154,23 +20710,23 @@ var ts; var expression = node.expression; var exprType = checkExpression(expression); switch (node.parent.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); checkTypeAssignableTo(exprType, classDecoratorType, node); break; - case 133 /* PropertyDeclaration */: + case 134 /* PropertyDeclaration */: checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); break; - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: var methodType = getTypeOfNode(node.parent); var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); checkTypeAssignableTo(exprType, methodDecoratorType, node); break; - case 130 /* Parameter */: + case 131 /* Parameter */: checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); break; } @@ -20180,14 +20736,14 @@ var ts; // When we are emitting type metadata for decorators, we need to try to check the type // as if it were an expression so that we can emit the type in a value position when we // serialize the type metadata. - if (node && node.kind === 142 /* TypeReference */) { + if (node && node.kind === 144 /* TypeReference */) { var type = getTypeFromTypeNode(node); var shouldCheckIfUnknownType = type === unknownType && compilerOptions.isolatedModules; if (!type || (!shouldCheckIfUnknownType && type.flags & (2097279 /* Intrinsic */ | 132 /* NumberLike */ | 258 /* StringLike */))) { return; } if (shouldCheckIfUnknownType || type.symbol.valueDeclaration) { - checkExpressionOrQualifiedName(node.typeName); + checkExpression(node.typeName); } } } @@ -20197,19 +20753,19 @@ var ts; */ function checkTypeAnnotationAsExpression(node) { switch (node.kind) { - case 133 /* PropertyDeclaration */: + case 134 /* PropertyDeclaration */: checkTypeNodeAsExpression(node.type); break; - case 130 /* Parameter */: + case 131 /* Parameter */: checkTypeNodeAsExpression(node.type); break; - case 135 /* MethodDeclaration */: + case 136 /* MethodDeclaration */: checkTypeNodeAsExpression(node.type); break; - case 137 /* GetAccessor */: + case 138 /* GetAccessor */: checkTypeNodeAsExpression(node.type); break; - case 138 /* SetAccessor */: + case 139 /* SetAccessor */: checkTypeNodeAsExpression(getSetAccessorTypeAnnotationNode(node)); break; } @@ -20238,47 +20794,44 @@ var ts; if (compilerOptions.emitDecoratorMetadata) { // we only need to perform these checks if we are emitting serialized type metadata for the target of a decorator. switch (node.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: var constructor = ts.getFirstConstructorWithBody(node); if (constructor) { checkParameterTypeAnnotationsAsExpressions(constructor); } break; - case 135 /* MethodDeclaration */: + case 136 /* MethodDeclaration */: checkParameterTypeAnnotationsAsExpressions(node); // fall-through - case 138 /* SetAccessor */: - case 137 /* GetAccessor */: - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 139 /* SetAccessor */: + case 138 /* GetAccessor */: + case 134 /* PropertyDeclaration */: + case 131 /* Parameter */: checkTypeAnnotationAsExpression(node); break; } } emitDecorate = true; - if (node.kind === 130 /* Parameter */) { + if (node.kind === 131 /* Parameter */) { emitParam = true; } ts.forEach(node.decorators, checkDecorator); } function checkFunctionDeclaration(node) { if (produceDiagnostics) { - checkFunctionLikeDeclaration(node) || - checkGrammarFunctionName(node.name) || - checkGrammarForGenerator(node); + checkFunctionLikeDeclaration(node) || checkGrammarForGenerator(node); checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); } } function checkFunctionLikeDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSignatureDeclaration(node); // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name && node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name && node.name.kind === 129 /* ComputedPropertyName */) { // This check will account for methods in class/interface declarations, // as well as accessors in classes/object literals checkComputedPropertyName(node.name); @@ -20322,11 +20875,11 @@ var ts; } function checkBlock(node) { // Grammar checking for SyntaxKind.Block - if (node.kind === 180 /* Block */) { + if (node.kind === 182 /* Block */) { checkGrammarStatementInAmbientContext(node); } ts.forEach(node.statements, checkSourceElement); - if (ts.isFunctionBlock(node) || node.kind === 207 /* ModuleBlock */) { + if (ts.isFunctionBlock(node) || node.kind === 209 /* ModuleBlock */) { checkFunctionExpressionBodies(node); } } @@ -20345,12 +20898,12 @@ var ts; if (!(identifier && identifier.text === name)) { return false; } - if (node.kind === 133 /* PropertyDeclaration */ || - node.kind === 132 /* PropertySignature */ || - node.kind === 135 /* MethodDeclaration */ || - node.kind === 134 /* MethodSignature */ || - node.kind === 137 /* GetAccessor */ || - node.kind === 138 /* SetAccessor */) { + if (node.kind === 134 /* PropertyDeclaration */ || + node.kind === 133 /* PropertySignature */ || + node.kind === 136 /* MethodDeclaration */ || + node.kind === 135 /* MethodSignature */ || + node.kind === 138 /* GetAccessor */ || + node.kind === 139 /* SetAccessor */) { // it is ok to have member named '_super' or '_this' - member access is always qualified return false; } @@ -20359,7 +20912,7 @@ var ts; return false; } var root = ts.getRootDeclaration(node); - if (root.kind === 130 /* Parameter */ && ts.nodeIsMissing(root.parent.body)) { + if (root.kind === 131 /* Parameter */ && ts.nodeIsMissing(root.parent.body)) { // just an overload - no codegen impact return false; } @@ -20392,7 +20945,7 @@ var ts; return; } // bubble up and find containing type - var enclosingClass = ts.getAncestor(node, 202 /* ClassDeclaration */); + var enclosingClass = ts.getAncestor(node, 204 /* ClassDeclaration */); // if containing type was not found or it is ambient - exit (no codegen) if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; @@ -20412,12 +20965,12 @@ var ts; return; } // Uninstantiated modules shouldnt do this check - if (node.kind === 206 /* ModuleDeclaration */ && ts.getModuleInstanceState(node) !== 1 /* Instantiated */) { + if (node.kind === 208 /* ModuleDeclaration */ && ts.getModuleInstanceState(node) !== 1 /* Instantiated */) { return; } // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent var parent = getDeclarationContainer(node); - if (parent.kind === 228 /* SourceFile */ && ts.isExternalModule(parent)) { + if (parent.kind === 230 /* SourceFile */ && ts.isExternalModule(parent)) { // If the declaration happens to be in external module, report error that require and exports are reserved keywords error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); } @@ -20452,7 +21005,7 @@ var ts; // skip variable declarations that don't have initializers // NOTE: in ES6 spec initializer is required in variable declarations where name is binding pattern // so we'll always treat binding elements as initialized - if (node.kind === 199 /* VariableDeclaration */ && !node.initializer) { + if (node.kind === 201 /* VariableDeclaration */ && !node.initializer) { return; } var symbol = getSymbolOfNode(node); @@ -20462,17 +21015,17 @@ var ts; localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2 /* BlockScopedVariable */) { if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 12288 /* BlockScoped */) { - var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 200 /* VariableDeclarationList */); - var container = varDeclList.parent.kind === 181 /* VariableStatement */ && varDeclList.parent.parent + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 202 /* VariableDeclarationList */); + var container = varDeclList.parent.kind === 183 /* VariableStatement */ && varDeclList.parent.parent ? varDeclList.parent.parent : undefined; // names of block-scoped and function scoped variables can collide only // if block scoped variable is defined in the function\module\source file scope (because of variable hoisting) var namesShareScope = container && - (container.kind === 180 /* Block */ && ts.isFunctionLike(container.parent) || - container.kind === 207 /* ModuleBlock */ || - container.kind === 206 /* ModuleDeclaration */ || - container.kind === 228 /* SourceFile */); + (container.kind === 182 /* Block */ && ts.isFunctionLike(container.parent) || + container.kind === 209 /* ModuleBlock */ || + container.kind === 208 /* ModuleDeclaration */ || + container.kind === 230 /* SourceFile */); // here we know that function scoped variable is shadowed by block scoped one // if they are defined in the same scope - binder has already reported redeclaration error // otherwise if variable has an initializer - show error that initialization will fail @@ -20487,7 +21040,7 @@ var ts; } // Check that a parameter initializer contains no references to parameters declared to the right of itself function checkParameterInitializer(node) { - if (ts.getRootDeclaration(node).kind !== 130 /* Parameter */) { + if (ts.getRootDeclaration(node).kind !== 131 /* Parameter */) { return; } var func = ts.getContainingFunction(node); @@ -20498,7 +21051,7 @@ var ts; // check FunctionLikeDeclaration.locals (stores parameters\function local variable) // if it contains entry with a specified name and if this entry matches the resolved symbol if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455 /* Value */) === referencedSymbol) { - if (referencedSymbol.valueDeclaration.kind === 130 /* Parameter */) { + if (referencedSymbol.valueDeclaration.kind === 131 /* Parameter */) { if (referencedSymbol.valueDeclaration === node) { error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); return; @@ -20518,14 +21071,13 @@ var ts; } // Check variable, parameter, or property declaration function checkVariableLikeDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); checkDecorators(node); checkSourceElement(node.type); // For a computed property, just check the initializer and exit // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { checkComputedPropertyName(node.name); if (node.initializer) { checkExpressionCached(node.initializer); @@ -20536,7 +21088,7 @@ var ts; ts.forEach(node.name.elements, checkSourceElement); } // For a parameter declaration with an initializer, error and exit if the containing function doesn't have a body - if (node.initializer && ts.getRootDeclaration(node).kind === 130 /* Parameter */ && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + if (node.initializer && ts.getRootDeclaration(node).kind === 131 /* Parameter */ && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); return; } @@ -20568,10 +21120,10 @@ var ts; checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); } } - if (node.kind !== 133 /* PropertyDeclaration */ && node.kind !== 132 /* PropertySignature */) { + if (node.kind !== 134 /* PropertyDeclaration */ && node.kind !== 133 /* PropertySignature */) { // We know we don't have a binding pattern or computed name here checkExportsOnMergedDeclarations(node); - if (node.kind === 199 /* VariableDeclaration */ || node.kind === 153 /* BindingElement */) { + if (node.kind === 201 /* VariableDeclaration */ || node.kind === 155 /* BindingElement */) { checkVarDeclaredNamesNotShadowed(node); } checkCollisionWithCapturedSuperVariable(node, node.name); @@ -20601,7 +21153,7 @@ var ts; } function inBlockOrObjectLiteralExpression(node) { while (node) { - if (node.kind === 180 /* Block */ || node.kind === 155 /* ObjectLiteralExpression */) { + if (node.kind === 182 /* Block */ || node.kind === 157 /* ObjectLiteralExpression */) { return true; } node = node.parent; @@ -20634,12 +21186,12 @@ var ts; function checkForStatement(node) { // Grammar checking if (!checkGrammarStatementInAmbientContext(node)) { - if (node.initializer && node.initializer.kind == 200 /* VariableDeclarationList */) { + if (node.initializer && node.initializer.kind === 202 /* VariableDeclarationList */) { checkGrammarVariableDeclarationList(node.initializer); } } if (node.initializer) { - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { ts.forEach(node.initializer.declarations, checkVariableDeclaration); } else { @@ -20659,14 +21211,14 @@ var ts; // via checkRightHandSideOfForOf. // If the LHS is an expression, check the LHS, as a destructuring assignment or as a reference. // Then check that the RHS is assignable to it. - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { checkForInOrForOfVariableDeclaration(node); } else { var varExpr = node.initializer; var iteratedType = checkRightHandSideOfForOf(node.expression); // There may be a destructuring assignment on the left side - if (varExpr.kind === 154 /* ArrayLiteralExpression */ || varExpr.kind === 155 /* ObjectLiteralExpression */) { + if (varExpr.kind === 156 /* ArrayLiteralExpression */ || varExpr.kind === 157 /* ObjectLiteralExpression */) { // iteratedType may be undefined. In this case, we still want to check the structure of // varExpr, in particular making sure it's a valid LeftHandSideExpression. But we'd like // to short circuit the type relation checking as much as possible, so we pass the unknownType. @@ -20695,7 +21247,7 @@ var ts; // for (let VarDecl in Expr) Statement // VarDecl must be a variable declaration without a type annotation that declares a variable of type Any, // and Expr must be an expression of type Any, an object type, or a type parameter type. - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { var variable = node.initializer.declarations[0]; if (variable && ts.isBindingPattern(variable.name)) { error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); @@ -20709,7 +21261,7 @@ var ts; // and Expr must be an expression of type Any, an object type, or a type parameter type. var varExpr = node.initializer; var leftType = checkExpression(varExpr); - if (varExpr.kind === 154 /* ArrayLiteralExpression */ || varExpr.kind === 155 /* ObjectLiteralExpression */) { + if (varExpr.kind === 156 /* ArrayLiteralExpression */ || varExpr.kind === 157 /* ObjectLiteralExpression */) { error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); } else if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, 258 /* StringLike */)) { @@ -20948,7 +21500,7 @@ var ts; // TODO: Check that target label is valid } function isGetAccessorWithAnnotatatedSetAccessor(node) { - return !!(node.kind === 137 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 138 /* SetAccessor */))); + return !!(node.kind === 138 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 139 /* SetAccessor */))); } function checkReturnStatement(node) { // Grammar checking @@ -20961,7 +21513,8 @@ var ts; if (node.expression) { var func = ts.getContainingFunction(node); if (func) { - var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); + var signature = getSignatureFromDeclaration(func); + var returnType = getReturnTypeOfSignature(signature); var exprType = checkExpressionCached(node.expression); if (func.asteriskToken) { // A generator does not need its return expressions checked against its return type. @@ -20970,27 +21523,22 @@ var ts; // for generators. return; } - if (func.kind === 138 /* SetAccessor */) { + if (func.kind === 139 /* SetAccessor */) { error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); } - else if (func.kind === 136 /* Constructor */) { + else if (func.kind === 137 /* Constructor */) { if (!isTypeAssignableTo(exprType, returnType)) { error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } } - else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) { + else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) { checkTypeAssignableTo(exprType, returnType, node.expression, undefined); } } } } function checkWithStatement(node) { - // Grammar checking for withStatement - if (!checkGrammarStatementInAmbientContext(node)) { - if (node.parserContextFlags & 1 /* StrictMode */) { - grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); - } - } + checkGrammarStatementInAmbientContext(node); checkExpression(node.expression); error(node.expression, ts.Diagnostics.All_symbols_within_a_with_block_will_be_resolved_to_any); } @@ -21002,7 +21550,7 @@ var ts; var expressionType = checkExpression(node.expression); ts.forEach(node.caseBlock.clauses, function (clause) { // Grammar check for duplicate default clauses, skip if we already report duplicate default clause - if (clause.kind === 222 /* DefaultClause */ && !hasDuplicateDefaultClause) { + if (clause.kind === 224 /* DefaultClause */ && !hasDuplicateDefaultClause) { if (firstDefaultClause === undefined) { firstDefaultClause = clause; } @@ -21014,7 +21562,7 @@ var ts; hasDuplicateDefaultClause = true; } } - if (produceDiagnostics && clause.kind === 221 /* CaseClause */) { + if (produceDiagnostics && clause.kind === 223 /* CaseClause */) { var caseClause = clause; // TypeScript 1.0 spec (April 2014):5.9 // In a 'switch' statement, each 'case' expression must be of a type that is assignable to or from the type of the 'switch' expression. @@ -21035,7 +21583,7 @@ var ts; if (ts.isFunctionLike(current)) { break; } - if (current.kind === 195 /* LabeledStatement */ && current.label.text === node.label.text) { + if (current.kind === 197 /* LabeledStatement */ && current.label.text === node.label.text) { var sourceFile = ts.getSourceFileOfNode(node); grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNodeFromSourceText(sourceFile.text, node.label)); break; @@ -21083,9 +21631,6 @@ var ts; grammarErrorOnNode(localSymbol.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, identifierName); } } - // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the - // Catch production is eval or arguments - checkGrammarEvalOrArgumentsInStrictMode(node, catchClause.variableDeclaration.name); } } checkBlock(catchClause.block); @@ -21105,7 +21650,7 @@ var ts; checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */); checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */); }); - if (type.flags & 1024 /* Class */ && type.symbol.valueDeclaration.kind === 202 /* ClassDeclaration */) { + if (type.flags & 1024 /* Class */ && type.symbol.valueDeclaration.kind === 204 /* ClassDeclaration */) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; @@ -21143,7 +21688,7 @@ var ts; // perform property check if property or indexer is declared in 'type' // this allows to rule out cases when both property and indexer are inherited from the base class var errorNode; - if (prop.valueDeclaration.name.kind === 128 /* ComputedPropertyName */ || prop.parent === containingType.symbol) { + if (prop.valueDeclaration.name.kind === 129 /* ComputedPropertyName */ || prop.parent === containingType.symbol) { errorNode = prop.valueDeclaration; } else if (indexDeclaration) { @@ -21199,7 +21744,6 @@ var ts; return unknownType; } function checkClassDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node); // Grammar checking if (!node.name && !(node.flags & 256 /* Default */)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); @@ -21218,36 +21762,42 @@ var ts; var staticType = getTypeOfSymbol(symbol); var baseTypeNode = ts.getClassExtendsHeritageClauseElement(node); if (baseTypeNode) { - if (!ts.isSupportedExpressionWithTypeArguments(baseTypeNode)) { - error(baseTypeNode.expression, ts.Diagnostics.Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses); - } emitExtends = emitExtends || !ts.isInAmbientContext(node); - checkExpressionWithTypeArguments(baseTypeNode); - } - var baseTypes = getBaseTypes(type); - if (baseTypes.length) { - if (produceDiagnostics) { + var baseTypes = getBaseTypes(type); + if (baseTypes.length && produceDiagnostics) { var baseType = baseTypes[0]; + var staticBaseType = getBaseConstructorTypeOfClass(type); + if (baseTypeNode.typeArguments) { + ts.forEach(baseTypeNode.typeArguments, checkSourceElement); + for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); _i < _a.length; _i++) { + var constructor = _a[_i]; + if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) { + break; + } + } + } checkTypeAssignableTo(type, baseType, node.name || node, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1); - var staticBaseType = getTypeOfSymbol(baseType.symbol); - checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); - if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, 107455 /* Value */)) { - error(baseTypeNode, ts.Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType)); + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); + if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32 /* Class */)) { + // When the static base type is a "class-like" constructor function (but not actually a class), we verify + // that all instantiated base constructor signatures return the same type. We can simply compare the type + // references (as opposed to checking the structure of the types) because elsewhere we have already checked + // that the base type is a class or interface type (and not, for example, an anonymous object type). + var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments); + if (ts.forEach(constructors, function (sig) { return getReturnTypeOfSignature(sig) !== baseType; })) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type); + } } checkKindsOfPropertyMemberOverrides(type, baseType); } } - if (baseTypes.length || (baseTypeNode && compilerOptions.isolatedModules)) { - // Check that base type can be evaluated as expression - checkExpressionOrQualifiedName(baseTypeNode.expression); - } var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node); if (implementedTypeNodes) { ts.forEach(implementedTypeNodes, function (typeRefNode) { if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) { error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments); } - checkExpressionWithTypeArguments(typeRefNode); + checkTypeReferenceNode(typeRefNode); if (produceDiagnostics) { var t = getTypeFromTypeNode(typeRefNode); if (t !== unknownType) { @@ -21335,7 +21885,7 @@ var ts; } } function isAccessor(kind) { - return kind === 137 /* GetAccessor */ || kind === 138 /* SetAccessor */; + return kind === 138 /* GetAccessor */ || kind === 139 /* SetAccessor */; } function areTypeParametersIdentical(list1, list2) { if (!list1 && !list2) { @@ -21399,13 +21949,13 @@ var ts; } function checkInterfaceDeclaration(node) { // Grammar checking - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node); checkTypeParameters(node.typeParameters); if (produceDiagnostics) { checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 203 /* InterfaceDeclaration */); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 205 /* InterfaceDeclaration */); if (symbol.declarations.length > 1) { if (node !== firstInterfaceDecl && !areTypeParametersIdentical(firstInterfaceDecl.typeParameters, node.typeParameters)) { error(node.name, ts.Diagnostics.All_declarations_of_an_interface_must_have_identical_type_parameters); @@ -21427,7 +21977,7 @@ var ts; if (!ts.isSupportedExpressionWithTypeArguments(heritageElement)) { error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments); } - checkExpressionWithTypeArguments(heritageElement); + checkTypeReferenceNode(heritageElement); }); ts.forEach(node.members, checkSourceElement); if (produceDiagnostics) { @@ -21449,7 +21999,7 @@ var ts; var ambient = ts.isInAmbientContext(node); var enumIsConst = ts.isConst(node); ts.forEach(node.members, function (member) { - if (member.name.kind !== 128 /* ComputedPropertyName */ && isNumericLiteralName(member.name.text)) { + if (member.name.kind !== 129 /* ComputedPropertyName */ && isNumericLiteralName(member.name.text)) { error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); } var initializer = member.initializer; @@ -21489,7 +22039,7 @@ var ts; return evalConstant(initializer); function evalConstant(e) { switch (e.kind) { - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: var value = evalConstant(e.operand); if (value === undefined) { return undefined; @@ -21500,7 +22050,7 @@ var ts; case 47 /* TildeToken */: return ~value; } return undefined; - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: var left = evalConstant(e.left); if (left === undefined) { return undefined; @@ -21525,11 +22075,11 @@ var ts; return undefined; case 7 /* NumericLiteral */: return +e.text; - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return evalConstant(e.expression); case 65 /* Identifier */: - case 157 /* ElementAccessExpression */: - case 156 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 158 /* PropertyAccessExpression */: var member = initializer.parent; var currentType = getTypeOfSymbol(getSymbolOfNode(member.parent)); var enumType; @@ -21542,7 +22092,7 @@ var ts; } else { var expression; - if (e.kind === 157 /* ElementAccessExpression */) { + if (e.kind === 159 /* ElementAccessExpression */) { if (e.argumentExpression === undefined || e.argumentExpression.kind !== 8 /* StringLiteral */) { return undefined; @@ -21560,7 +22110,7 @@ var ts; if (current.kind === 65 /* Identifier */) { break; } - else if (current.kind === 156 /* PropertyAccessExpression */) { + else if (current.kind === 158 /* PropertyAccessExpression */) { current = current.expression; } else { @@ -21599,7 +22149,7 @@ var ts; return; } // Grammar checking - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); @@ -21629,7 +22179,7 @@ var ts; var seenEnumMissingInitialInitializer = false; ts.forEach(enumSymbol.declarations, function (declaration) { // return true if we hit a violation of the rule, false otherwise - if (declaration.kind !== 205 /* EnumDeclaration */) { + if (declaration.kind !== 207 /* EnumDeclaration */) { return false; } var enumDeclaration = declaration; @@ -21652,8 +22202,8 @@ var ts; var declarations = symbol.declarations; for (var _i = 0; _i < declarations.length; _i++) { var declaration = declarations[_i]; - if ((declaration.kind === 202 /* ClassDeclaration */ || - (declaration.kind === 201 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) && + if ((declaration.kind === 204 /* ClassDeclaration */ || + (declaration.kind === 203 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { return declaration; } @@ -21676,7 +22226,15 @@ var ts; function checkModuleDeclaration(node) { if (produceDiagnostics) { // Grammar checking - if (!checkGrammarDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { + var isAmbientExternalModule = node.name.kind === 8 /* StringLiteral */; + var contextErrorMessage = isAmbientExternalModule + ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file + : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module; + if (checkGrammarModuleElementContext(node, contextErrorMessage)) { + // If we hit a module declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node)) { if (!ts.isInAmbientContext(node) && node.name.kind === 8 /* StringLiteral */) { grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); } @@ -21701,14 +22259,14 @@ var ts; } // if the module merges with a class declaration in the same lexical scope, // we need to track this to ensure the correct emit. - var mergedClass = ts.getDeclarationOfKind(symbol, 202 /* ClassDeclaration */); + var mergedClass = ts.getDeclarationOfKind(symbol, 204 /* ClassDeclaration */); if (mergedClass && inSameLexicalScope(node, mergedClass)) { getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */; } } // Checks for ambient external modules. - if (node.name.kind === 8 /* StringLiteral */) { + if (isAmbientExternalModule) { if (!isGlobalSourceFile(node.parent)) { error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules); } @@ -21721,10 +22279,10 @@ var ts; } function getFirstIdentifier(node) { while (true) { - if (node.kind === 127 /* QualifiedName */) { + if (node.kind === 128 /* QualifiedName */) { node = node.left; } - else if (node.kind === 156 /* PropertyAccessExpression */) { + else if (node.kind === 158 /* PropertyAccessExpression */) { node = node.expression; } else { @@ -21740,9 +22298,9 @@ var ts; error(moduleName, ts.Diagnostics.String_literal_expected); return false; } - var inAmbientExternalModule = node.parent.kind === 207 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; - if (node.parent.kind !== 228 /* SourceFile */ && !inAmbientExternalModule) { - error(moduleName, node.kind === 216 /* ExportDeclaration */ ? + var inAmbientExternalModule = node.parent.kind === 209 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; + if (node.parent.kind !== 230 /* SourceFile */ && !inAmbientExternalModule) { + error(moduleName, node.kind === 218 /* ExportDeclaration */ ? ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module); return false; @@ -21765,7 +22323,7 @@ var ts; (symbol.flags & 793056 /* Type */ ? 793056 /* Type */ : 0) | (symbol.flags & 1536 /* Namespace */ ? 1536 /* Namespace */ : 0); if (target.flags & excludedMeanings) { - var message = node.kind === 218 /* ExportSpecifier */ ? + var message = node.kind === 220 /* ExportSpecifier */ ? ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0; error(node, message, symbolToString(symbol)); @@ -21778,7 +22336,11 @@ var ts; checkAliasSymbol(node); } function checkImportDeclaration(node) { - if (!checkGrammarImportDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); } if (checkExternalImportOrExportDeclaration(node)) { @@ -21788,7 +22350,7 @@ var ts; checkImportBinding(importClause); } if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 214 /* NamespaceImport */) { checkImportBinding(importClause.namedBindings); } else { @@ -21799,7 +22361,11 @@ var ts; } } function checkImportEqualsDeclaration(node) { - checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node); + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) { + // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + checkGrammarDecorators(node) || checkGrammarModifiers(node); if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) { checkImportBinding(node); if (node.flags & 1 /* Export */) { @@ -21829,6 +22395,10 @@ var ts; } } function checkExportDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) { + // If we hit an export in an illegal context, just bail out to avoid cascading errors. + return; + } if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 499 /* Modifier */)) { grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); } @@ -21837,8 +22407,8 @@ var ts; // export { x, y } // export { x, y } from "foo" ts.forEach(node.exportClause.elements, checkExportSpecifier); - var inAmbientExternalModule = node.parent.kind === 207 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; - if (node.parent.kind !== 228 /* SourceFile */ && !inAmbientExternalModule) { + var inAmbientExternalModule = node.parent.kind === 209 /* ModuleBlock */ && node.parent.parent.name.kind === 8 /* StringLiteral */; + if (node.parent.kind !== 230 /* SourceFile */ && !inAmbientExternalModule) { error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace); } } @@ -21851,6 +22421,11 @@ var ts; } } } + function checkGrammarModuleElementContext(node, errorMessage) { + if (node.parent.kind !== 230 /* SourceFile */ && node.parent.kind !== 209 /* ModuleBlock */ && node.parent.kind !== 208 /* ModuleDeclaration */) { + return grammarErrorOnFirstToken(node, errorMessage); + } + } function checkExportSpecifier(node) { checkAliasSymbol(node); if (!node.parent.parent.moduleSpecifier) { @@ -21858,8 +22433,12 @@ var ts; } } function checkExportAssignment(node) { - var container = node.parent.kind === 228 /* SourceFile */ ? node.parent : node.parent.parent; - if (container.kind === 206 /* ModuleDeclaration */ && container.name.kind === 65 /* Identifier */) { + if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) { + // If we hit an export assignment in an illegal context, just bail out to avoid cascading errors. + return; + } + var container = node.parent.kind === 230 /* SourceFile */ ? node.parent : node.parent.parent; + if (container.kind === 208 /* ModuleDeclaration */ && container.name.kind === 65 /* Identifier */) { error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace); return; } @@ -21886,10 +22465,10 @@ var ts; } } function getModuleStatements(node) { - if (node.kind === 228 /* SourceFile */) { + if (node.kind === 230 /* SourceFile */) { return node.statements; } - if (node.kind === 206 /* ModuleDeclaration */ && node.body.kind === 207 /* ModuleBlock */) { + if (node.kind === 208 /* ModuleDeclaration */ && node.body.kind === 209 /* ModuleBlock */) { return node.body.statements; } return emptyArray; @@ -21914,111 +22493,118 @@ var ts; links.exportsChecked = true; } } + function checkTypePredicate(node) { + if (!isInLegalTypePredicatePosition(node)) { + error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + } + } function checkSourceElement(node) { if (!node) return; switch (node.kind) { - case 129 /* TypeParameter */: + case 130 /* TypeParameter */: return checkTypeParameter(node); - case 130 /* Parameter */: + case 131 /* Parameter */: return checkParameter(node); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return checkPropertyDeclaration(node); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: return checkSignatureDeclaration(node); - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: return checkSignatureDeclaration(node); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return checkMethodDeclaration(node); - case 136 /* Constructor */: + case 137 /* Constructor */: return checkConstructorDeclaration(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return checkAccessorDeclaration(node); - case 142 /* TypeReference */: + case 144 /* TypeReference */: return checkTypeReferenceNode(node); - case 145 /* TypeQuery */: + case 143 /* TypePredicate */: + return checkTypePredicate(node); + case 147 /* TypeQuery */: return checkTypeQuery(node); - case 146 /* TypeLiteral */: + case 148 /* TypeLiteral */: return checkTypeLiteral(node); - case 147 /* ArrayType */: + case 149 /* ArrayType */: return checkArrayType(node); - case 148 /* TupleType */: + case 150 /* TupleType */: return checkTupleType(node); - case 149 /* UnionType */: + case 151 /* UnionType */: return checkUnionType(node); - case 150 /* ParenthesizedType */: + case 152 /* ParenthesizedType */: return checkSourceElement(node.type); - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return checkFunctionDeclaration(node); - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return checkBlock(node); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return checkVariableStatement(node); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: return checkExpressionStatement(node); - case 184 /* IfStatement */: + case 186 /* IfStatement */: return checkIfStatement(node); - case 185 /* DoStatement */: + case 187 /* DoStatement */: return checkDoStatement(node); - case 186 /* WhileStatement */: + case 188 /* WhileStatement */: return checkWhileStatement(node); - case 187 /* ForStatement */: + case 189 /* ForStatement */: return checkForStatement(node); - case 188 /* ForInStatement */: + case 190 /* ForInStatement */: return checkForInStatement(node); - case 189 /* ForOfStatement */: + case 191 /* ForOfStatement */: return checkForOfStatement(node); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 193 /* BreakStatement */: return checkBreakOrContinueStatement(node); - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: return checkReturnStatement(node); - case 193 /* WithStatement */: + case 195 /* WithStatement */: return checkWithStatement(node); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: return checkSwitchStatement(node); - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return checkLabeledStatement(node); - case 196 /* ThrowStatement */: + case 198 /* ThrowStatement */: return checkThrowStatement(node); - case 197 /* TryStatement */: + case 199 /* TryStatement */: return checkTryStatement(node); - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: return checkVariableDeclaration(node); - case 153 /* BindingElement */: + case 155 /* BindingElement */: return checkBindingElement(node); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return checkClassDeclaration(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return checkInterfaceDeclaration(node); - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: return checkTypeAliasDeclaration(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return checkEnumDeclaration(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return checkModuleDeclaration(node); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: return checkImportDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return checkImportEqualsDeclaration(node); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return checkExportDeclaration(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return checkExportAssignment(node); - case 182 /* EmptyStatement */: + case 184 /* EmptyStatement */: checkGrammarStatementInAmbientContext(node); return; - case 198 /* DebuggerStatement */: + case 200 /* DebuggerStatement */: checkGrammarStatementInAmbientContext(node); return; - case 219 /* MissingDeclaration */: + case 221 /* MissingDeclaration */: return checkMissingDeclaration(node); } } @@ -22033,83 +22619,83 @@ var ts; // Delaying the type check of the body ensures foo has been assigned a type. function checkFunctionExpressionBodies(node) { switch (node.kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: ts.forEach(node.parameters, checkFunctionExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: ts.forEach(node.decorators, checkFunctionExpressionBodies); ts.forEach(node.parameters, checkFunctionExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } break; - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: ts.forEach(node.parameters, checkFunctionExpressionBodies); break; - case 193 /* WithStatement */: + case 195 /* WithStatement */: checkFunctionExpressionBodies(node.expression); break; - case 131 /* Decorator */: - case 130 /* Parameter */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 153 /* BindingElement */: - case 154 /* ArrayLiteralExpression */: - case 155 /* ObjectLiteralExpression */: - case 225 /* PropertyAssignment */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 160 /* TaggedTemplateExpression */: - case 172 /* TemplateExpression */: - case 178 /* TemplateSpan */: - case 161 /* TypeAssertionExpression */: - case 162 /* ParenthesizedExpression */: - case 166 /* TypeOfExpression */: - case 167 /* VoidExpression */: - case 165 /* DeleteExpression */: - case 168 /* PrefixUnaryExpression */: - case 169 /* PostfixUnaryExpression */: - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: - case 174 /* SpreadElementExpression */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 181 /* VariableStatement */: - case 183 /* ExpressionStatement */: - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: - case 192 /* ReturnStatement */: - case 194 /* SwitchStatement */: - case 208 /* CaseBlock */: - case 221 /* CaseClause */: - case 222 /* DefaultClause */: - case 195 /* LabeledStatement */: - case 196 /* ThrowStatement */: - case 197 /* TryStatement */: - case 224 /* CatchClause */: - case 199 /* VariableDeclaration */: - case 200 /* VariableDeclarationList */: - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 215 /* ExportAssignment */: - case 228 /* SourceFile */: + case 132 /* Decorator */: + case 131 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: + case 155 /* BindingElement */: + case 156 /* ArrayLiteralExpression */: + case 157 /* ObjectLiteralExpression */: + case 227 /* PropertyAssignment */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 162 /* TaggedTemplateExpression */: + case 174 /* TemplateExpression */: + case 180 /* TemplateSpan */: + case 163 /* TypeAssertionExpression */: + case 164 /* ParenthesizedExpression */: + case 168 /* TypeOfExpression */: + case 169 /* VoidExpression */: + case 167 /* DeleteExpression */: + case 170 /* PrefixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: + case 172 /* BinaryExpression */: + case 173 /* ConditionalExpression */: + case 176 /* SpreadElementExpression */: + case 182 /* Block */: + case 209 /* ModuleBlock */: + case 183 /* VariableStatement */: + case 185 /* ExpressionStatement */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 192 /* ContinueStatement */: + case 193 /* BreakStatement */: + case 194 /* ReturnStatement */: + case 196 /* SwitchStatement */: + case 210 /* CaseBlock */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: + case 197 /* LabeledStatement */: + case 198 /* ThrowStatement */: + case 199 /* TryStatement */: + case 226 /* CatchClause */: + case 201 /* VariableDeclaration */: + case 202 /* VariableDeclarationList */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 229 /* EnumMember */: + case 217 /* ExportAssignment */: + case 230 /* SourceFile */: ts.forEachChild(node, checkFunctionExpressionBodies); break; } @@ -22123,6 +22709,11 @@ var ts; function checkSourceFileWorker(node) { var links = getNodeLinks(node); if (!(links.flags & 1 /* TypeChecked */)) { + // Check whether the file has declared it is the default lib, + // and whether the user has specifically chosen to avoid checking it. + if (node.isDefaultLib && compilerOptions.skipDefaultLibCheck) { + return; + } // Grammar checking checkGrammarSourceFile(node); emitExtends = false; @@ -22172,7 +22763,7 @@ var ts; function isInsideWithStatementBody(node) { if (node) { while (node.parent) { - if (node.parent.kind === 193 /* WithStatement */ && node.parent.statement === node) { + if (node.parent.kind === 195 /* WithStatement */ && node.parent.statement === node) { return true; } node = node.parent; @@ -22195,23 +22786,23 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (!ts.isExternalModule(location)) { break; } - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */); break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: if (!(memberFlags & 128 /* Static */)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */); } break; - case 163 /* FunctionExpression */: + case 165 /* FunctionExpression */: if (location.name) { copySymbol(location.symbol, meaning); } @@ -22249,22 +22840,22 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (!ts.isExternalModule(location)) break; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */); break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: if (!(memberFlags & 128 /* Static */)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */); } break; - case 163 /* FunctionExpression */: + case 165 /* FunctionExpression */: if (location.name) { copySymbol(location.symbol, meaning); } @@ -22277,43 +22868,43 @@ var ts; return symbolsToArray(symbols); } function isTypeDeclarationName(name) { - return name.kind == 65 /* Identifier */ && + return name.kind === 65 /* Identifier */ && isTypeDeclaration(name.parent) && name.parent.name === name; } function isTypeDeclaration(node) { switch (node.kind) { - case 129 /* TypeParameter */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: + case 130 /* TypeParameter */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 207 /* EnumDeclaration */: return true; } } // True if the given identifier is part of a type reference function isTypeReferenceIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 127 /* QualifiedName */) { + while (node.parent && node.parent.kind === 128 /* QualifiedName */) { node = node.parent; } - return node.parent && node.parent.kind === 142 /* TypeReference */; + return node.parent && node.parent.kind === 144 /* TypeReference */; } function isHeritageClauseElementIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 156 /* PropertyAccessExpression */) { + while (node.parent && node.parent.kind === 158 /* PropertyAccessExpression */) { node = node.parent; } - return node.parent && node.parent.kind === 177 /* ExpressionWithTypeArguments */; + return node.parent && node.parent.kind === 179 /* ExpressionWithTypeArguments */; } function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { - while (nodeOnRightSide.parent.kind === 127 /* QualifiedName */) { + while (nodeOnRightSide.parent.kind === 128 /* QualifiedName */) { nodeOnRightSide = nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 209 /* ImportEqualsDeclaration */) { + if (nodeOnRightSide.parent.kind === 211 /* ImportEqualsDeclaration */) { return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 215 /* ExportAssignment */) { + if (nodeOnRightSide.parent.kind === 217 /* ExportAssignment */) { return nodeOnRightSide.parent.expression === nodeOnRightSide && nodeOnRightSide.parent; } return undefined; @@ -22325,11 +22916,11 @@ var ts; if (ts.isDeclarationName(entityName)) { return getSymbolOfNode(entityName.parent); } - if (entityName.parent.kind === 215 /* ExportAssignment */) { + if (entityName.parent.kind === 217 /* ExportAssignment */) { return resolveEntityName(entityName, /*all meanings*/ 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */); } - if (entityName.kind !== 156 /* PropertyAccessExpression */) { + if (entityName.kind !== 158 /* PropertyAccessExpression */) { if (isInRightSideOfImportOrExportAssignment(entityName)) { // Since we already checked for ExportAssignment, this really could only be an Import return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); @@ -22339,7 +22930,7 @@ var ts; entityName = entityName.parent; } if (isHeritageClauseElementIdentifier(entityName)) { - var meaning = entityName.parent.kind === 177 /* ExpressionWithTypeArguments */ ? 793056 /* Type */ : 1536 /* Namespace */; + var meaning = entityName.parent.kind === 179 /* ExpressionWithTypeArguments */ ? 793056 /* Type */ : 1536 /* Namespace */; meaning |= 8388608 /* Alias */; return resolveEntityName(entityName, meaning); } @@ -22354,14 +22945,14 @@ var ts; var meaning = 107455 /* Value */ | 8388608 /* Alias */; return resolveEntityName(entityName, meaning); } - else if (entityName.kind === 156 /* PropertyAccessExpression */) { + else if (entityName.kind === 158 /* PropertyAccessExpression */) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkPropertyAccessExpression(entityName); } return getNodeLinks(entityName).resolvedSymbol; } - else if (entityName.kind === 127 /* QualifiedName */) { + else if (entityName.kind === 128 /* QualifiedName */) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkQualifiedName(entityName); @@ -22370,7 +22961,7 @@ var ts; } } else if (isTypeReferenceIdentifier(entityName)) { - var meaning = entityName.parent.kind === 142 /* TypeReference */ ? 793056 /* Type */ : 1536 /* Namespace */; + var meaning = entityName.parent.kind === 144 /* TypeReference */ ? 793056 /* Type */ : 1536 /* Namespace */; // Include aliases in the meaning, this ensures that we do not follow aliases to where they point and instead // return the alias symbol. meaning |= 8388608 /* Alias */; @@ -22389,14 +22980,14 @@ var ts; return getSymbolOfNode(node.parent); } if (node.kind === 65 /* Identifier */ && isInRightSideOfImportOrExportAssignment(node)) { - return node.parent.kind === 215 /* ExportAssignment */ + return node.parent.kind === 217 /* ExportAssignment */ ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); } switch (node.kind) { case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: + case 158 /* PropertyAccessExpression */: + case 128 /* QualifiedName */: return getSymbolOfEntityNameOrPropertyAccessExpression(node); case 93 /* ThisKeyword */: case 91 /* SuperKeyword */: @@ -22405,7 +22996,7 @@ var ts; case 114 /* ConstructorKeyword */: // constructor keyword for an overload, should take us to the definition if it exist var constructorDeclaration = node.parent; - if (constructorDeclaration && constructorDeclaration.kind === 136 /* Constructor */) { + if (constructorDeclaration && constructorDeclaration.kind === 137 /* Constructor */) { return constructorDeclaration.parent.symbol; } return undefined; @@ -22414,14 +23005,14 @@ var ts; var moduleName; if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) || - ((node.parent.kind === 210 /* ImportDeclaration */ || node.parent.kind === 216 /* ExportDeclaration */) && + ((node.parent.kind === 212 /* ImportDeclaration */ || node.parent.kind === 218 /* ExportDeclaration */) && node.parent.moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } // Intentional fall-through case 7 /* NumericLiteral */: // index access - if (node.parent.kind == 157 /* ElementAccessExpression */ && node.parent.argumentExpression === node) { + if (node.parent.kind === 159 /* ElementAccessExpression */ && node.parent.argumentExpression === node) { var objectType = checkExpression(node.parent.expression); if (objectType === unknownType) return undefined; @@ -22438,7 +23029,7 @@ var ts; // The function returns a value symbol of an identifier in the short-hand property assignment. // This is necessary as an identifier in short-hand property assignment can contains two meaning: // property name and property value. - if (location && location.kind === 226 /* ShorthandPropertyAssignment */) { + if (location && location.kind === 228 /* ShorthandPropertyAssignment */) { return resolveEntityName(location.name, 107455 /* Value */); } return undefined; @@ -22454,6 +23045,11 @@ var ts; if (ts.isExpression(node)) { return getTypeOfExpression(node); } + if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(node)) { + // A SyntaxKind.ExpressionWithTypeArguments is considered a type node, except when it occurs in the + // extends clause of a class. We handle that case here. + return getBaseTypes(getDeclaredTypeOfSymbol(getSymbolOfNode(node.parent.parent)))[0]; + } if (isTypeDeclaration(node)) { // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration var symbol = getSymbolOfNode(node); @@ -22517,93 +23113,92 @@ var ts; return [symbol]; } // Emitter support - function isExternalModuleSymbol(symbol) { - return symbol.flags & 512 /* ValueModule */ && symbol.declarations.length === 1 && symbol.declarations[0].kind === 228 /* SourceFile */; - } - function getAliasNameSubstitution(symbol, getGeneratedNameForNode) { - // If this is es6 or higher, just use the name of the export - // no need to qualify it. - if (languageVersion >= 2 /* ES6 */) { - return undefined; - } - var node = getDeclarationOfAliasSymbol(symbol); - if (node) { - if (node.kind === 211 /* ImportClause */) { - var defaultKeyword; - if (languageVersion === 0 /* ES3 */) { - defaultKeyword = "[\"default\"]"; - } - else { - defaultKeyword = ".default"; - } - return getGeneratedNameForNode(node.parent) + defaultKeyword; - } - if (node.kind === 214 /* ImportSpecifier */) { - var moduleName = getGeneratedNameForNode(node.parent.parent.parent); - var propertyName = node.propertyName || node.name; - return moduleName + "." + ts.unescapeIdentifier(propertyName.text); - } - } - } - function getExportNameSubstitution(symbol, location, getGeneratedNameForNode) { - if (isExternalModuleSymbol(symbol.parent)) { - // 1. If this is es6 or higher, just use the name of the export - // no need to qualify it. - // 2. export mechanism for System modules is different from CJS\AMD - // and it does not need qualifications for exports - if (languageVersion >= 2 /* ES6 */ || compilerOptions.module === 4 /* System */) { - return undefined; - } - return "exports." + ts.unescapeIdentifier(symbol.name); - } - var node = location; - var containerSymbol = getParentOfSymbol(symbol); - while (node) { - if ((node.kind === 206 /* ModuleDeclaration */ || node.kind === 205 /* EnumDeclaration */) && getSymbolOfNode(node) === containerSymbol) { - return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); - } - node = node.parent; - } - } - function getExpressionNameSubstitution(node, getGeneratedNameForNode) { - var symbol = getNodeLinks(node).resolvedSymbol || (ts.isDeclarationName(node) ? getSymbolOfNode(node.parent) : undefined); + // When resolved as an expression identifier, if the given node references an exported entity, return the declaration + // node of the exported entity's container. Otherwise, return undefined. + function getReferencedExportContainer(node) { + var symbol = getReferencedValueSymbol(node); if (symbol) { - // Whan an identifier resolves to a parented symbol, it references an exported entity from - // another declaration of the same internal module. - if (symbol.parent) { - return getExportNameSubstitution(symbol, node.parent, getGeneratedNameForNode); + if (symbol.flags & 1048576 /* ExportValue */) { + // If we reference an exported entity within the same module declaration, then whether + // we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the + // kinds that we do NOT prefix. + var exportSymbol = getMergedSymbol(symbol.exportSymbol); + if (exportSymbol.flags & 944 /* ExportHasLocal */) { + return undefined; + } + symbol = exportSymbol; } - // If we reference an exported entity within the same module declaration, then whether - // we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the - // kinds that we do NOT prefix. - var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); - if (symbol !== exportSymbol && !(exportSymbol.flags & 944 /* ExportHasLocal */)) { - return getExportNameSubstitution(exportSymbol, node.parent, getGeneratedNameForNode); - } - // Named imports from ES6 import declarations are rewritten - if (symbol.flags & 8388608 /* Alias */) { - return getAliasNameSubstitution(symbol, getGeneratedNameForNode); + var parentSymbol = getParentOfSymbol(symbol); + if (parentSymbol) { + if (parentSymbol.flags & 512 /* ValueModule */ && parentSymbol.valueDeclaration.kind === 230 /* SourceFile */) { + return parentSymbol.valueDeclaration; + } + for (var n = node.parent; n; n = n.parent) { + if ((n.kind === 208 /* ModuleDeclaration */ || n.kind === 207 /* EnumDeclaration */) && getSymbolOfNode(n) === parentSymbol) { + return n; + } + } } } } + // When resolved as an expression identifier, if the given node references an import, return the declaration of + // that import. Otherwise, return undefined. + function getReferencedImportDeclaration(node) { + var symbol = getReferencedValueSymbol(node); + return symbol && symbol.flags & 8388608 /* Alias */ ? getDeclarationOfAliasSymbol(symbol) : undefined; + } + function isStatementWithLocals(node) { + switch (node.kind) { + case 182 /* Block */: + case 210 /* CaseBlock */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + return true; + } + return false; + } + function isNestedRedeclarationSymbol(symbol) { + if (symbol.flags & 418 /* BlockScoped */) { + var links = getSymbolLinks(symbol); + if (links.isNestedRedeclaration === undefined) { + var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration); + links.isNestedRedeclaration = isStatementWithLocals(container) && + !!resolveName(container.parent, symbol.name, 107455 /* Value */, undefined, undefined); + } + return links.isNestedRedeclaration; + } + return false; + } + // When resolved as an expression identifier, if the given node references a nested block scoped entity with + // a name that hides an existing name, return the declaration of that entity. Otherwise, return undefined. + function getReferencedNestedRedeclaration(node) { + var symbol = getReferencedValueSymbol(node); + return symbol && isNestedRedeclarationSymbol(symbol) ? symbol.valueDeclaration : undefined; + } + // Return true if the given node is a declaration of a nested block scoped entity with a name that hides an + // existing name. + function isNestedRedeclaration(node) { + return isNestedRedeclarationSymbol(getSymbolOfNode(node)); + } function isValueAliasDeclaration(node) { switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 213 /* ImportClause */: + case 214 /* NamespaceImport */: + case 216 /* ImportSpecifier */: + case 220 /* ExportSpecifier */: return isAliasResolvedToValue(getSymbolOfNode(node)); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: var exportClause = node.exportClause; return exportClause && ts.forEach(exportClause.elements, isValueAliasDeclaration); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return node.expression && node.expression.kind === 65 /* Identifier */ ? isAliasResolvedToValue(getSymbolOfNode(node)) : true; } return false; } function isTopLevelValueImportEqualsWithEntityName(node) { - if (node.parent.kind !== 228 /* SourceFile */ || !ts.isInternalModuleImportEqualsDeclaration(node)) { + if (node.parent.kind !== 230 /* SourceFile */ || !ts.isInternalModuleImportEqualsDeclaration(node)) { // parent is not source file or it is not reference to internal module return false; } @@ -22661,7 +23256,7 @@ var ts; return getNodeLinks(node).enumMemberValue; } function getConstantValue(node) { - if (node.kind === 227 /* EnumMember */) { + if (node.kind === 229 /* EnumMember */) { return getEnumMemberValue(node); } var symbol = getNodeLinks(node).resolvedSymbol; @@ -22674,10 +23269,13 @@ var ts; return undefined; } /** Serializes an EntityName (with substitutions) to an appropriate JS constructor value. Used by the __metadata decorator. */ - function serializeEntityName(node, getGeneratedNameForNode, fallbackPath) { + function serializeEntityName(node, fallbackPath) { if (node.kind === 65 /* Identifier */) { - var substitution = getExpressionNameSubstitution(node, getGeneratedNameForNode); - var text = substitution || node.text; + // TODO(ron.buckton): The getExpressionNameSubstitution function has been removed, but calling it + // here has no effect anyway as an identifier in a type name is not an expression. + // var substitution = getExpressionNameSubstitution(node, getGeneratedNameForNode); + // var text = substitution || (node).text; + var text = node.text; if (fallbackPath) { fallbackPath.push(text); } @@ -22686,15 +23284,15 @@ var ts; } } else { - var left = serializeEntityName(node.left, getGeneratedNameForNode, fallbackPath); - var right = serializeEntityName(node.right, getGeneratedNameForNode, fallbackPath); + var left = serializeEntityName(node.left, fallbackPath); + var right = serializeEntityName(node.right, fallbackPath); if (!fallbackPath) { return left + "." + right; } } } /** Serializes a TypeReferenceNode to an appropriate JS constructor value. Used by the __metadata decorator. */ - function serializeTypeReferenceNode(node, getGeneratedNameForNode) { + function serializeTypeReferenceNode(node) { // serialization of a TypeReferenceNode uses the following rules: // // * The serialized type of a TypeReference that is `void` is "void 0". @@ -22727,11 +23325,11 @@ var ts; } else if (type === unknownType) { var fallbackPath = []; - serializeEntityName(node.typeName, getGeneratedNameForNode, fallbackPath); + serializeEntityName(node.typeName, fallbackPath); return fallbackPath; } else if (type.symbol && type.symbol.valueDeclaration) { - return serializeEntityName(node.typeName, getGeneratedNameForNode); + return serializeEntityName(node.typeName); } else if (typeHasCallOrConstructSignatures(type)) { return "Function"; @@ -22739,7 +23337,7 @@ var ts; return "Object"; } /** Serializes a TypeNode to an appropriate JS constructor value. Used by the __metadata decorator. */ - function serializeTypeNode(node, getGeneratedNameForNode) { + function serializeTypeNode(node) { // serialization of a TypeNode uses the following rules: // // * The serialized type of `void` is "void 0" (undefined). @@ -22754,26 +23352,26 @@ var ts; switch (node.kind) { case 99 /* VoidKeyword */: return "void 0"; - case 150 /* ParenthesizedType */: - return serializeTypeNode(node.type, getGeneratedNameForNode); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 152 /* ParenthesizedType */: + return serializeTypeNode(node.type); + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return "Function"; - case 147 /* ArrayType */: - case 148 /* TupleType */: + case 149 /* ArrayType */: + case 150 /* TupleType */: return "Array"; case 113 /* BooleanKeyword */: return "Boolean"; - case 122 /* StringKeyword */: + case 123 /* StringKeyword */: case 8 /* StringLiteral */: return "String"; - case 120 /* NumberKeyword */: + case 121 /* NumberKeyword */: return "Number"; - case 142 /* TypeReference */: - return serializeTypeReferenceNode(node, getGeneratedNameForNode); - case 145 /* TypeQuery */: - case 146 /* TypeLiteral */: - case 149 /* UnionType */: + case 144 /* TypeReference */: + return serializeTypeReferenceNode(node); + case 147 /* TypeQuery */: + case 148 /* TypeLiteral */: + case 151 /* UnionType */: case 112 /* AnyKeyword */: break; default: @@ -22784,7 +23382,7 @@ var ts; return "Object"; } /** Serializes the type of a declaration to an appropriate JS constructor value. Used by the __metadata decorator for a class member. */ - function serializeTypeOfNode(node, getGeneratedNameForNode) { + function serializeTypeOfNode(node) { // serialization of the type of a declaration uses the following rules: // // * The serialized type of a ClassDeclaration is "Function" @@ -22796,11 +23394,11 @@ var ts; // // For rules on serializing type annotations, see `serializeTypeNode`. switch (node.kind) { - case 202 /* ClassDeclaration */: return "Function"; - case 133 /* PropertyDeclaration */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 130 /* Parameter */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 137 /* GetAccessor */: return serializeTypeNode(node.type, getGeneratedNameForNode); - case 138 /* SetAccessor */: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node), getGeneratedNameForNode); + case 204 /* ClassDeclaration */: return "Function"; + case 134 /* PropertyDeclaration */: return serializeTypeNode(node.type); + case 131 /* Parameter */: return serializeTypeNode(node.type); + case 138 /* GetAccessor */: return serializeTypeNode(node.type); + case 139 /* SetAccessor */: return serializeTypeNode(getSetAccessorTypeAnnotationNode(node)); } if (ts.isFunctionLike(node)) { return "Function"; @@ -22808,7 +23406,7 @@ var ts; return "void 0"; } /** Serializes the parameter types of a function or the constructor of a class. Used by the __metadata decorator for a method or set accessor. */ - function serializeParameterTypesOfNode(node, getGeneratedNameForNode) { + function serializeParameterTypesOfNode(node) { // serialization of parameter types uses the following rules: // // * If the declaration is a class, the parameters of the first constructor with a body are used. @@ -22817,7 +23415,7 @@ var ts; // For the rules on serializing the type of each parameter declaration, see `serializeTypeOfDeclaration`. if (node) { var valueDeclaration; - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { valueDeclaration = ts.getFirstConstructorWithBody(node); } else if (ts.isFunctionLike(node) && ts.nodeIsPresent(node.body)) { @@ -22832,19 +23430,19 @@ var ts; for (var i = 0; i < parameterCount; i++) { if (parameters[i].dotDotDotToken) { var parameterType = parameters[i].type; - if (parameterType.kind === 147 /* ArrayType */) { + if (parameterType.kind === 149 /* ArrayType */) { parameterType = parameterType.elementType; } - else if (parameterType.kind === 142 /* TypeReference */ && parameterType.typeArguments && parameterType.typeArguments.length === 1) { + else if (parameterType.kind === 144 /* TypeReference */ && parameterType.typeArguments && parameterType.typeArguments.length === 1) { parameterType = parameterType.typeArguments[0]; } else { parameterType = undefined; } - result[i] = serializeTypeNode(parameterType, getGeneratedNameForNode); + result[i] = serializeTypeNode(parameterType); } else { - result[i] = serializeTypeOfNode(parameters[i], getGeneratedNameForNode); + result[i] = serializeTypeOfNode(parameters[i]); } } return result; @@ -22854,9 +23452,9 @@ var ts; return emptyArray; } /** Serializes the return type of function. Used by the __metadata decorator for a method. */ - function serializeReturnTypeOfNode(node, getGeneratedNameForNode) { + function serializeReturnTypeOfNode(node) { if (node && ts.isFunctionLike(node)) { - return serializeTypeNode(node.type, getGeneratedNameForNode); + return serializeTypeNode(node.type); } return "void 0"; } @@ -22879,25 +23477,25 @@ var ts; function hasGlobalName(name) { return ts.hasProperty(globals, name); } - function resolvesToSomeValue(location, name) { - ts.Debug.assert(!ts.nodeIsSynthesized(location), "resolvesToSomeValue called with a synthesized location"); - return !!resolveName(location, name, 107455 /* Value */, undefined, undefined); + function getReferencedValueSymbol(reference) { + return getNodeLinks(reference).resolvedSymbol || + resolveName(reference, reference.text, 107455 /* Value */ | 1048576 /* ExportValue */ | 8388608 /* Alias */, + /*nodeNotFoundMessage*/ undefined, undefined); } function getReferencedValueDeclaration(reference) { ts.Debug.assert(!ts.nodeIsSynthesized(reference)); - var symbol = getNodeLinks(reference).resolvedSymbol || - resolveName(reference, reference.text, 107455 /* Value */ | 8388608 /* Alias */, undefined, undefined); + var symbol = getReferencedValueSymbol(reference); return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration; } function getBlockScopedVariableId(n) { ts.Debug.assert(!ts.nodeIsSynthesized(n)); - var isVariableDeclarationOrBindingElement = n.parent.kind === 153 /* BindingElement */ || (n.parent.kind === 199 /* VariableDeclaration */ && n.parent.name === n); + var isVariableDeclarationOrBindingElement = n.parent.kind === 155 /* BindingElement */ || (n.parent.kind === 201 /* VariableDeclaration */ && n.parent.name === n); var symbol = (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) || getNodeLinks(n).resolvedSymbol || resolveName(n, n.text, 107455 /* Value */ | 8388608 /* Alias */, undefined, undefined); var isLetOrConst = symbol && (symbol.flags & 2 /* BlockScopedVariable */) && - symbol.valueDeclaration.parent.kind !== 224 /* CatchClause */; + symbol.valueDeclaration.parent.kind !== 226 /* CatchClause */; if (isLetOrConst) { // side-effect of calling this method: // assign id to symbol if it was not yet set @@ -22919,7 +23517,10 @@ var ts; } function createResolver() { return { - getExpressionNameSubstitution: getExpressionNameSubstitution, + getReferencedExportContainer: getReferencedExportContainer, + getReferencedImportDeclaration: getReferencedImportDeclaration, + getReferencedNestedRedeclaration: getReferencedNestedRedeclaration, + isNestedRedeclaration: isNestedRedeclaration, isValueAliasDeclaration: isValueAliasDeclaration, hasGlobalName: hasGlobalName, isReferencedAliasDeclaration: isReferencedAliasDeclaration, @@ -22933,7 +23534,6 @@ var ts; isSymbolAccessible: isSymbolAccessible, isEntityNameVisible: isEntityNameVisible, getConstantValue: getConstantValue, - resolvesToSomeValue: resolvesToSomeValue, collectLinkedAliases: collectLinkedAliases, getBlockScopedVariableId: getBlockScopedVariableId, getReferencedValueDeclaration: getReferencedValueDeclaration, @@ -22994,137 +23594,6 @@ var ts; anyArrayType = createArrayType(anyType); } // GRAMMAR CHECKING - function isReservedWordInStrictMode(node) { - // Check that originalKeywordKind is less than LastFutureReservedWord to see if an Identifier is a strict-mode reserved word - return (node.parserContextFlags & 1 /* StrictMode */) && - (102 /* FirstFutureReservedWord */ <= node.originalKeywordKind && node.originalKeywordKind <= 110 /* LastFutureReservedWord */); - } - function reportStrictModeGrammarErrorInClassDeclaration(identifier, message, arg0, arg1, arg2) { - // We are checking if this name is inside class declaration or class expression (which are under class definitions inside ES6 spec.) - // if so, we would like to give more explicit invalid usage error. - if (ts.getAncestor(identifier, 202 /* ClassDeclaration */) || ts.getAncestor(identifier, 175 /* ClassExpression */)) { - return grammarErrorOnNode(identifier, message, arg0); - } - return false; - } - function checkGrammarImportDeclarationNameInStrictMode(node) { - // Check if the import declaration used strict-mode reserved word in its names bindings - if (node.importClause) { - var impotClause = node.importClause; - if (impotClause.namedBindings) { - var nameBindings = impotClause.namedBindings; - if (nameBindings.kind === 212 /* NamespaceImport */) { - var name_15 = nameBindings.name; - if (isReservedWordInStrictMode(name_15)) { - var nameText = ts.declarationNameToString(name_15); - return grammarErrorOnNode(name_15, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - else if (nameBindings.kind === 213 /* NamedImports */) { - var reportError = false; - for (var _i = 0, _a = nameBindings.elements; _i < _a.length; _i++) { - var element = _a[_i]; - var name_16 = element.name; - if (isReservedWordInStrictMode(name_16)) { - var nameText = ts.declarationNameToString(name_16); - reportError = reportError || grammarErrorOnNode(name_16, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - return reportError; - } - } - } - return false; - } - function checkGrammarDeclarationNameInStrictMode(node) { - var name = node.name; - if (name && name.kind === 65 /* Identifier */ && isReservedWordInStrictMode(name)) { - var nameText = ts.declarationNameToString(name); - switch (node.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 201 /* FunctionDeclaration */: - case 129 /* TypeParameter */: - case 153 /* BindingElement */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: - return checkGrammarIdentifierInStrictMode(name); - case 202 /* ClassDeclaration */: - // Report an error if the class declaration uses strict-mode reserved word. - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText); - case 206 /* ModuleDeclaration */: - // Report an error if the module declaration uses strict-mode reserved word. - // TODO(yuisu): fix this when having external module in strict mode - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - case 209 /* ImportEqualsDeclaration */: - // TODO(yuisu): fix this when having external module in strict mode - return grammarErrorOnNode(name, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - } - } - return false; - } - function checkGrammarTypeReferenceInStrictMode(typeName) { - // Check if the type reference is using strict mode keyword - // Example: - // class C { - // foo(x: public){} // Error. - // } - if (typeName.kind === 65 /* Identifier */) { - checkGrammarTypeNameInStrictMode(typeName); - } - else if (typeName.kind === 127 /* QualifiedName */) { - // Walk from right to left and report a possible error at each Identifier in QualifiedName - // Example: - // x1: public.private.package // error at public and private - checkGrammarTypeNameInStrictMode(typeName.right); - checkGrammarTypeReferenceInStrictMode(typeName.left); - } - } - // This function will report an error for every identifier in property access expression - // whether it violates strict mode reserved words. - // Example: - // public // error at public - // public.private.package // error at public - // B.private.B // no error - function checkGrammarExpressionWithTypeArgumentsInStrictMode(expression) { - // Example: - // class C extends public // error at public - if (expression && expression.kind === 65 /* Identifier */) { - return checkGrammarIdentifierInStrictMode(expression); - } - else if (expression && expression.kind === 156 /* PropertyAccessExpression */) { - // Walk from left to right in PropertyAccessExpression until we are at the left most expression - // in PropertyAccessExpression. According to grammar production of MemberExpression, - // the left component expression is a PrimaryExpression (i.e. Identifier) while the other - // component after dots can be IdentifierName. - checkGrammarExpressionWithTypeArgumentsInStrictMode(expression.expression); - } - } - // The function takes an identifier itself or an expression which has SyntaxKind.Identifier. - function checkGrammarIdentifierInStrictMode(node, nameText) { - if (node && node.kind === 65 /* Identifier */ && isReservedWordInStrictMode(node)) { - if (!nameText) { - nameText = ts.declarationNameToString(node); - } - // TODO (yuisu): Fix when module is a strict mode - var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || - grammarErrorOnNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode, nameText); - return errorReport; - } - return false; - } - // The function takes an identifier when uses as a typeName in TypeReferenceNode - function checkGrammarTypeNameInStrictMode(node) { - if (node && node.kind === 65 /* Identifier */ && isReservedWordInStrictMode(node)) { - var nameText = ts.declarationNameToString(node); - // TODO (yuisu): Fix when module is a strict mode - var errorReport = reportStrictModeGrammarErrorInClassDeclaration(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode, nameText) || - grammarErrorOnNode(node, ts.Diagnostics.Type_expected_0_is_a_reserved_word_in_strict_mode, nameText); - return errorReport; - } - return false; - } function checkGrammarDecorators(node) { if (!node.decorators) { return false; @@ -23135,7 +23604,7 @@ var ts; else if (languageVersion < 1 /* ES5 */) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher); } - else if (node.kind === 137 /* GetAccessor */ || node.kind === 138 /* SetAccessor */) { + else if (node.kind === 138 /* GetAccessor */ || node.kind === 139 /* SetAccessor */) { var accessors = ts.getAllAccessorDeclarations(node.parent.members, node); if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name); @@ -23145,33 +23614,33 @@ var ts; } function checkGrammarModifiers(node) { switch (node.kind) { - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 141 /* IndexSignature */: - case 206 /* ModuleDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 216 /* ExportDeclaration */: - case 215 /* ExportAssignment */: - case 130 /* Parameter */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 137 /* Constructor */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 142 /* IndexSignature */: + case 208 /* ModuleDeclaration */: + case 212 /* ImportDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 218 /* ExportDeclaration */: + case 217 /* ExportAssignment */: + case 131 /* Parameter */: break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 181 /* VariableStatement */: - case 201 /* FunctionDeclaration */: - case 204 /* TypeAliasDeclaration */: - if (node.modifiers && node.parent.kind !== 207 /* ModuleBlock */ && node.parent.kind !== 228 /* SourceFile */) { + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 183 /* VariableStatement */: + case 203 /* FunctionDeclaration */: + case 206 /* TypeAliasDeclaration */: + if (node.modifiers && node.parent.kind !== 209 /* ModuleBlock */ && node.parent.kind !== 230 /* SourceFile */) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); } break; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: if (node.modifiers && (node.modifiers.length > 1 || node.modifiers[0].kind !== 70 /* ConstKeyword */) && - node.parent.kind !== 207 /* ModuleBlock */ && node.parent.kind !== 228 /* SourceFile */) { + node.parent.kind !== 209 /* ModuleBlock */ && node.parent.kind !== 230 /* SourceFile */) { return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); } break; @@ -23207,7 +23676,7 @@ var ts; else if (flags & 128 /* Static */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } - else if (node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + else if (node.parent.kind === 209 /* ModuleBlock */ || node.parent.kind === 230 /* SourceFile */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } flags |= ts.modifierToFlag(modifier.kind); @@ -23216,10 +23685,10 @@ var ts; if (flags & 128 /* Static */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); } - else if (node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + else if (node.parent.kind === 209 /* ModuleBlock */ || node.parent.kind === 230 /* SourceFile */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 131 /* Parameter */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } flags |= 128 /* Static */; @@ -23232,10 +23701,10 @@ var ts; else if (flags & 2 /* Ambient */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 204 /* ClassDeclaration */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 131 /* Parameter */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); } flags |= 1 /* Export */; @@ -23244,13 +23713,13 @@ var ts; if (flags & 2 /* Ambient */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 204 /* ClassDeclaration */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } - else if (node.kind === 130 /* Parameter */) { + else if (node.kind === 131 /* Parameter */) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); } - else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 207 /* ModuleBlock */) { + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 209 /* ModuleBlock */) { return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } flags |= 2 /* Ambient */; @@ -23258,7 +23727,7 @@ var ts; break; } } - if (node.kind === 136 /* Constructor */) { + if (node.kind === 137 /* Constructor */) { if (flags & 128 /* Static */) { return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } @@ -23269,10 +23738,10 @@ var ts; return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } } - else if ((node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) { + else if ((node.kind === 212 /* ImportDeclaration */ || node.kind === 211 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); } - else if (node.kind === 130 /* Parameter */ && (flags & 112 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) { + else if (node.kind === 131 /* Parameter */ && (flags & 112 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) { return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } } @@ -23336,7 +23805,7 @@ var ts; checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file); } function checkGrammarArrowFunction(node, file) { - if (node.kind === 164 /* ArrowFunction */) { + if (node.kind === 166 /* ArrowFunction */) { var arrowFunction = node; var startLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.pos).line; var endLine = ts.getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.end).line; @@ -23371,7 +23840,7 @@ var ts; if (!parameter.type) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation); } - if (parameter.type.kind !== 122 /* StringKeyword */ && parameter.type.kind !== 120 /* NumberKeyword */) { + if (parameter.type.kind !== 123 /* StringKeyword */ && parameter.type.kind !== 121 /* NumberKeyword */) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); } if (!node.type) { @@ -23404,7 +23873,7 @@ var ts; var sourceFile = ts.getSourceFileOfNode(node); for (var _i = 0; _i < arguments.length; _i++) { var arg = arguments[_i]; - if (arg.kind === 176 /* OmittedExpression */) { + if (arg.kind === 178 /* OmittedExpression */) { return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); } } @@ -23478,19 +23947,19 @@ var ts; } function checkGrammarComputedPropertyName(node) { // If node is not a computedPropertyName, just skip the grammar checking - if (node.kind !== 128 /* ComputedPropertyName */) { + if (node.kind !== 129 /* ComputedPropertyName */) { return false; } var computedPropertyName = node; - if (computedPropertyName.expression.kind === 170 /* BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 23 /* CommaToken */) { + if (computedPropertyName.expression.kind === 172 /* BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 23 /* CommaToken */) { return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); } } function checkGrammarForGenerator(node) { if (node.asteriskToken) { - ts.Debug.assert(node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */ || - node.kind === 135 /* MethodDeclaration */); + ts.Debug.assert(node.kind === 203 /* FunctionDeclaration */ || + node.kind === 165 /* FunctionExpression */ || + node.kind === 136 /* MethodDeclaration */); if (ts.isInAmbientContext(node)) { return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context); } @@ -23502,10 +23971,6 @@ var ts; } } } - function checkGrammarFunctionName(name) { - // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1)) - return checkGrammarEvalOrArgumentsInStrictMode(name, name); - } function checkGrammarForInvalidQuestionMark(node, questionToken, message) { if (questionToken) { return grammarErrorOnNode(questionToken, message); @@ -23517,14 +23982,13 @@ var ts; var GetAccessor = 2; var SetAccesor = 4; var GetOrSetAccessor = GetAccessor | SetAccesor; - var inStrictMode = (node.parserContextFlags & 1 /* StrictMode */) !== 0; for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { var prop = _a[_i]; - var name_17 = prop.name; - if (prop.kind === 176 /* OmittedExpression */ || - name_17.kind === 128 /* ComputedPropertyName */) { + var name_15 = prop.name; + if (prop.kind === 178 /* OmittedExpression */ || + name_15.kind === 129 /* ComputedPropertyName */) { // If the name is not a ComputedPropertyName, the grammar checking will skip it - checkGrammarComputedPropertyName(name_17); + checkGrammarComputedPropertyName(name_15); continue; } // ECMA-262 11.1.5 Object Initialiser @@ -23536,46 +24000,44 @@ var ts; // d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields var currentKind = void 0; - if (prop.kind === 225 /* PropertyAssignment */ || prop.kind === 226 /* ShorthandPropertyAssignment */) { + if (prop.kind === 227 /* PropertyAssignment */ || prop.kind === 228 /* ShorthandPropertyAssignment */) { // Grammar checking for computedPropertName and shorthandPropertyAssignment checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); - if (name_17.kind === 7 /* NumericLiteral */) { - checkGrammarNumericLiteral(name_17); + if (name_15.kind === 7 /* NumericLiteral */) { + checkGrammarNumericLiteral(name_15); } currentKind = Property; } - else if (prop.kind === 135 /* MethodDeclaration */) { + else if (prop.kind === 136 /* MethodDeclaration */) { currentKind = Property; } - else if (prop.kind === 137 /* GetAccessor */) { + else if (prop.kind === 138 /* GetAccessor */) { currentKind = GetAccessor; } - else if (prop.kind === 138 /* SetAccessor */) { + else if (prop.kind === 139 /* SetAccessor */) { currentKind = SetAccesor; } else { ts.Debug.fail("Unexpected syntax kind:" + prop.kind); } - if (!ts.hasProperty(seen, name_17.text)) { - seen[name_17.text] = currentKind; + if (!ts.hasProperty(seen, name_15.text)) { + seen[name_15.text] = currentKind; } else { - var existingKind = seen[name_17.text]; + var existingKind = seen[name_15.text]; if (currentKind === Property && existingKind === Property) { - if (inStrictMode) { - grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode); - } + continue; } else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) { if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) { - seen[name_17.text] = currentKind | existingKind; + seen[name_15.text] = currentKind | existingKind; } else { - return grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); + return grammarErrorOnNode(name_15, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); } } else { - return grammarErrorOnNode(name_17, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); + return grammarErrorOnNode(name_15, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); } } } @@ -23584,24 +24046,24 @@ var ts; if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; } - if (forInOrOfStatement.initializer.kind === 200 /* VariableDeclarationList */) { + if (forInOrOfStatement.initializer.kind === 202 /* VariableDeclarationList */) { var variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { if (variableList.declarations.length > 1) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 190 /* ForInStatement */ ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement; return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic); } var firstDeclaration = variableList.declarations[0]; if (firstDeclaration.initializer) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 190 /* ForInStatement */ ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer; return grammarErrorOnNode(firstDeclaration.name, diagnostic); } if (firstDeclaration.type) { - var diagnostic = forInOrOfStatement.kind === 188 /* ForInStatement */ + var diagnostic = forInOrOfStatement.kind === 190 /* ForInStatement */ ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation; return grammarErrorOnNode(firstDeclaration, diagnostic); @@ -23624,10 +24086,10 @@ var ts; else if (accessor.typeParameters) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); } - else if (kind === 137 /* GetAccessor */ && accessor.parameters.length) { + else if (kind === 138 /* GetAccessor */ && accessor.parameters.length) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); } - else if (kind === 138 /* SetAccessor */) { + else if (kind === 139 /* SetAccessor */) { if (accessor.type) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); } @@ -23652,7 +24114,7 @@ var ts; } } function checkGrammarForNonSymbolComputedProperty(node, message) { - if (node.kind === 128 /* ComputedPropertyName */ && !ts.isWellKnownSymbolSyntactically(node.expression)) { + if (node.kind === 129 /* ComputedPropertyName */ && !ts.isWellKnownSymbolSyntactically(node.expression)) { return grammarErrorOnNode(node, message); } } @@ -23662,7 +24124,7 @@ var ts; checkGrammarForGenerator(node)) { return true; } - if (node.parent.kind === 155 /* ObjectLiteralExpression */) { + if (node.parent.kind === 157 /* ObjectLiteralExpression */) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -23670,7 +24132,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.kind === 204 /* ClassDeclaration */) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -23686,22 +24148,22 @@ var ts; return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol); } } - else if (node.parent.kind === 203 /* InterfaceDeclaration */) { + else if (node.parent.kind === 205 /* InterfaceDeclaration */) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol); } - else if (node.parent.kind === 146 /* TypeLiteral */) { + else if (node.parent.kind === 148 /* TypeLiteral */) { return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol); } } function isIterationStatement(node, lookInLabeledStatements) { switch (node.kind) { - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: return true; - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); } return false; @@ -23713,11 +24175,11 @@ var ts; return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); } switch (current.kind) { - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: if (node.label && current.label.text === node.label.text) { // found matching label - verify that label usage is correct // continue can only target labels that are on iteration statements - var isMisplacedContinueLabel = node.kind === 190 /* ContinueStatement */ + var isMisplacedContinueLabel = node.kind === 192 /* ContinueStatement */ && !isIterationStatement(current.statement, true); if (isMisplacedContinueLabel) { return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement); @@ -23725,8 +24187,8 @@ var ts; return false; } break; - case 194 /* SwitchStatement */: - if (node.kind === 191 /* BreakStatement */ && !node.label) { + case 196 /* SwitchStatement */: + if (node.kind === 193 /* BreakStatement */ && !node.label) { // unlabeled break within switch statement - ok return false; } @@ -23741,13 +24203,13 @@ var ts; current = current.parent; } if (node.label) { - var message = node.kind === 191 /* BreakStatement */ + var message = node.kind === 193 /* BreakStatement */ ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); } else { - var message = node.kind === 191 /* BreakStatement */ + var message = node.kind === 193 /* BreakStatement */ ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement; return grammarErrorOnNode(node, message); @@ -23759,7 +24221,7 @@ var ts; if (node !== ts.lastOrUndefined(elements)) { return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern); } - if (node.name.kind === 152 /* ArrayBindingPattern */ || node.name.kind === 151 /* ObjectBindingPattern */) { + if (node.name.kind === 154 /* ArrayBindingPattern */ || node.name.kind === 153 /* ObjectBindingPattern */) { return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern); } if (node.initializer) { @@ -23767,12 +24229,9 @@ var ts; return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); } } - // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code - // and its Identifier is eval or arguments - return checkGrammarEvalOrArgumentsInStrictMode(node, node.name); } function checkGrammarVariableDeclaration(node) { - if (node.parent.parent.kind !== 188 /* ForInStatement */ && node.parent.parent.kind !== 189 /* ForOfStatement */) { + if (node.parent.parent.kind !== 190 /* ForInStatement */ && node.parent.parent.kind !== 191 /* ForOfStatement */) { if (ts.isInAmbientContext(node)) { if (node.initializer) { // Error on equals token which immediate precedes the initializer @@ -23796,8 +24255,7 @@ var ts; // It is a Syntax Error if the BoundNames of ForDeclaration contains "let". // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code // and its Identifier is eval or arguments - return (checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name)) || - checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name); } function checkGrammarNameInLetOrConstDeclarations(name) { if (name.kind === 65 /* Identifier */) { @@ -23809,7 +24267,7 @@ var ts; var elements = name.elements; for (var _i = 0; _i < elements.length; _i++) { var element = elements[_i]; - if (element.kind !== 176 /* OmittedExpression */) { + if (element.kind !== 178 /* OmittedExpression */) { checkGrammarNameInLetOrConstDeclarations(element.name); } } @@ -23826,15 +24284,15 @@ var ts; } function allowLetAndConstDeclarations(parent) { switch (parent.kind) { - case 184 /* IfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 193 /* WithStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 186 /* IfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 195 /* WithStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: return false; - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return allowLetAndConstDeclarations(parent.parent); } return true; @@ -23850,7 +24308,7 @@ var ts; } } function isIntegerLiteral(expression) { - if (expression.kind === 168 /* PrefixUnaryExpression */) { + if (expression.kind === 170 /* PrefixUnaryExpression */) { var unaryExpression = expression; if (unaryExpression.operator === 33 /* PlusToken */ || unaryExpression.operator === 34 /* MinusToken */) { expression = unaryExpression.operand; @@ -23879,7 +24337,7 @@ var ts; // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including // well known symbols. - if (node.name.kind === 128 /* ComputedPropertyName */) { + if (node.name.kind === 129 /* ComputedPropertyName */) { hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); } else if (inAmbientContext) { @@ -23921,26 +24379,6 @@ var ts; return true; } } - function checkGrammarEvalOrArgumentsInStrictMode(contextNode, name) { - if (name && name.kind === 65 /* Identifier */) { - var identifier = name; - if (contextNode && (contextNode.parserContextFlags & 1 /* StrictMode */) && isEvalOrArgumentsIdentifier(identifier)) { - var nameText = ts.declarationNameToString(identifier); - // We check first if the name is inside class declaration or class expression; if so give explicit message - // otherwise report generic error message. - // reportGrammarErrorInClassDeclaration only return true if grammar error is successfully reported and false otherwise - var reportErrorInClassDeclaration = reportStrictModeGrammarErrorInClassDeclaration(identifier, ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode, nameText); - if (!reportErrorInClassDeclaration) { - return grammarErrorOnNode(identifier, ts.Diagnostics.Invalid_use_of_0_in_strict_mode, nameText); - } - return reportErrorInClassDeclaration; - } - } - } - function isEvalOrArgumentsIdentifier(node) { - return node.kind === 65 /* Identifier */ && - (node.text === "eval" || node.text === "arguments"); - } function checkGrammarConstructorTypeParameters(node) { if (node.typeParameters) { return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration); @@ -23952,18 +24390,18 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.kind === 204 /* ClassDeclaration */) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 203 /* InterfaceDeclaration */) { + else if (node.parent.kind === 205 /* InterfaceDeclaration */) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol)) { return true; } } - else if (node.parent.kind === 146 /* TypeLiteral */) { + else if (node.parent.kind === 148 /* TypeLiteral */) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { return true; } @@ -23983,11 +24421,11 @@ var ts; // export_opt ExternalImportDeclaration // export_opt AmbientDeclaration // - if (node.kind === 203 /* InterfaceDeclaration */ || - node.kind === 210 /* ImportDeclaration */ || - node.kind === 209 /* ImportEqualsDeclaration */ || - node.kind === 216 /* ExportDeclaration */ || - node.kind === 215 /* ExportAssignment */ || + if (node.kind === 205 /* InterfaceDeclaration */ || + node.kind === 212 /* ImportDeclaration */ || + node.kind === 211 /* ImportEqualsDeclaration */ || + node.kind === 218 /* ExportDeclaration */ || + node.kind === 217 /* ExportAssignment */ || (node.flags & 2 /* Ambient */) || (node.flags & (1 /* Export */ | 256 /* Default */))) { return false; @@ -23997,7 +24435,7 @@ var ts; function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { var decl = _a[_i]; - if (ts.isDeclaration(decl) || decl.kind === 181 /* VariableStatement */) { + if (ts.isDeclaration(decl) || decl.kind === 183 /* VariableStatement */) { if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { return true; } @@ -24023,7 +24461,7 @@ var ts; // to prevent noisyness. So use a bit on the block to indicate if // this has already been reported, and don't report if it has. // - if (node.parent.kind === 180 /* Block */ || node.parent.kind === 207 /* ModuleBlock */ || node.parent.kind === 228 /* SourceFile */) { + if (node.parent.kind === 182 /* Block */ || node.parent.kind === 209 /* ModuleBlock */ || node.parent.kind === 230 /* SourceFile */) { var links_1 = getNodeLinks(node.parent); // Check if the containing block ever report this error if (!links_1.hasReportedStatementInAmbientContext) { @@ -24036,13 +24474,8 @@ var ts; } function checkGrammarNumericLiteral(node) { // Grammar checking - if (node.flags & 16384 /* OctalLiteral */) { - if (node.parserContextFlags & 1 /* StrictMode */) { - return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode); - } - else if (languageVersion >= 1 /* ES5 */) { - return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); - } + if (node.flags & 16384 /* OctalLiteral */ && languageVersion >= 1 /* ES5 */) { + return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher); } } function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) { @@ -24053,8 +24486,6 @@ var ts; return true; } } - initializeTypeChecker(); - return checker; } ts.createTypeChecker = createTypeChecker; })(ts || (ts = {})); @@ -24113,7 +24544,7 @@ var ts; var oldWriter = writer; ts.forEach(moduleElementDeclarationEmitInfo, function (aliasEmitInfo) { if (aliasEmitInfo.isVisible) { - ts.Debug.assert(aliasEmitInfo.node.kind === 210 /* ImportDeclaration */); + ts.Debug.assert(aliasEmitInfo.node.kind === 212 /* ImportDeclaration */); createAndSetNewTextWriterWithSymbolWriter(); ts.Debug.assert(aliasEmitInfo.indent === 0); writeImportDeclaration(aliasEmitInfo.node); @@ -24189,10 +24620,10 @@ var ts; var oldWriter = writer; ts.forEach(nodes, function (declaration) { var nodeToCheck; - if (declaration.kind === 199 /* VariableDeclaration */) { + if (declaration.kind === 201 /* VariableDeclaration */) { nodeToCheck = declaration.parent.parent; } - else if (declaration.kind === 213 /* NamedImports */ || declaration.kind === 214 /* ImportSpecifier */ || declaration.kind === 211 /* ImportClause */) { + else if (declaration.kind === 215 /* NamedImports */ || declaration.kind === 216 /* ImportSpecifier */ || declaration.kind === 213 /* ImportClause */) { ts.Debug.fail("We should be getting ImportDeclaration instead to write"); } else { @@ -24210,7 +24641,7 @@ var ts; // Writing of function bar would mark alias declaration foo as visible but we haven't yet visited that declaration so do nothing, // we would write alias foo declaration when we visit it since it would now be marked as visible if (moduleElementEmitInfo) { - if (moduleElementEmitInfo.node.kind === 210 /* ImportDeclaration */) { + if (moduleElementEmitInfo.node.kind === 212 /* ImportDeclaration */) { // we have to create asynchronous output only after we have collected complete information // because it is possible to enable multiple bindings as asynchronously visible moduleElementEmitInfo.isVisible = true; @@ -24220,12 +24651,12 @@ var ts; for (var declarationIndent = moduleElementEmitInfo.indent; declarationIndent; declarationIndent--) { increaseIndent(); } - if (nodeToCheck.kind === 206 /* ModuleDeclaration */) { + if (nodeToCheck.kind === 208 /* ModuleDeclaration */) { ts.Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined); asynchronousSubModuleDeclarationEmitInfo = []; } writeModuleElement(nodeToCheck); - if (nodeToCheck.kind === 206 /* ModuleDeclaration */) { + if (nodeToCheck.kind === 208 /* ModuleDeclaration */) { moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo; asynchronousSubModuleDeclarationEmitInfo = undefined; } @@ -24318,41 +24749,41 @@ var ts; function emitType(type) { switch (type.kind) { case 112 /* AnyKeyword */: - case 122 /* StringKeyword */: - case 120 /* NumberKeyword */: + case 123 /* StringKeyword */: + case 121 /* NumberKeyword */: case 113 /* BooleanKeyword */: - case 123 /* SymbolKeyword */: + case 124 /* SymbolKeyword */: case 99 /* VoidKeyword */: case 8 /* StringLiteral */: return writeTextOfNode(currentSourceFile, type); - case 177 /* ExpressionWithTypeArguments */: + case 179 /* ExpressionWithTypeArguments */: return emitExpressionWithTypeArguments(type); - case 142 /* TypeReference */: + case 144 /* TypeReference */: return emitTypeReference(type); - case 145 /* TypeQuery */: + case 147 /* TypeQuery */: return emitTypeQuery(type); - case 147 /* ArrayType */: + case 149 /* ArrayType */: return emitArrayType(type); - case 148 /* TupleType */: + case 150 /* TupleType */: return emitTupleType(type); - case 149 /* UnionType */: + case 151 /* UnionType */: return emitUnionType(type); - case 150 /* ParenthesizedType */: + case 152 /* ParenthesizedType */: return emitParenType(type); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return emitSignatureDeclarationWithJsDocComments(type); - case 146 /* TypeLiteral */: + case 148 /* TypeLiteral */: return emitTypeLiteral(type); case 65 /* Identifier */: return emitEntityName(type); - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: return emitEntityName(type); } function emitEntityName(entityName) { var visibilityResult = resolver.isEntityNameVisible(entityName, // Aliases can be written asynchronously so use correct enclosing declaration - entityName.parent.kind === 209 /* ImportEqualsDeclaration */ ? entityName.parent : enclosingDeclaration); + entityName.parent.kind === 211 /* ImportEqualsDeclaration */ ? entityName.parent : enclosingDeclaration); handleSymbolAccessibilityError(visibilityResult); writeEntityName(entityName); function writeEntityName(entityName) { @@ -24360,8 +24791,8 @@ var ts; writeTextOfNode(currentSourceFile, entityName); } else { - var left = entityName.kind === 127 /* QualifiedName */ ? entityName.left : entityName.expression; - var right = entityName.kind === 127 /* QualifiedName */ ? entityName.right : entityName.name; + var left = entityName.kind === 128 /* QualifiedName */ ? entityName.left : entityName.expression; + var right = entityName.kind === 128 /* QualifiedName */ ? entityName.right : entityName.name; writeEntityName(left); write("."); writeTextOfNode(currentSourceFile, right); @@ -24370,7 +24801,7 @@ var ts; } function emitExpressionWithTypeArguments(node) { if (ts.isSupportedExpressionWithTypeArguments(node)) { - ts.Debug.assert(node.expression.kind === 65 /* Identifier */ || node.expression.kind === 156 /* PropertyAccessExpression */); + ts.Debug.assert(node.expression.kind === 65 /* Identifier */ || node.expression.kind === 158 /* PropertyAccessExpression */); emitEntityName(node.expression); if (node.typeArguments) { write("<"); @@ -24436,9 +24867,9 @@ var ts; } var count = 0; while (true) { - var name_18 = baseName + "_" + (++count); - if (!ts.hasProperty(currentSourceFile.identifiers, name_18)) { - return name_18; + var name_16 = baseName + "_" + (++count); + if (!ts.hasProperty(currentSourceFile.identifiers, name_16)) { + return name_16; } } } @@ -24482,10 +24913,10 @@ var ts; if (isModuleElementVisible) { writeModuleElement(node); } - else if (node.kind === 209 /* ImportEqualsDeclaration */ || - (node.parent.kind === 228 /* SourceFile */ && ts.isExternalModule(currentSourceFile))) { + else if (node.kind === 211 /* ImportEqualsDeclaration */ || + (node.parent.kind === 230 /* SourceFile */ && ts.isExternalModule(currentSourceFile))) { var isVisible; - if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 228 /* SourceFile */) { + if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== 230 /* SourceFile */) { // Import declaration of another module that is visited async so lets put it in right spot asynchronousSubModuleDeclarationEmitInfo.push({ node: node, @@ -24495,7 +24926,7 @@ var ts; }); } else { - if (node.kind === 210 /* ImportDeclaration */) { + if (node.kind === 212 /* ImportDeclaration */) { var importDeclaration = node; if (importDeclaration.importClause) { isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) || @@ -24513,23 +24944,23 @@ var ts; } function writeModuleElement(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return writeFunctionDeclaration(node); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return writeVariableStatement(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return writeInterfaceDeclaration(node); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return writeClassDeclaration(node); - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: return writeTypeAliasDeclaration(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return writeEnumDeclaration(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return writeModuleDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return writeImportEqualsDeclaration(node); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: return writeImportDeclaration(node); default: ts.Debug.fail("Unknown symbol kind"); @@ -24545,7 +24976,7 @@ var ts; if (node.flags & 256 /* Default */) { write("default "); } - else if (node.kind !== 203 /* InterfaceDeclaration */) { + else if (node.kind !== 205 /* InterfaceDeclaration */) { write("declare "); } } @@ -24591,7 +25022,7 @@ var ts; } function isVisibleNamedBinding(namedBindings) { if (namedBindings) { - if (namedBindings.kind === 212 /* NamespaceImport */) { + if (namedBindings.kind === 214 /* NamespaceImport */) { return resolver.isDeclarationVisible(namedBindings); } else { @@ -24619,7 +25050,7 @@ var ts; // If the default binding was emitted, write the separated write(", "); } - if (node.importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (node.importClause.namedBindings.kind === 214 /* NamespaceImport */) { write("* as "); writeTextOfNode(currentSourceFile, node.importClause.namedBindings.name); } @@ -24670,9 +25101,14 @@ var ts; function writeModuleDeclaration(node) { emitJsDocComments(node); emitModuleElementDeclarationFlags(node); - write("module "); + if (node.flags & 32768 /* Namespace */) { + write("namespace "); + } + else { + write("module "); + } writeTextOfNode(currentSourceFile, node.name); - while (node.body.kind !== 207 /* ModuleBlock */) { + while (node.body.kind !== 209 /* ModuleBlock */) { node = node.body; write("."); writeTextOfNode(currentSourceFile, node.name); @@ -24733,7 +25169,7 @@ var ts; writeLine(); } function isPrivateMethodTypeParameter(node) { - return node.parent.kind === 135 /* MethodDeclaration */ && (node.parent.flags & 32 /* Private */); + return node.parent.kind === 136 /* MethodDeclaration */ && (node.parent.flags & 32 /* Private */); } function emitTypeParameters(typeParameters) { function emitTypeParameter(node) { @@ -24744,15 +25180,15 @@ var ts; // If there is constraint present and this is not a type parameter of the private method emit the constraint if (node.constraint && !isPrivateMethodTypeParameter(node)) { write(" extends "); - if (node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - (node.parent.parent && node.parent.parent.kind === 146 /* TypeLiteral */)) { - ts.Debug.assert(node.parent.kind === 135 /* MethodDeclaration */ || - node.parent.kind === 134 /* MethodSignature */ || - node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - node.parent.kind === 139 /* CallSignature */ || - node.parent.kind === 140 /* ConstructSignature */); + if (node.parent.kind === 145 /* FunctionType */ || + node.parent.kind === 146 /* ConstructorType */ || + (node.parent.parent && node.parent.parent.kind === 148 /* TypeLiteral */)) { + ts.Debug.assert(node.parent.kind === 136 /* MethodDeclaration */ || + node.parent.kind === 135 /* MethodSignature */ || + node.parent.kind === 145 /* FunctionType */ || + node.parent.kind === 146 /* ConstructorType */ || + node.parent.kind === 140 /* CallSignature */ || + node.parent.kind === 141 /* ConstructSignature */); emitType(node.constraint); } else { @@ -24763,31 +25199,31 @@ var ts; // Type parameter constraints are named by user so we should always be able to name it var diagnosticMessage; switch (node.parent.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; break; - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; break; - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 139 /* CallSignature */: + case 140 /* CallSignature */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (node.parent.flags & 128 /* Static */) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.parent.kind === 204 /* ClassDeclaration */) { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } break; - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -24818,7 +25254,7 @@ var ts; function getHeritageClauseVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; // Heritage clause is written by user so it can always be named - if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + if (node.parent.parent.kind === 204 /* ClassDeclaration */) { // Class or Interface implemented/extended is inaccessible diagnosticMessage = isImplementsList ? ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : @@ -24899,7 +25335,7 @@ var ts; function emitVariableDeclaration(node) { // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted // so there is no check needed to see if declaration is visible - if (node.kind !== 199 /* VariableDeclaration */ || resolver.isDeclarationVisible(node)) { + if (node.kind !== 201 /* VariableDeclaration */ || resolver.isDeclarationVisible(node)) { if (ts.isBindingPattern(node.name)) { emitBindingPattern(node.name); } @@ -24909,10 +25345,10 @@ var ts; // what we want, namely the name expression enclosed in brackets. writeTextOfNode(currentSourceFile, node.name); // If optional property emit ? - if ((node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) && ts.hasQuestionToken(node)) { + if ((node.kind === 134 /* PropertyDeclaration */ || node.kind === 133 /* PropertySignature */) && ts.hasQuestionToken(node)) { write("?"); } - if ((node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) && node.parent.kind === 146 /* TypeLiteral */) { + if ((node.kind === 134 /* PropertyDeclaration */ || node.kind === 133 /* PropertySignature */) && node.parent.kind === 148 /* TypeLiteral */) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.flags & 32 /* Private */)) { @@ -24921,14 +25357,14 @@ var ts; } } function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { - if (node.kind === 199 /* VariableDeclaration */) { + if (node.kind === 201 /* VariableDeclaration */) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1; } - else if (node.kind === 133 /* PropertyDeclaration */ || node.kind === 132 /* PropertySignature */) { + else if (node.kind === 134 /* PropertyDeclaration */ || node.kind === 133 /* PropertySignature */) { // TODO(jfreeman): Deal with computed properties in error reporting. if (node.flags & 128 /* Static */) { return symbolAccesibilityResult.errorModuleName ? @@ -24937,7 +25373,7 @@ var ts; ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 204 /* ClassDeclaration */) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -24969,7 +25405,7 @@ var ts; var elements = []; for (var _i = 0, _a = bindingPattern.elements; _i < _a.length; _i++) { var element = _a[_i]; - if (element.kind !== 176 /* OmittedExpression */) { + if (element.kind !== 178 /* OmittedExpression */) { elements.push(element); } } @@ -25039,7 +25475,7 @@ var ts; var type = getTypeAnnotationFromAccessor(node); if (!type) { // couldn't get type for the first accessor, try the another one - var anotherAccessor = node.kind === 137 /* GetAccessor */ ? accessors.setAccessor : accessors.getAccessor; + var anotherAccessor = node.kind === 138 /* GetAccessor */ ? accessors.setAccessor : accessors.getAccessor; type = getTypeAnnotationFromAccessor(anotherAccessor); if (type) { accessorWithTypeAnnotation = anotherAccessor; @@ -25052,7 +25488,7 @@ var ts; } function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 137 /* GetAccessor */ + return accessor.kind === 138 /* GetAccessor */ ? accessor.type // Getter - return type : accessor.parameters.length > 0 ? accessor.parameters[0].type // Setter parameter type @@ -25061,7 +25497,7 @@ var ts; } function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (accessorWithTypeAnnotation.kind === 138 /* SetAccessor */) { + if (accessorWithTypeAnnotation.kind === 139 /* SetAccessor */) { // Setters have to have type named and cannot infer it so, the type should always be named if (accessorWithTypeAnnotation.parent.flags & 128 /* Static */) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? @@ -25111,17 +25547,17 @@ var ts; // so no need to verify if the declaration is visible if (!resolver.isImplementationOfOverload(node)) { emitJsDocComments(node); - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 203 /* FunctionDeclaration */) { emitModuleElementDeclarationFlags(node); } - else if (node.kind === 135 /* MethodDeclaration */) { + else if (node.kind === 136 /* MethodDeclaration */) { emitClassMemberDeclarationFlags(node); } - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 203 /* FunctionDeclaration */) { write("function "); writeTextOfNode(currentSourceFile, node.name); } - else if (node.kind === 136 /* Constructor */) { + else if (node.kind === 137 /* Constructor */) { write("constructor"); } else { @@ -25139,11 +25575,11 @@ var ts; } function emitSignatureDeclaration(node) { // Construct signature or constructor type write new Signature - if (node.kind === 140 /* ConstructSignature */ || node.kind === 144 /* ConstructorType */) { + if (node.kind === 141 /* ConstructSignature */ || node.kind === 146 /* ConstructorType */) { write("new "); } emitTypeParameters(node.typeParameters); - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 142 /* IndexSignature */) { write("["); } else { @@ -25153,22 +25589,22 @@ var ts; enclosingDeclaration = node; // Parameters emitCommaList(node.parameters, emitParameterDeclaration); - if (node.kind === 141 /* IndexSignature */) { + if (node.kind === 142 /* IndexSignature */) { write("]"); } else { write(")"); } // If this is not a constructor and is not private, emit the return type - var isFunctionTypeOrConstructorType = node.kind === 143 /* FunctionType */ || node.kind === 144 /* ConstructorType */; - if (isFunctionTypeOrConstructorType || node.parent.kind === 146 /* TypeLiteral */) { + var isFunctionTypeOrConstructorType = node.kind === 145 /* FunctionType */ || node.kind === 146 /* ConstructorType */; + if (isFunctionTypeOrConstructorType || node.parent.kind === 148 /* TypeLiteral */) { // Emit type literal signature return type only if specified if (node.type) { write(isFunctionTypeOrConstructorType ? " => " : ": "); emitType(node.type); } } - else if (node.kind !== 136 /* Constructor */ && !(node.flags & 32 /* Private */)) { + else if (node.kind !== 137 /* Constructor */ && !(node.flags & 32 /* Private */)) { writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); } enclosingDeclaration = prevEnclosingDeclaration; @@ -25179,26 +25615,26 @@ var ts; function getReturnTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.kind) { - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: // Interfaces cannot have return types that cannot be named diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 139 /* CallSignature */: + case 140 /* CallSignature */: // Interfaces cannot have return types that cannot be named diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: // Interfaces cannot have return types that cannot be named diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0; break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (node.flags & 128 /* Static */) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? @@ -25206,7 +25642,7 @@ var ts; ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0; } - else if (node.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.kind === 204 /* ClassDeclaration */) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : @@ -25220,7 +25656,7 @@ var ts; ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; } break; - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : @@ -25255,9 +25691,9 @@ var ts; write("?"); } decreaseIndent(); - if (node.parent.kind === 143 /* FunctionType */ || - node.parent.kind === 144 /* ConstructorType */ || - node.parent.parent.kind === 146 /* TypeLiteral */) { + if (node.parent.kind === 145 /* FunctionType */ || + node.parent.kind === 146 /* ConstructorType */ || + node.parent.parent.kind === 148 /* TypeLiteral */) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.parent.flags & 32 /* Private */)) { @@ -25273,24 +25709,24 @@ var ts; } function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult) { switch (node.parent.kind) { - case 136 /* Constructor */: + case 137 /* Constructor */: return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1; - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: // Interfaces cannot have parameter types that cannot be named return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; - case 139 /* CallSignature */: + case 140 /* CallSignature */: // Interfaces cannot have parameter types that cannot be named return symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (node.parent.flags & 128 /* Static */) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? @@ -25298,7 +25734,7 @@ var ts; ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; } - else if (node.parent.parent.kind === 202 /* ClassDeclaration */) { + else if (node.parent.parent.kind === 204 /* ClassDeclaration */) { return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -25311,7 +25747,7 @@ var ts; ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; } - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ? ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : @@ -25323,12 +25759,12 @@ var ts; } function emitBindingPattern(bindingPattern) { // We have to explicitly emit square bracket and bracket because these tokens are not store inside the node. - if (bindingPattern.kind === 151 /* ObjectBindingPattern */) { + if (bindingPattern.kind === 153 /* ObjectBindingPattern */) { write("{"); emitCommaList(bindingPattern.elements, emitBindingElement); write("}"); } - else if (bindingPattern.kind === 152 /* ArrayBindingPattern */) { + else if (bindingPattern.kind === 154 /* ArrayBindingPattern */) { write("["); var elements = bindingPattern.elements; emitCommaList(elements, emitBindingElement); @@ -25347,7 +25783,7 @@ var ts; typeName: bindingElement.name } : undefined; } - if (bindingElement.kind === 176 /* OmittedExpression */) { + if (bindingElement.kind === 178 /* OmittedExpression */) { // If bindingElement is an omittedExpression (i.e. containing elision), // we will emit blank space (although this may differ from users' original code, // it allows emitSeparatedList to write separator appropriately) @@ -25356,7 +25792,7 @@ var ts; // emit : function foo([ , x, , ]) {} write(" "); } - else if (bindingElement.kind === 153 /* BindingElement */) { + else if (bindingElement.kind === 155 /* BindingElement */) { if (bindingElement.propertyName) { // bindingElement has propertyName property in the following case: // { y: [a,b,c] ...} -> bindingPattern will have a property called propertyName for "y" @@ -25397,40 +25833,40 @@ var ts; } function emitNode(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 203 /* InterfaceDeclaration */: - case 202 /* ClassDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: + case 203 /* FunctionDeclaration */: + case 208 /* ModuleDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 205 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 207 /* EnumDeclaration */: return emitModuleElement(node, isModuleElementVisible(node)); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return emitModuleElement(node, isVariableStatementVisible(node)); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: // Import declaration without import clause is visible, otherwise it is not visible return emitModuleElement(node, !node.importClause); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return emitExportDeclaration(node); - case 136 /* Constructor */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 137 /* Constructor */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return writeFunctionDeclaration(node); - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 141 /* IndexSignature */: + case 141 /* ConstructSignature */: + case 140 /* CallSignature */: + case 142 /* IndexSignature */: return emitSignatureDeclarationWithJsDocComments(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return emitAccessorDeclaration(node); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return emitPropertyDeclaration(node); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return emitEnumMemberDeclaration(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return emitExportAssignment(node); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return emitSourceFile(node); } } @@ -25491,7 +25927,7 @@ var ts; // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature function emitFiles(resolver, host, targetSourceFile) { // emit output for the __extends helper function - var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n __.prototype = b.prototype;\n d.prototype = new __();\n};"; + var extendsHelper = "\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};"; // emit output for the __decorate helper function var decorateHelper = "\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") return Reflect.decorate(decorators, target, key, desc);\n switch (arguments.length) {\n case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);\n case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);\n case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);\n }\n};"; // emit output for the __metadata helper function @@ -25567,7 +26003,6 @@ var ts; var exportFunctionForFile; var generatedNameSet = {}; var nodeToGeneratedName = []; - var blockScopedVariableToGeneratedName; var computedPropertyNamesToGeneratedNames; var extendsEmitted = false; var decorateEmitted = false; @@ -25647,9 +26082,9 @@ var ts; tempFlags++; // Skip over 'i' and 'n' if (count !== 8 && count !== 13) { - var name_19 = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26); - if (isUniqueName(name_19)) { - return name_19; + var name_17 = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26); + if (isUniqueName(name_17)) { + return name_17; } } } @@ -25672,73 +26107,40 @@ var ts; i++; } } - function assignGeneratedName(node, name) { - nodeToGeneratedName[ts.getNodeId(node)] = ts.unescapeIdentifier(name); - } - function generateNameForFunctionOrClassDeclaration(node) { - if (!node.name) { - assignGeneratedName(node, makeUniqueName("default")); - } - } function generateNameForModuleOrEnum(node) { - if (node.name.kind === 65 /* Identifier */) { - var name_20 = node.name.text; - // Use module/enum name itself if it is unique, otherwise make a unique variation - assignGeneratedName(node, isUniqueLocalName(name_20, node) ? name_20 : makeUniqueName(name_20)); - } + var name = node.name.text; + // Use module/enum name itself if it is unique, otherwise make a unique variation + return isUniqueLocalName(name, node) ? name : makeUniqueName(name); } function generateNameForImportOrExportDeclaration(node) { var expr = ts.getExternalModuleName(node); var baseName = expr.kind === 8 /* StringLiteral */ ? ts.escapeIdentifier(ts.makeIdentifierFromModuleName(expr.text)) : "module"; - assignGeneratedName(node, makeUniqueName(baseName)); + return makeUniqueName(baseName); } - function generateNameForImportDeclaration(node) { - if (node.importClause) { - generateNameForImportOrExportDeclaration(node); - } - } - function generateNameForExportDeclaration(node) { - if (node.moduleSpecifier) { - generateNameForImportOrExportDeclaration(node); - } - } - function generateNameForExportAssignment(node) { - if (node.expression && node.expression.kind !== 65 /* Identifier */) { - assignGeneratedName(node, makeUniqueName("default")); - } + function generateNameForExportDefault() { + return makeUniqueName("default"); } function generateNameForNode(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 202 /* ClassDeclaration */: - case 175 /* ClassExpression */: - generateNameForFunctionOrClassDeclaration(node); - break; - case 206 /* ModuleDeclaration */: - generateNameForModuleOrEnum(node); - generateNameForNode(node.body); - break; - case 205 /* EnumDeclaration */: - generateNameForModuleOrEnum(node); - break; - case 210 /* ImportDeclaration */: - generateNameForImportDeclaration(node); - break; - case 216 /* ExportDeclaration */: - generateNameForExportDeclaration(node); - break; - case 215 /* ExportAssignment */: - generateNameForExportAssignment(node); - break; + case 65 /* Identifier */: + return makeUniqueName(node.text); + case 208 /* ModuleDeclaration */: + case 207 /* EnumDeclaration */: + return generateNameForModuleOrEnum(node); + case 212 /* ImportDeclaration */: + case 218 /* ExportDeclaration */: + return generateNameForImportOrExportDeclaration(node); + case 203 /* FunctionDeclaration */: + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + case 217 /* ExportAssignment */: + return generateNameForExportDefault(); } } function getGeneratedNameForNode(node) { - var nodeId = ts.getNodeId(node); - if (!nodeToGeneratedName[nodeId]) { - generateNameForNode(node); - } - return nodeToGeneratedName[nodeId]; + var id = ts.getNodeId(node); + return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = ts.unescapeIdentifier(generateNameForNode(node))); } function initializeEmitterWithSourceMaps() { var sourceMapDir; // The directory in which sourcemap will be @@ -25767,7 +26169,7 @@ var ts; } var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; // Line/Comma delimiters - if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) { + if (lastEncodedSourceMapSpan.emittedLine === lastRecordedSourceMapSpan.emittedLine) { // Emit comma to separate the entry if (sourceMapData.sourceMapMappings) { sourceMapData.sourceMapMappings += ","; @@ -25836,8 +26238,8 @@ var ts; var emittedColumn = writer.getColumn(); // If this location wasn't recorded or the location in source is going backwards, record the span if (!lastRecordedSourceMapSpan || - lastRecordedSourceMapSpan.emittedLine != emittedLine || - lastRecordedSourceMapSpan.emittedColumn != emittedColumn || + lastRecordedSourceMapSpan.emittedLine !== emittedLine || + lastRecordedSourceMapSpan.emittedColumn !== emittedColumn || (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex && (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line || (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) { @@ -25903,8 +26305,8 @@ var ts; // Child scopes are always shown with a dot (even if they have no name), // unless it is a computed property. Then it is shown with brackets, // but the brackets are included in the name. - var name_21 = node.name; - if (!name_21 || name_21.kind !== 128 /* ComputedPropertyName */) { + var name_18 = node.name; + if (!name_18 || name_18.kind !== 129 /* ComputedPropertyName */) { scopeName = "." + scopeName; } scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; @@ -25922,21 +26324,21 @@ var ts; // The scope was already given a name use it recordScopeNameStart(scopeName); } - else if (node.kind === 201 /* FunctionDeclaration */ || - node.kind === 163 /* FunctionExpression */ || - node.kind === 135 /* MethodDeclaration */ || - node.kind === 134 /* MethodSignature */ || - node.kind === 137 /* GetAccessor */ || - node.kind === 138 /* SetAccessor */ || - node.kind === 206 /* ModuleDeclaration */ || - node.kind === 202 /* ClassDeclaration */ || - node.kind === 205 /* EnumDeclaration */) { + else if (node.kind === 203 /* FunctionDeclaration */ || + node.kind === 165 /* FunctionExpression */ || + node.kind === 136 /* MethodDeclaration */ || + node.kind === 135 /* MethodSignature */ || + node.kind === 138 /* GetAccessor */ || + node.kind === 139 /* SetAccessor */ || + node.kind === 208 /* ModuleDeclaration */ || + node.kind === 204 /* ClassDeclaration */ || + node.kind === 207 /* EnumDeclaration */) { // Declaration and has associated name use it if (node.name) { - var name_22 = node.name; + var name_19 = node.name; // For computed property names, the text will include the brackets - scopeName = name_22.kind === 128 /* ComputedPropertyName */ - ? ts.getTextOfNode(name_22) + scopeName = name_19.kind === 129 /* ComputedPropertyName */ + ? ts.getTextOfNode(name_19) : node.name.text; } recordScopeNameStart(scopeName); @@ -26040,19 +26442,19 @@ var ts; else { sourceMapDir = ts.getDirectoryPath(ts.normalizePath(jsFilePath)); } - function emitNodeWithSourceMap(node, allowGeneratedIdentifiers) { + function emitNodeWithSourceMap(node) { if (node) { if (ts.nodeIsSynthesized(node)) { - return emitNodeWithoutSourceMap(node, false); + return emitNodeWithoutSourceMap(node); } - if (node.kind != 228 /* SourceFile */) { + if (node.kind !== 230 /* SourceFile */) { recordEmitNodeStartSpan(node); - emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers); + emitNodeWithoutSourceMap(node); recordEmitNodeEndSpan(node); } else { recordNewSourceFileStart(node); - emitNodeWithoutSourceMap(node, false); + emitNodeWithoutSourceMap(node); } } } @@ -26308,10 +26710,10 @@ var ts; write("("); emit(tempVariable); // Now we emit the expressions - if (node.template.kind === 172 /* TemplateExpression */) { + if (node.template.kind === 174 /* TemplateExpression */) { ts.forEach(node.template.templateSpans, function (templateSpan) { write(", "); - var needsParens = templateSpan.expression.kind === 170 /* BinaryExpression */ + var needsParens = templateSpan.expression.kind === 172 /* BinaryExpression */ && templateSpan.expression.operatorToken.kind === 23 /* CommaToken */; emitParenthesizedIf(templateSpan.expression, needsParens); }); @@ -26346,7 +26748,7 @@ var ts; // ("abc" + 1) << (2 + "") // rather than // "abc" + (1 << 2) + "" - var needsParens = templateSpan.expression.kind !== 162 /* ParenthesizedExpression */ + var needsParens = templateSpan.expression.kind !== 164 /* ParenthesizedExpression */ && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1 /* GreaterThan */; if (i > 0 || headEmitted) { // If this is the first span and the head was not emitted, then this templateSpan's @@ -26388,11 +26790,11 @@ var ts; } function templateNeedsParens(template, parent) { switch (parent.kind) { - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return parent.expression === template; - case 160 /* TaggedTemplateExpression */: - case 162 /* ParenthesizedExpression */: + case 162 /* TaggedTemplateExpression */: + case 164 /* ParenthesizedExpression */: return false; default: return comparePrecedenceToBinaryPlus(parent) !== -1 /* LessThan */; @@ -26413,7 +26815,7 @@ var ts; // TODO (drosen): Note that we need to account for the upcoming 'yield' and // spread ('...') unary operators that are anticipated for ES6. switch (expression.kind) { - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: switch (expression.operatorToken.kind) { case 35 /* AsteriskToken */: case 36 /* SlashToken */: @@ -26425,8 +26827,8 @@ var ts; default: return -1 /* LessThan */; } - case 173 /* YieldExpression */: - case 171 /* ConditionalExpression */: + case 175 /* YieldExpression */: + case 173 /* ConditionalExpression */: return -1 /* LessThan */; default: return 1 /* GreaterThan */; @@ -26441,11 +26843,11 @@ var ts; // In a sense, it does not actually emit identifiers as much as it declares a name for a specific property. // For example, this is utilized when feeding in a result to Object.defineProperty. function emitExpressionForPropertyName(node) { - ts.Debug.assert(node.kind !== 153 /* BindingElement */); + ts.Debug.assert(node.kind !== 155 /* BindingElement */); if (node.kind === 8 /* StringLiteral */) { emitLiteral(node); } - else if (node.kind === 128 /* ComputedPropertyName */) { + else if (node.kind === 129 /* ComputedPropertyName */) { // if this is a decorated computed property, we will need to capture the result // of the property expression so that we can apply decorators later. This is to ensure // we don't introduce unintended side effects: @@ -26486,75 +26888,126 @@ var ts; write("\""); } } - function isNotExpressionIdentifier(node) { + function isExpressionIdentifier(node) { var parent = node.parent; switch (parent.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 201 /* FunctionDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - return parent.name === node; - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: - return parent.name === node || parent.propertyName === node; - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: - case 215 /* ExportAssignment */: - return false; - case 195 /* LabeledStatement */: - return node.parent.label === node; + case 156 /* ArrayLiteralExpression */: + case 172 /* BinaryExpression */: + case 160 /* CallExpression */: + case 223 /* CaseClause */: + case 129 /* ComputedPropertyName */: + case 173 /* ConditionalExpression */: + case 132 /* Decorator */: + case 167 /* DeleteExpression */: + case 187 /* DoStatement */: + case 159 /* ElementAccessExpression */: + case 217 /* ExportAssignment */: + case 185 /* ExpressionStatement */: + case 179 /* ExpressionWithTypeArguments */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 186 /* IfStatement */: + case 161 /* NewExpression */: + case 164 /* ParenthesizedExpression */: + case 171 /* PostfixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: + case 194 /* ReturnStatement */: + case 228 /* ShorthandPropertyAssignment */: + case 176 /* SpreadElementExpression */: + case 196 /* SwitchStatement */: + case 162 /* TaggedTemplateExpression */: + case 180 /* TemplateSpan */: + case 198 /* ThrowStatement */: + case 163 /* TypeAssertionExpression */: + case 168 /* TypeOfExpression */: + case 169 /* VoidExpression */: + case 188 /* WhileStatement */: + case 195 /* WithStatement */: + case 175 /* YieldExpression */: + return true; + case 155 /* BindingElement */: + case 229 /* EnumMember */: + case 131 /* Parameter */: + case 227 /* PropertyAssignment */: + case 134 /* PropertyDeclaration */: + case 201 /* VariableDeclaration */: + return parent.initializer === node; + case 158 /* PropertyAccessExpression */: + return parent.expression === node; + case 166 /* ArrowFunction */: + case 165 /* FunctionExpression */: + return parent.body === node; + case 211 /* ImportEqualsDeclaration */: + return parent.moduleReference === node; + case 128 /* QualifiedName */: + return parent.left === node; } + return false; } function emitExpressionIdentifier(node) { - var substitution = resolver.getExpressionNameSubstitution(node, getGeneratedNameForNode); - if (substitution) { - write(substitution); + var container = resolver.getReferencedExportContainer(node); + if (container) { + if (container.kind === 230 /* SourceFile */) { + // Identifier references module export + if (languageVersion < 2 /* ES6 */ && compilerOptions.module !== 4 /* System */) { + write("exports."); + } + } + else { + // Identifier references namespace export + write(getGeneratedNameForNode(container)); + write("."); + } } - else { - writeTextOfNode(currentSourceFile, node); - } - } - function getGeneratedNameForIdentifier(node) { - if (ts.nodeIsSynthesized(node) || !blockScopedVariableToGeneratedName) { - return undefined; - } - var variableId = resolver.getBlockScopedVariableId(node); - if (variableId === undefined) { - return undefined; - } - return blockScopedVariableToGeneratedName[variableId]; - } - function emitIdentifier(node, allowGeneratedIdentifiers) { - if (allowGeneratedIdentifiers) { - var generatedName = getGeneratedNameForIdentifier(node); - if (generatedName) { - write(generatedName); + else if (languageVersion < 2 /* ES6 */) { + var declaration = resolver.getReferencedImportDeclaration(node); + if (declaration) { + if (declaration.kind === 213 /* ImportClause */) { + // Identifier references default import + write(getGeneratedNameForNode(declaration.parent)); + write(languageVersion === 0 /* ES3 */ ? '["default"]' : ".default"); + return; + } + else if (declaration.kind === 216 /* ImportSpecifier */) { + // Identifier references named import + write(getGeneratedNameForNode(declaration.parent.parent.parent)); + write("."); + writeTextOfNode(currentSourceFile, declaration.propertyName || declaration.name); + return; + } + } + declaration = resolver.getReferencedNestedRedeclaration(node); + if (declaration) { + write(getGeneratedNameForNode(declaration.name)); return; } } + writeTextOfNode(currentSourceFile, node); + } + function isNameOfNestedRedeclaration(node) { + if (languageVersion < 2 /* ES6 */) { + var parent_7 = node.parent; + switch (parent_7.kind) { + case 155 /* BindingElement */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 201 /* VariableDeclaration */: + return parent_7.name === node && resolver.isNestedRedeclaration(parent_7); + } + } + return false; + } + function emitIdentifier(node) { if (!node.parent) { write(node.text); } - else if (!isNotExpressionIdentifier(node)) { + else if (isExpressionIdentifier(node)) { emitExpressionIdentifier(node); } + else if (isNameOfNestedRedeclaration(node)) { + write(getGeneratedNameForNode(node)); + } else { writeTextOfNode(currentSourceFile, node); } @@ -26595,7 +27048,7 @@ var ts; } function emitBindingElement(node) { if (node.propertyName) { - emit(node.propertyName, false); + emit(node.propertyName); write(": "); } if (node.dotDotDotToken) { @@ -26626,11 +27079,11 @@ var ts; function needsParenthesisForPropertyAccessOrInvocation(node) { switch (node.kind) { case 65 /* Identifier */: - case 154 /* ArrayLiteralExpression */: - case 156 /* PropertyAccessExpression */: - case 157 /* ElementAccessExpression */: - case 158 /* CallExpression */: - case 162 /* ParenthesizedExpression */: + case 156 /* ArrayLiteralExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + case 160 /* CallExpression */: + case 164 /* ParenthesizedExpression */: // This list is not exhaustive and only includes those cases that are relevant // to the check in emitArrayLiteral. More cases can be added as needed. return false; @@ -26650,17 +27103,17 @@ var ts; write(", "); } var e = elements[pos]; - if (e.kind === 174 /* SpreadElementExpression */) { + if (e.kind === 176 /* SpreadElementExpression */) { e = e.expression; emitParenthesizedIf(e, group === 0 && needsParenthesisForPropertyAccessOrInvocation(e)); pos++; - if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 154 /* ArrayLiteralExpression */) { + if (pos === length && group === 0 && needsUniqueCopy && e.kind !== 156 /* ArrayLiteralExpression */) { write(".slice()"); } } else { var i = pos; - while (i < length && elements[i].kind !== 174 /* SpreadElementExpression */) { + while (i < length && elements[i].kind !== 176 /* SpreadElementExpression */) { i++; } write("["); @@ -26683,7 +27136,7 @@ var ts; } } function isSpreadElementExpression(node) { - return node.kind === 174 /* SpreadElementExpression */; + return node.kind === 176 /* SpreadElementExpression */; } function emitArrayLiteral(node) { var elements = node.elements; @@ -26753,7 +27206,7 @@ var ts; writeComma(); var property = properties[i]; emitStart(property); - if (property.kind === 137 /* GetAccessor */ || property.kind === 138 /* SetAccessor */) { + if (property.kind === 138 /* GetAccessor */ || property.kind === 139 /* SetAccessor */) { // TODO (drosen): Reconcile with 'emitMemberFunctions'. var accessors = ts.getAllAccessorDeclarations(node.properties, property); if (property !== accessors.firstAccessor) { @@ -26805,13 +27258,13 @@ var ts; emitMemberAccessForPropertyName(property.name); emitEnd(property.name); write(" = "); - if (property.kind === 225 /* PropertyAssignment */) { + if (property.kind === 227 /* PropertyAssignment */) { emit(property.initializer); } - else if (property.kind === 226 /* ShorthandPropertyAssignment */) { + else if (property.kind === 228 /* ShorthandPropertyAssignment */) { emitExpressionIdentifier(property.name); } - else if (property.kind === 135 /* MethodDeclaration */) { + else if (property.kind === 136 /* MethodDeclaration */) { emitFunctionDeclaration(property); } else { @@ -26845,7 +27298,7 @@ var ts; // Everything until that point can be emitted as part of the initial object literal. var numInitialNonComputedProperties = numProperties; for (var i = 0, n = properties.length; i < n; i++) { - if (properties[i].name.kind === 128 /* ComputedPropertyName */) { + if (properties[i].name.kind === 129 /* ComputedPropertyName */) { numInitialNonComputedProperties = i; break; } @@ -26861,21 +27314,21 @@ var ts; emitObjectLiteralBody(node, properties.length); } function createBinaryExpression(left, operator, right, startsOnNewLine) { - var result = ts.createSynthesizedNode(170 /* BinaryExpression */, startsOnNewLine); + var result = ts.createSynthesizedNode(172 /* BinaryExpression */, startsOnNewLine); result.operatorToken = ts.createSynthesizedNode(operator); result.left = left; result.right = right; return result; } function createPropertyAccessExpression(expression, name) { - var result = ts.createSynthesizedNode(156 /* PropertyAccessExpression */); + var result = ts.createSynthesizedNode(158 /* PropertyAccessExpression */); result.expression = parenthesizeForAccess(expression); result.dotToken = ts.createSynthesizedNode(20 /* DotToken */); result.name = name; return result; } function createElementAccessExpression(expression, argumentExpression) { - var result = ts.createSynthesizedNode(157 /* ElementAccessExpression */); + var result = ts.createSynthesizedNode(159 /* ElementAccessExpression */); result.expression = parenthesizeForAccess(expression); result.argumentExpression = argumentExpression; return result; @@ -26883,7 +27336,7 @@ var ts; function parenthesizeForAccess(expr) { // When diagnosing whether the expression needs parentheses, the decision should be based // on the innermost expression in a chain of nested type assertions. - while (expr.kind === 161 /* TypeAssertionExpression */) { + while (expr.kind === 163 /* TypeAssertionExpression */) { expr = expr.expression; } // isLeftHandSideExpression is almost the correct criterion for when it is not necessary @@ -26895,11 +27348,11 @@ var ts; // 1.x -> not the same as (1).x // if (ts.isLeftHandSideExpression(expr) && - expr.kind !== 159 /* NewExpression */ && + expr.kind !== 161 /* NewExpression */ && expr.kind !== 7 /* NumericLiteral */) { return expr; } - var node = ts.createSynthesizedNode(162 /* ParenthesizedExpression */); + var node = ts.createSynthesizedNode(164 /* ParenthesizedExpression */); node.expression = expr; return node; } @@ -26912,46 +27365,39 @@ var ts; if (languageVersion >= 2 /* ES6 */ && node.asteriskToken) { write("*"); } - emit(node.name, false); + emit(node.name); if (languageVersion < 2 /* ES6 */) { write(": function "); } emitSignatureAndBody(node); } function emitPropertyAssignment(node) { - emit(node.name, false); + emit(node.name); write(": "); emit(node.initializer); } + // Return true if identifier resolves to an exported member of a namespace + function isNamespaceExportReference(node) { + var container = resolver.getReferencedExportContainer(node); + return container && container.kind !== 230 /* SourceFile */; + } function emitShorthandPropertyAssignment(node) { - emit(node.name, false); - // If short-hand property has a prefix, then regardless of the target version, we will emit it as normal property assignment. For example: - // module m { - // export let y; - // } - // module m { - // export let obj = { y }; - // } - // The short-hand property in obj need to emit as such ... = { y : m.y } regardless of the TargetScript version - if (languageVersion < 2 /* ES6 */) { + // The name property of a short-hand property assignment is considered an expression position, so here + // we manually emit the identifier to avoid rewriting. + writeTextOfNode(currentSourceFile, node.name); + // If emitting pre-ES6 code, or if the name requires rewriting when resolved as an expression identifier, + // we emit a normal property assignment. For example: + // module m { + // export let y; + // } + // module m { + // let obj = { y }; + // } + // Here we need to emit obj = { y : m.y } regardless of the output target. + if (languageVersion < 2 /* ES6 */ || isNamespaceExportReference(node.name)) { // Emit identifier as an identifier write(": "); - var generatedName = getGeneratedNameForIdentifier(node.name); - if (generatedName) { - write(generatedName); - } - else { - // Even though this is stored as identifier treat it as an expression - // Short-hand, { x }, is equivalent of normal form { x: x } - emitExpressionIdentifier(node.name); - } - } - else if (resolver.getExpressionNameSubstitution(node.name, getGeneratedNameForNode)) { - // Emit identifier as an identifier - write(": "); - // Even though this is stored as identifier treat it as an expression - // Short-hand, { x }, is equivalent of normal form { x: x } - emitExpressionIdentifier(node.name); + emit(node.name); } } function tryEmitConstantValue(node) { @@ -26963,7 +27409,7 @@ var ts; if (constantValue !== undefined) { write(constantValue.toString()); if (!compilerOptions.removeComments) { - var propertyName = node.kind === 156 /* PropertyAccessExpression */ ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + var propertyName = node.kind === 158 /* PropertyAccessExpression */ ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); write(" /* " + propertyName + " */"); } return true; @@ -26997,7 +27443,7 @@ var ts; var indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, node.dotToken); write("."); var indentedAfterDot = indentIfOnDifferentLines(node, node.dotToken, node.name); - emit(node.name, false); + emit(node.name); decreaseIndentIf(indentedBeforeDot, indentedAfterDot); } function emitQualifiedName(node) { @@ -27015,10 +27461,10 @@ var ts; write("]"); } function hasSpreadElement(elements) { - return ts.forEach(elements, function (e) { return e.kind === 174 /* SpreadElementExpression */; }); + return ts.forEach(elements, function (e) { return e.kind === 176 /* SpreadElementExpression */; }); } function skipParentheses(node) { - while (node.kind === 162 /* ParenthesizedExpression */ || node.kind === 161 /* TypeAssertionExpression */) { + while (node.kind === 164 /* ParenthesizedExpression */ || node.kind === 163 /* TypeAssertionExpression */) { node = node.expression; } return node; @@ -27039,13 +27485,13 @@ var ts; function emitCallWithSpread(node) { var target; var expr = skipParentheses(node.expression); - if (expr.kind === 156 /* PropertyAccessExpression */) { + if (expr.kind === 158 /* PropertyAccessExpression */) { // Target will be emitted as "this" argument target = emitCallTarget(expr.expression); write("."); emit(expr.name); } - else if (expr.kind === 157 /* ElementAccessExpression */) { + else if (expr.kind === 159 /* ElementAccessExpression */) { // Target will be emitted as "this" argument target = emitCallTarget(expr.expression); write("["); @@ -27090,7 +27536,7 @@ var ts; } else { emit(node.expression); - superCall = node.expression.kind === 156 /* PropertyAccessExpression */ && node.expression.expression.kind === 91 /* SuperKeyword */; + superCall = node.expression.kind === 158 /* PropertyAccessExpression */ && node.expression.expression.kind === 91 /* SuperKeyword */; } if (superCall && languageVersion < 2 /* ES6 */) { write(".call("); @@ -27109,23 +27555,21 @@ var ts; } function emitNewExpression(node) { write("new "); - // Spread operator logic can be supported in new expressions in ES5 using a combination + // Spread operator logic is supported in new expressions in ES5 using a combination // of Function.prototype.bind() and Function.prototype.apply(). // // Example: // - // var arguments = [1, 2, 3, 4, 5]; - // new Array(...arguments); + // var args = [1, 2, 3, 4, 5]; + // new Array(...args); // - // Could be transpiled into ES5: + // is compiled into the following ES5: // - // var arguments = [1, 2, 3, 4, 5]; - // new (Array.bind.apply(Array, [void 0].concat(arguments))); + // var args = [1, 2, 3, 4, 5]; + // new (Array.bind.apply(Array, [void 0].concat(args))); // - // `[void 0]` is the first argument which represents `thisArg` to the bind method above. - // And `thisArg` will be set to the return value of the constructor when instantiated - // with the new operator — regardless of any value we set `thisArg` to. Thus, we set it - // to an undefined, `void 0`. + // The 'thisArg' to 'bind' is ignored when invoking the result of 'bind' with 'new', + // Thus, we set it to undefined ('void 0'). if (languageVersion === 1 /* ES5 */ && node.arguments && hasSpreadElement(node.arguments)) { @@ -27161,12 +27605,12 @@ var ts; // If the node is synthesized, it means the emitter put the parentheses there, // not the user. If we didn't want them, the emitter would not have put them // there. - if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 164 /* ArrowFunction */) { - if (node.expression.kind === 161 /* TypeAssertionExpression */) { + if (!ts.nodeIsSynthesized(node) && node.parent.kind !== 166 /* ArrowFunction */) { + if (node.expression.kind === 163 /* TypeAssertionExpression */) { var operand = node.expression.expression; // Make sure we consider all nested cast expressions, e.g.: // (-A).x; - while (operand.kind == 161 /* TypeAssertionExpression */) { + while (operand.kind === 163 /* TypeAssertionExpression */) { operand = operand.expression; } // We have an expression of the form: (SubExpr) @@ -27177,14 +27621,14 @@ var ts; // (typeof A).toString() should be emitted as (typeof A).toString() and not typeof A.toString() // new (A()) should be emitted as new (A()) and not new A() // (function foo() { })() should be emitted as an IIF (function foo(){})() and not declaration function foo(){} () - if (operand.kind !== 168 /* PrefixUnaryExpression */ && - operand.kind !== 167 /* VoidExpression */ && - operand.kind !== 166 /* TypeOfExpression */ && - operand.kind !== 165 /* DeleteExpression */ && - operand.kind !== 169 /* PostfixUnaryExpression */ && - operand.kind !== 159 /* NewExpression */ && - !(operand.kind === 158 /* CallExpression */ && node.parent.kind === 159 /* NewExpression */) && - !(operand.kind === 163 /* FunctionExpression */ && node.parent.kind === 158 /* CallExpression */)) { + if (operand.kind !== 170 /* PrefixUnaryExpression */ && + operand.kind !== 169 /* VoidExpression */ && + operand.kind !== 168 /* TypeOfExpression */ && + operand.kind !== 167 /* DeleteExpression */ && + operand.kind !== 171 /* PostfixUnaryExpression */ && + operand.kind !== 161 /* NewExpression */ && + !(operand.kind === 160 /* CallExpression */ && node.parent.kind === 161 /* NewExpression */) && + !(operand.kind === 165 /* FunctionExpression */ && node.parent.kind === 160 /* CallExpression */)) { emit(operand); return; } @@ -27213,7 +27657,7 @@ var ts; if (!isCurrentFileSystemExternalModule() || node.kind !== 65 /* Identifier */ || ts.nodeIsSynthesized(node)) { return false; } - var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 199 /* VariableDeclaration */ || node.parent.kind === 153 /* BindingElement */); + var isVariableDeclarationOrBindingElement = node.parent && (node.parent.kind === 201 /* VariableDeclaration */ || node.parent.kind === 155 /* BindingElement */); var targetDeclaration = isVariableDeclarationOrBindingElement ? node.parent : resolver.getReferencedValueDeclaration(node); @@ -27243,7 +27687,7 @@ var ts; // the resulting expression a prefix increment operation. And in the second, it will make the resulting // expression a prefix increment whose operand is a plus expression - (++(+x)) // The same is true of minus of course. - if (node.operand.kind === 168 /* PrefixUnaryExpression */) { + if (node.operand.kind === 170 /* PrefixUnaryExpression */) { var operand = node.operand; if (node.operator === 33 /* PlusToken */ && (operand.operator === 33 /* PlusToken */ || operand.operator === 38 /* PlusPlusToken */)) { write(" "); @@ -27299,10 +27743,10 @@ var ts; } var current = node; while (current) { - if (current.kind === 228 /* SourceFile */) { + if (current.kind === 230 /* SourceFile */) { return !isExported || ((ts.getCombinedNodeFlags(node) & 1 /* Export */) !== 0); } - else if (ts.isFunctionLike(current) || current.kind === 207 /* ModuleBlock */) { + else if (ts.isFunctionLike(current) || current.kind === 209 /* ModuleBlock */) { return false; } else { @@ -27312,8 +27756,8 @@ var ts; } function emitBinaryExpression(node) { if (languageVersion < 2 /* ES6 */ && node.operatorToken.kind === 53 /* EqualsToken */ && - (node.left.kind === 155 /* ObjectLiteralExpression */ || node.left.kind === 154 /* ArrayLiteralExpression */)) { - emitDestructuring(node, node.parent.kind === 183 /* ExpressionStatement */); + (node.left.kind === 157 /* ObjectLiteralExpression */ || node.left.kind === 156 /* ArrayLiteralExpression */)) { + emitDestructuring(node, node.parent.kind === 185 /* ExpressionStatement */); } else { var exportChanged = node.operatorToken.kind >= 53 /* FirstAssignment */ && @@ -27365,7 +27809,7 @@ var ts; } } function isSingleLineEmptyBlock(node) { - if (node && node.kind === 180 /* Block */) { + if (node && node.kind === 182 /* Block */) { var block = node; return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); } @@ -27380,12 +27824,12 @@ var ts; emitToken(14 /* OpenBraceToken */, node.pos); increaseIndent(); scopeEmitStart(node.parent); - if (node.kind === 207 /* ModuleBlock */) { - ts.Debug.assert(node.parent.kind === 206 /* ModuleDeclaration */); + if (node.kind === 209 /* ModuleBlock */) { + ts.Debug.assert(node.parent.kind === 208 /* ModuleDeclaration */); emitCaptureThisForNodeIfNecessary(node.parent); } emitLines(node.statements); - if (node.kind === 207 /* ModuleBlock */) { + if (node.kind === 209 /* ModuleBlock */) { emitTempDeclarations(true); } decreaseIndent(); @@ -27394,7 +27838,7 @@ var ts; scopeEmitEnd(); } function emitEmbeddedStatement(node) { - if (node.kind === 180 /* Block */) { + if (node.kind === 182 /* Block */) { write(" "); emit(node); } @@ -27406,7 +27850,7 @@ var ts; } } function emitExpressionStatement(node) { - emitParenthesizedIf(node.expression, node.expression.kind === 164 /* ArrowFunction */); + emitParenthesizedIf(node.expression, node.expression.kind === 166 /* ArrowFunction */); write(";"); } function emitIfStatement(node) { @@ -27419,7 +27863,7 @@ var ts; if (node.elseStatement) { writeLine(); emitToken(76 /* ElseKeyword */, node.thenStatement.end); - if (node.elseStatement.kind === 184 /* IfStatement */) { + if (node.elseStatement.kind === 186 /* IfStatement */) { write(" "); emit(node.elseStatement); } @@ -27431,7 +27875,7 @@ var ts; function emitDoStatement(node) { write("do"); emitEmbeddedStatement(node.statement); - if (node.statement.kind === 180 /* Block */) { + if (node.statement.kind === 182 /* Block */) { write(" "); } else { @@ -27506,7 +27950,7 @@ var ts; var endPos = emitToken(82 /* ForKeyword */, node.pos); write(" "); endPos = emitToken(16 /* OpenParenToken */, endPos); - if (node.initializer && node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer && node.initializer.kind === 202 /* VariableDeclarationList */) { var variableDeclarationList = node.initializer; var startIsEmitted = tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); if (startIsEmitted) { @@ -27527,13 +27971,13 @@ var ts; emitEmbeddedStatement(node.statement); } function emitForInOrForOfStatement(node) { - if (languageVersion < 2 /* ES6 */ && node.kind === 189 /* ForOfStatement */) { + if (languageVersion < 2 /* ES6 */ && node.kind === 191 /* ForOfStatement */) { return emitDownLevelForOfStatement(node); } var endPos = emitToken(82 /* ForKeyword */, node.pos); write(" "); endPos = emitToken(16 /* OpenParenToken */, endPos); - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos); @@ -27543,7 +27987,7 @@ var ts; else { emit(node.initializer); } - if (node.kind === 188 /* ForInStatement */) { + if (node.kind === 190 /* ForInStatement */) { write(" in "); } else { @@ -27628,7 +28072,7 @@ var ts; // let v = _a[_i]; var rhsIterationValue = createElementAccessExpression(rhsReference, counter); emitStart(node.initializer); - if (node.initializer.kind === 200 /* VariableDeclarationList */) { + if (node.initializer.kind === 202 /* VariableDeclarationList */) { write("var "); var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length > 0) { @@ -27658,7 +28102,7 @@ var ts; // Initializer is an expression. Emit the expression in the body, so that it's // evaluated on every iteration. var assignmentExpression = createBinaryExpression(node.initializer, 53 /* EqualsToken */, rhsIterationValue, false); - if (node.initializer.kind === 154 /* ArrayLiteralExpression */ || node.initializer.kind === 155 /* ObjectLiteralExpression */) { + if (node.initializer.kind === 156 /* ArrayLiteralExpression */ || node.initializer.kind === 157 /* ObjectLiteralExpression */) { // This is a destructuring pattern, so call emitDestructuring instead of emit. Calling emit will not work, because it will cause // the BinaryExpression to be passed in instead of the expression statement, which will cause emitDestructuring to crash. emitDestructuring(assignmentExpression, true, undefined); @@ -27669,7 +28113,7 @@ var ts; } emitEnd(node.initializer); write(";"); - if (node.statement.kind === 180 /* Block */) { + if (node.statement.kind === 182 /* Block */) { emitLines(node.statement.statements); } else { @@ -27681,7 +28125,7 @@ var ts; write("}"); } function emitBreakOrContinueStatement(node) { - emitToken(node.kind === 191 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */, node.pos); + emitToken(node.kind === 193 /* BreakStatement */ ? 66 /* BreakKeyword */ : 71 /* ContinueKeyword */, node.pos); emitOptional(" ", node.label); write(";"); } @@ -27726,7 +28170,7 @@ var ts; ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); } function emitCaseOrDefaultClause(node) { - if (node.kind === 221 /* CaseClause */) { + if (node.kind === 223 /* CaseClause */) { write("case "); emit(node.expression); write(":"); @@ -27781,7 +28225,7 @@ var ts; function getContainingModule(node) { do { node = node.parent; - } while (node && node.kind !== 206 /* ModuleDeclaration */); + } while (node && node.kind !== 208 /* ModuleDeclaration */); return node; } function emitContainingModuleName(node) { @@ -27806,7 +28250,7 @@ var ts; function createVoidZero() { var zero = ts.createSynthesizedNode(7 /* NumericLiteral */); zero.text = "0"; - var result = ts.createSynthesizedNode(167 /* VoidExpression */); + var result = ts.createSynthesizedNode(169 /* VoidExpression */); result.expression = zero; return result; } @@ -27882,15 +28326,15 @@ var ts; // Also temporary variables should be explicitly allocated for source level declarations when module target is system // because actual variable declarations are hoisted var canDefineTempVariablesInPlace = false; - if (root.kind === 199 /* VariableDeclaration */) { + if (root.kind === 201 /* VariableDeclaration */) { var isExported = ts.getCombinedNodeFlags(root) & 1 /* Export */; var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root); canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind; } - else if (root.kind === 130 /* Parameter */) { + else if (root.kind === 131 /* Parameter */) { canDefineTempVariablesInPlace = true; } - if (root.kind === 170 /* BinaryExpression */) { + if (root.kind === 172 /* BinaryExpression */) { emitAssignmentExpression(root); } else { @@ -27901,8 +28345,7 @@ var ts; if (emitCount++) { write(", "); } - renameNonTopLevelLetAndConst(name); - var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 199 /* VariableDeclaration */ || name.parent.kind === 153 /* BindingElement */); + var isVariableDeclarationOrBindingElement = name.parent && (name.parent.kind === 201 /* VariableDeclaration */ || name.parent.kind === 155 /* BindingElement */); var exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name); if (exportChanged) { write(exportFunctionForFile + "(\""); @@ -27937,14 +28380,14 @@ var ts; // we need to generate a temporary variable value = ensureIdentifier(value); // Return the expression 'value === void 0 ? defaultValue : value' - var equals = ts.createSynthesizedNode(170 /* BinaryExpression */); + var equals = ts.createSynthesizedNode(172 /* BinaryExpression */); equals.left = value; equals.operatorToken = ts.createSynthesizedNode(30 /* EqualsEqualsEqualsToken */); equals.right = createVoidZero(); return createConditionalExpression(equals, defaultValue, value); } function createConditionalExpression(condition, whenTrue, whenFalse) { - var cond = ts.createSynthesizedNode(171 /* ConditionalExpression */); + var cond = ts.createSynthesizedNode(173 /* ConditionalExpression */); cond.condition = condition; cond.questionToken = ts.createSynthesizedNode(50 /* QuestionToken */); cond.whenTrue = whenTrue; @@ -27958,13 +28401,17 @@ var ts; return node; } function createPropertyAccessForDestructuringProperty(object, propName) { - if (propName.kind !== 65 /* Identifier */) { - return createElementAccessExpression(object, propName); + // We create a synthetic copy of the identifier in order to avoid the rewriting that might + // otherwise occur when the identifier is emitted. + var syntheticName = ts.createSynthesizedNode(propName.kind); + syntheticName.text = propName.text; + if (syntheticName.kind !== 65 /* Identifier */) { + return createElementAccessExpression(object, syntheticName); } - return createPropertyAccessExpression(object, propName); + return createPropertyAccessExpression(object, syntheticName); } function createSliceCall(value, sliceIndex) { - var call = ts.createSynthesizedNode(158 /* CallExpression */); + var call = ts.createSynthesizedNode(160 /* CallExpression */); var sliceIdentifier = ts.createSynthesizedNode(65 /* Identifier */); sliceIdentifier.text = "slice"; call.expression = createPropertyAccessExpression(value, sliceIdentifier); @@ -27981,9 +28428,8 @@ var ts; } for (var _a = 0; _a < properties.length; _a++) { var p = properties[_a]; - if (p.kind === 225 /* PropertyAssignment */ || p.kind === 226 /* ShorthandPropertyAssignment */) { - // TODO(andersh): Computed property support - var propName = (p.name); + if (p.kind === 227 /* PropertyAssignment */ || p.kind === 228 /* ShorthandPropertyAssignment */) { + var propName = p.name; emitDestructuringAssignment(p.initializer || propName, createPropertyAccessForDestructuringProperty(value, propName)); } } @@ -27997,8 +28443,8 @@ var ts; } for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 176 /* OmittedExpression */) { - if (e.kind !== 174 /* SpreadElementExpression */) { + if (e.kind !== 178 /* OmittedExpression */) { + if (e.kind !== 176 /* SpreadElementExpression */) { emitDestructuringAssignment(e, createElementAccessExpression(value, createNumericLiteral(i))); } else if (i === elements.length - 1) { @@ -28008,14 +28454,14 @@ var ts; } } function emitDestructuringAssignment(target, value) { - if (target.kind === 170 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { + if (target.kind === 172 /* BinaryExpression */ && target.operatorToken.kind === 53 /* EqualsToken */) { value = createDefaultValueCheck(value, target.right); target = target.left; } - if (target.kind === 155 /* ObjectLiteralExpression */) { + if (target.kind === 157 /* ObjectLiteralExpression */) { emitObjectLiteralAssignment(target, value); } - else if (target.kind === 154 /* ArrayLiteralExpression */) { + else if (target.kind === 156 /* ArrayLiteralExpression */) { emitArrayLiteralAssignment(target, value); } else { @@ -28029,14 +28475,14 @@ var ts; emitDestructuringAssignment(target, value); } else { - if (root.parent.kind !== 162 /* ParenthesizedExpression */) { + if (root.parent.kind !== 164 /* ParenthesizedExpression */) { write("("); } value = ensureIdentifier(value); emitDestructuringAssignment(target, value); write(", "); emit(value); - if (root.parent.kind !== 162 /* ParenthesizedExpression */) { + if (root.parent.kind !== 164 /* ParenthesizedExpression */) { write(")"); } } @@ -28060,12 +28506,12 @@ var ts; } for (var i = 0; i < elements.length; i++) { var element = elements[i]; - if (pattern.kind === 151 /* ObjectBindingPattern */) { + if (pattern.kind === 153 /* ObjectBindingPattern */) { // Rewrite element to a declaration with an initializer that fetches property var propName = element.propertyName || element.name; emitBindingElement(element, createPropertyAccessForDestructuringProperty(value, propName)); } - else if (element.kind !== 176 /* OmittedExpression */) { + else if (element.kind !== 178 /* OmittedExpression */) { if (!element.dotDotDotToken) { // Rewrite element to a declaration that accesses array element at index i emitBindingElement(element, createElementAccessExpression(value, createNumericLiteral(i))); @@ -28092,7 +28538,6 @@ var ts; } } else { - renameNonTopLevelLetAndConst(node.name); var initializer = node.initializer; if (!initializer && languageVersion < 2 /* ES6 */) { // downlevel emit for non-initialized let bindings defined in loops @@ -28105,8 +28550,8 @@ var ts; (getCombinedFlagsForIdentifier(node.name) & 4096 /* Let */); // NOTE: default initialization should not be added to let bindings in for-in\for-of statements if (isUninitializedLet && - node.parent.parent.kind !== 188 /* ForInStatement */ && - node.parent.parent.kind !== 189 /* ForOfStatement */) { + node.parent.parent.kind !== 190 /* ForInStatement */ && + node.parent.parent.kind !== 191 /* ForOfStatement */) { initializer = createVoidZero(); } } @@ -28124,7 +28569,7 @@ var ts; } } function emitExportVariableAssignments(node) { - if (node.kind === 176 /* OmittedExpression */) { + if (node.kind === 178 /* OmittedExpression */) { return; } var name = node.name; @@ -28136,56 +28581,15 @@ var ts; } } function getCombinedFlagsForIdentifier(node) { - if (!node.parent || (node.parent.kind !== 199 /* VariableDeclaration */ && node.parent.kind !== 153 /* BindingElement */)) { + if (!node.parent || (node.parent.kind !== 201 /* VariableDeclaration */ && node.parent.kind !== 155 /* BindingElement */)) { return 0; } return ts.getCombinedNodeFlags(node.parent); } - function renameNonTopLevelLetAndConst(node) { - // do not rename if - // - language version is ES6+ - // - node is synthesized - // - node is not identifier (can happen when tree is malformed) - // - node is definitely not name of variable declaration. - // it still can be part of parameter declaration, this check will be done next - if (languageVersion >= 2 /* ES6 */ || - ts.nodeIsSynthesized(node) || - node.kind !== 65 /* Identifier */ || - (node.parent.kind !== 199 /* VariableDeclaration */ && node.parent.kind !== 153 /* BindingElement */)) { - return; - } - var combinedFlags = getCombinedFlagsForIdentifier(node); - if (((combinedFlags & 12288 /* BlockScoped */) === 0) || combinedFlags & 1 /* Export */) { - // do not rename exported or non-block scoped variables - return; - } - // here it is known that node is a block scoped variable - var list = ts.getAncestor(node, 200 /* VariableDeclarationList */); - if (list.parent.kind === 181 /* VariableStatement */) { - var isSourceFileLevelBinding = list.parent.parent.kind === 228 /* SourceFile */; - var isModuleLevelBinding = list.parent.parent.kind === 207 /* ModuleBlock */; - var isFunctionLevelBinding = list.parent.parent.kind === 180 /* Block */ && ts.isFunctionLike(list.parent.parent.parent); - if (isSourceFileLevelBinding || isModuleLevelBinding || isFunctionLevelBinding) { - return; - } - } - var blockScopeContainer = ts.getEnclosingBlockScopeContainer(node); - var parent = blockScopeContainer.kind === 228 /* SourceFile */ - ? blockScopeContainer - : blockScopeContainer.parent; - if (resolver.resolvesToSomeValue(parent, node.text)) { - var variableId = resolver.getBlockScopedVariableId(node); - if (!blockScopedVariableToGeneratedName) { - blockScopedVariableToGeneratedName = []; - } - var generatedName = makeUniqueName(node.text); - blockScopedVariableToGeneratedName[variableId] = generatedName; - } - } function isES6ExportedDeclaration(node) { return !!(node.flags & 1 /* Export */) && languageVersion >= 2 /* ES6 */ && - node.parent.kind === 228 /* SourceFile */; + node.parent.kind === 230 /* SourceFile */; } function emitVariableStatement(node) { var startIsEmitted = false; @@ -28236,12 +28640,12 @@ var ts; function emitParameter(node) { if (languageVersion < 2 /* ES6 */) { if (ts.isBindingPattern(node.name)) { - var name_23 = createTempVariable(0 /* Auto */); + var name_20 = createTempVariable(0 /* Auto */); if (!tempParameters) { tempParameters = []; } - tempParameters.push(name_23); - emit(name_23); + tempParameters.push(name_20); + emit(name_20); } else { emit(node.name); @@ -28332,12 +28736,12 @@ var ts; } } function emitAccessor(node) { - write(node.kind === 137 /* GetAccessor */ ? "get " : "set "); - emit(node.name, false); + write(node.kind === 138 /* GetAccessor */ ? "get " : "set "); + emit(node.name); emitSignatureAndBody(node); } function shouldEmitAsArrowFunction(node) { - return node.kind === 164 /* ArrowFunction */ && languageVersion >= 2 /* ES6 */; + return node.kind === 166 /* ArrowFunction */ && languageVersion >= 2 /* ES6 */; } function emitDeclarationName(node) { if (node.name) { @@ -28348,11 +28752,11 @@ var ts; } } function shouldEmitFunctionName(node) { - if (node.kind === 163 /* FunctionExpression */) { + if (node.kind === 165 /* FunctionExpression */) { // Emit name if one is present return !!node.name; } - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 203 /* FunctionDeclaration */) { // Emit name if one is present, or emit generated name in down-level case (for export default case) return !!node.name || languageVersion < 2 /* ES6 */; } @@ -28361,7 +28765,7 @@ var ts; if (ts.nodeIsMissing(node.body)) { return emitOnlyPinnedOrTripleSlashComments(node); } - if (node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { + if (node.kind !== 136 /* MethodDeclaration */ && node.kind !== 135 /* MethodSignature */) { // Methods will emit the comments as part of emitting method declaration emitLeadingComments(node); } @@ -28384,10 +28788,10 @@ var ts; emitDeclarationName(node); } emitSignatureAndBody(node); - if (languageVersion < 2 /* ES6 */ && node.kind === 201 /* FunctionDeclaration */ && node.parent === currentSourceFile && node.name) { + if (languageVersion < 2 /* ES6 */ && node.kind === 203 /* FunctionDeclaration */ && node.parent === currentSourceFile && node.name) { emitExportMemberAssignments(node.name); } - if (node.kind !== 135 /* MethodDeclaration */ && node.kind !== 134 /* MethodSignature */) { + if (node.kind !== 136 /* MethodDeclaration */ && node.kind !== 135 /* MethodSignature */) { emitTrailingComments(node); } } @@ -28438,7 +28842,7 @@ var ts; // in that case. write(" { }"); } - else if (node.body.kind === 180 /* Block */) { + else if (node.body.kind === 182 /* Block */) { emitBlockFunctionBody(node, node.body); } else { @@ -28469,10 +28873,10 @@ var ts; write(" "); // Unwrap all type assertions. var current = body; - while (current.kind === 161 /* TypeAssertionExpression */) { + while (current.kind === 163 /* TypeAssertionExpression */) { current = current.expression; } - emitParenthesizedIf(body, current.kind === 155 /* ObjectLiteralExpression */); + emitParenthesizedIf(body, current.kind === 157 /* ObjectLiteralExpression */); } function emitDownLevelExpressionFunctionBody(node, body) { write(" {"); @@ -28548,9 +28952,9 @@ var ts; function findInitialSuperCall(ctor) { if (ctor.body) { var statement = ctor.body.statements[0]; - if (statement && statement.kind === 183 /* ExpressionStatement */) { + if (statement && statement.kind === 185 /* ExpressionStatement */) { var expr = statement.expression; - if (expr && expr.kind === 158 /* CallExpression */) { + if (expr && expr.kind === 160 /* CallExpression */) { var func = expr.expression; if (func && func.kind === 91 /* SuperKeyword */) { return statement; @@ -28582,7 +28986,7 @@ var ts; emitNodeWithoutSourceMap(memberName); write("]"); } - else if (memberName.kind === 128 /* ComputedPropertyName */) { + else if (memberName.kind === 129 /* ComputedPropertyName */) { emitComputedPropertyName(memberName); } else { @@ -28594,7 +28998,7 @@ var ts; var properties = []; for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if (member.kind === 133 /* PropertyDeclaration */ && isStatic === ((member.flags & 128 /* Static */) !== 0) && member.initializer) { + if (member.kind === 134 /* PropertyDeclaration */ && isStatic === ((member.flags & 128 /* Static */) !== 0) && member.initializer) { properties.push(member); } } @@ -28634,11 +29038,11 @@ var ts; } function emitMemberFunctionsForES5AndLower(node) { ts.forEach(node.members, function (member) { - if (member.kind === 179 /* SemicolonClassElement */) { + if (member.kind === 181 /* SemicolonClassElement */) { writeLine(); write(";"); } - else if (member.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */) { + else if (member.kind === 136 /* MethodDeclaration */ || node.kind === 135 /* MethodSignature */) { if (!member.body) { return emitOnlyPinnedOrTripleSlashComments(member); } @@ -28657,7 +29061,7 @@ var ts; write(";"); emitTrailingComments(member); } - else if (member.kind === 137 /* GetAccessor */ || member.kind === 138 /* SetAccessor */) { + else if (member.kind === 138 /* GetAccessor */ || member.kind === 139 /* SetAccessor */) { var accessors = ts.getAllAccessorDeclarations(node.members, member); if (member === accessors.firstAccessor) { writeLine(); @@ -28707,22 +29111,22 @@ var ts; function emitMemberFunctionsForES6AndHigher(node) { for (var _a = 0, _b = node.members; _a < _b.length; _a++) { var member = _b[_a]; - if ((member.kind === 135 /* MethodDeclaration */ || node.kind === 134 /* MethodSignature */) && !member.body) { + if ((member.kind === 136 /* MethodDeclaration */ || node.kind === 135 /* MethodSignature */) && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } - else if (member.kind === 135 /* MethodDeclaration */ || - member.kind === 137 /* GetAccessor */ || - member.kind === 138 /* SetAccessor */) { + else if (member.kind === 136 /* MethodDeclaration */ || + member.kind === 138 /* GetAccessor */ || + member.kind === 139 /* SetAccessor */) { writeLine(); emitLeadingComments(member); emitStart(member); if (member.flags & 128 /* Static */) { write("static "); } - if (member.kind === 137 /* GetAccessor */) { + if (member.kind === 138 /* GetAccessor */) { write("get "); } - else if (member.kind === 138 /* SetAccessor */) { + else if (member.kind === 139 /* SetAccessor */) { write("set "); } if (member.asteriskToken) { @@ -28733,7 +29137,7 @@ var ts; emitEnd(member); emitTrailingComments(member); } - else if (member.kind === 179 /* SemicolonClassElement */) { + else if (member.kind === 181 /* SemicolonClassElement */) { writeLine(); write(";"); } @@ -28758,11 +29162,11 @@ var ts; var hasInstancePropertyWithInitializer = false; // Emit the constructor overload pinned comments ts.forEach(node.members, function (member) { - if (member.kind === 136 /* Constructor */ && !member.body) { + if (member.kind === 137 /* Constructor */ && !member.body) { emitOnlyPinnedOrTripleSlashComments(member); } // Check if there is any non-static property assignment - if (member.kind === 133 /* PropertyDeclaration */ && member.initializer && (member.flags & 128 /* Static */) === 0) { + if (member.kind === 134 /* PropertyDeclaration */ && member.initializer && (member.flags & 128 /* Static */) === 0) { hasInstancePropertyWithInitializer = true; } }); @@ -28870,7 +29274,7 @@ var ts; } function emitClassLikeDeclarationForES6AndHigher(node) { var thisNodeIsDecorated = ts.nodeIsDecorated(node); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { if (thisNodeIsDecorated) { // To preserve the correct runtime semantics when decorators are applied to the class, // the emit needs to follow one of the following rules: @@ -28950,7 +29354,7 @@ var ts; // This keeps the expression as an expression, while ensuring that the static parts // of it have been initialized by the time it is used. var staticProperties = getInitializedProperties(node, true); - var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 175 /* ClassExpression */; + var isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === 177 /* ClassExpression */; var tempVariable; if (isClassExpressionWithStaticProperties) { tempVariable = createAndRecordTempVariable(0 /* Auto */); @@ -29034,7 +29438,7 @@ var ts; } } function emitClassLikeDeclarationBelowES6(node) { - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { // source file level classes in system modules are hoisted so 'var's for them are already defined if (!shouldHoistDeclarationInSystemJsModule(node)) { write("var "); @@ -29093,11 +29497,11 @@ var ts; emit(baseTypeNode.expression); } write(")"); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { write(";"); } emitEnd(node); - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { emitExportMemberAssignment(node); } if (languageVersion < 2 /* ES6 */ && node.parent === currentSourceFile && node.name) { @@ -29189,7 +29593,7 @@ var ts; else { decorators = member.decorators; // we only decorate the parameters here if this is a method - if (member.kind === 135 /* MethodDeclaration */) { + if (member.kind === 136 /* MethodDeclaration */) { functionLikeMember = member; } } @@ -29227,7 +29631,7 @@ var ts; // writeLine(); emitStart(member); - if (member.kind !== 133 /* PropertyDeclaration */) { + if (member.kind !== 134 /* PropertyDeclaration */) { write("Object.defineProperty("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -29257,7 +29661,7 @@ var ts; write(", "); emitExpressionForPropertyName(member.name); emitEnd(member.name); - if (member.kind !== 133 /* PropertyDeclaration */) { + if (member.kind !== 134 /* PropertyDeclaration */) { write(", Object.getOwnPropertyDescriptor("); emitStart(member.name); emitClassMemberPrefix(node, member); @@ -29299,10 +29703,10 @@ var ts; // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata // compiler option is set. switch (node.kind) { - case 135 /* MethodDeclaration */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 133 /* PropertyDeclaration */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 134 /* PropertyDeclaration */: return true; } return false; @@ -29312,7 +29716,7 @@ var ts; // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata // compiler option is set. switch (node.kind) { - case 135 /* MethodDeclaration */: + case 136 /* MethodDeclaration */: return true; } return false; @@ -29322,9 +29726,9 @@ var ts; // The caller should have already tested whether the node has decorators and whether the emitDecoratorMetadata // compiler option is set. switch (node.kind) { - case 202 /* ClassDeclaration */: - case 135 /* MethodDeclaration */: - case 138 /* SetAccessor */: + case 204 /* ClassDeclaration */: + case 136 /* MethodDeclaration */: + case 139 /* SetAccessor */: return true; } return false; @@ -29335,7 +29739,7 @@ var ts; var argumentsWritten = 0; if (compilerOptions.emitDecoratorMetadata) { if (shouldEmitTypeMetadata(node)) { - var serializedType = resolver.serializeTypeOfNode(node, getGeneratedNameForNode); + var serializedType = resolver.serializeTypeOfNode(node); if (serializedType) { if (writeComma) { write(", "); @@ -29348,7 +29752,7 @@ var ts; } } if (shouldEmitParamTypesMetadata(node)) { - var serializedTypes = resolver.serializeParameterTypesOfNode(node, getGeneratedNameForNode); + var serializedTypes = resolver.serializeParameterTypesOfNode(node); if (serializedTypes) { if (writeComma || argumentsWritten) { write(", "); @@ -29366,7 +29770,7 @@ var ts; } } if (shouldEmitReturnTypeMetadata(node)) { - var serializedType = resolver.serializeReturnTypeOfNode(node, getGeneratedNameForNode); + var serializedType = resolver.serializeReturnTypeOfNode(node); if (serializedType) { if (writeComma || argumentsWritten) { write(", "); @@ -29500,7 +29904,7 @@ var ts; } } function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { - if (moduleDeclaration.body.kind === 206 /* ModuleDeclaration */) { + if (moduleDeclaration.body.kind === 208 /* ModuleDeclaration */) { var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); return recursiveInnerModule || moduleDeclaration.body; } @@ -29536,7 +29940,7 @@ var ts; write(getGeneratedNameForNode(node)); emitEnd(node.name); write(") "); - if (node.body.kind === 207 /* ModuleBlock */) { + if (node.body.kind === 209 /* ModuleBlock */) { var saveTempFlags = tempFlags; var saveTempVariables = tempVariables; tempFlags = 0; @@ -29594,16 +29998,16 @@ var ts; } } function getNamespaceDeclarationNode(node) { - if (node.kind === 209 /* ImportEqualsDeclaration */) { + if (node.kind === 211 /* ImportEqualsDeclaration */) { return node; } var importClause = node.importClause; - if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause && importClause.namedBindings && importClause.namedBindings.kind === 214 /* NamespaceImport */) { return importClause.namedBindings; } } function isDefaultImport(node) { - return node.kind === 210 /* ImportDeclaration */ && node.importClause && !!node.importClause.name; + return node.kind === 212 /* ImportDeclaration */ && node.importClause && !!node.importClause.name; } function emitExportImportAssignments(node) { if (ts.isAliasSymbolDeclaration(node) && resolver.isValueAliasDeclaration(node)) { @@ -29631,7 +30035,7 @@ var ts; if (shouldEmitNamedBindings) { emitLeadingComments(node.importClause.namedBindings); emitStart(node.importClause.namedBindings); - if (node.importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (node.importClause.namedBindings.kind === 214 /* NamespaceImport */) { write("* as "); emit(node.importClause.namedBindings.name); } @@ -29657,7 +30061,7 @@ var ts; } function emitExternalImportDeclaration(node) { if (ts.contains(externalImports, node)) { - var isExportedImport = node.kind === 209 /* ImportEqualsDeclaration */ && (node.flags & 1 /* Export */) !== 0; + var isExportedImport = node.kind === 211 /* ImportEqualsDeclaration */ && (node.flags & 1 /* Export */) !== 0; var namespaceDeclaration = getNamespaceDeclarationNode(node); if (compilerOptions.module !== 2 /* AMD */) { emitLeadingComments(node); @@ -29676,7 +30080,7 @@ var ts; // import { x, y } from "foo" // import d, * as x from "foo" // import d, { x, y } from "foo" - var isNakedImport = 210 /* ImportDeclaration */ && !node.importClause; + var isNakedImport = 212 /* ImportDeclaration */ && !node.importClause; if (!isNakedImport) { write("var "); write(getGeneratedNameForNode(node)); @@ -29840,8 +30244,8 @@ var ts; write("export default "); var expression = node.expression; emit(expression); - if (expression.kind !== 201 /* FunctionDeclaration */ && - expression.kind !== 202 /* ClassDeclaration */) { + if (expression.kind !== 203 /* FunctionDeclaration */ && + expression.kind !== 204 /* ClassDeclaration */) { write(";"); } emitEnd(node); @@ -29877,7 +30281,7 @@ var ts; for (var _a = 0, _b = sourceFile.statements; _a < _b.length; _a++) { var node = _b[_a]; switch (node.kind) { - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: if (!node.importClause || resolver.isReferencedAliasDeclaration(node.importClause, true)) { // import "mod" @@ -29887,13 +30291,13 @@ var ts; externalImports.push(node); } break; - case 209 /* ImportEqualsDeclaration */: - if (node.moduleReference.kind === 220 /* ExternalModuleReference */ && resolver.isReferencedAliasDeclaration(node)) { + case 211 /* ImportEqualsDeclaration */: + if (node.moduleReference.kind === 222 /* ExternalModuleReference */ && resolver.isReferencedAliasDeclaration(node)) { // import x = require("mod") where x is referenced externalImports.push(node); } break; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: if (node.moduleSpecifier) { if (!node.exportClause) { // export * from "mod" @@ -29909,12 +30313,12 @@ var ts; // export { x, y } for (var _c = 0, _d = node.exportClause.elements; _c < _d.length; _c++) { var specifier = _d[_c]; - var name_24 = (specifier.propertyName || specifier.name).text; - (exportSpecifiers[name_24] || (exportSpecifiers[name_24] = [])).push(specifier); + var name_21 = (specifier.propertyName || specifier.name).text; + (exportSpecifiers[name_21] || (exportSpecifiers[name_21] = [])).push(specifier); } } break; - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: if (node.isExportEquals && !exportEquals) { // export = x exportEquals = node; @@ -29935,13 +30339,16 @@ var ts; write("}"); } } - function getLocalNameForExternalImport(importNode) { - var namespaceDeclaration = getNamespaceDeclarationNode(importNode); - if (namespaceDeclaration && !isDefaultImport(importNode)) { + function getLocalNameForExternalImport(node) { + var namespaceDeclaration = getNamespaceDeclarationNode(node); + if (namespaceDeclaration && !isDefaultImport(node)) { return ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, namespaceDeclaration.name); } - else { - return getGeneratedNameForNode(importNode); + if (node.kind === 212 /* ImportDeclaration */ && node.importClause) { + return getGeneratedNameForNode(node); + } + if (node.kind === 218 /* ExportDeclaration */ && node.moduleSpecifier) { + return getGeneratedNameForNode(node); } } function getExternalModuleNameText(importNode) { @@ -29960,8 +30367,8 @@ var ts; for (var _a = 0; _a < externalImports.length; _a++) { var importNode = externalImports[_a]; // do not create variable declaration for exports and imports that lack import clause - var skipNode = importNode.kind === 216 /* ExportDeclaration */ || - (importNode.kind === 210 /* ImportDeclaration */ && !importNode.importClause); + var skipNode = importNode.kind === 218 /* ExportDeclaration */ || + (importNode.kind === 212 /* ImportDeclaration */ && !importNode.importClause); if (skipNode) { continue; } @@ -29994,7 +30401,7 @@ var ts; var hasExportDeclarationWithExportClause = false; for (var _a = 0; _a < externalImports.length; _a++) { var externalImport = externalImports[_a]; - if (externalImport.kind === 216 /* ExportDeclaration */ && externalImport.exportClause) { + if (externalImport.kind === 218 /* ExportDeclaration */ && externalImport.exportClause) { hasExportDeclarationWithExportClause = true; break; } @@ -30026,7 +30433,7 @@ var ts; } for (var _d = 0; _d < externalImports.length; _d++) { var externalImport = externalImports[_d]; - if (externalImport.kind !== 216 /* ExportDeclaration */) { + if (externalImport.kind !== 218 /* ExportDeclaration */) { continue; } var exportDecl = externalImport; @@ -30110,12 +30517,12 @@ var ts; var seen = {}; for (var i = 0; i < hoistedVars.length; ++i) { var local = hoistedVars[i]; - var name_25 = local.kind === 65 /* Identifier */ + var name_22 = local.kind === 65 /* Identifier */ ? local : local.name; - if (name_25) { + if (name_22) { // do not emit duplicate entries (in case of declaration merging) in the list of hoisted variables - var text = ts.unescapeIdentifier(name_25.text); + var text = ts.unescapeIdentifier(name_22.text); if (ts.hasProperty(seen, text)) { continue; } @@ -30126,7 +30533,7 @@ var ts; if (i !== 0) { write(", "); } - if (local.kind === 202 /* ClassDeclaration */ || local.kind === 206 /* ModuleDeclaration */ || local.kind === 205 /* EnumDeclaration */) { + if (local.kind === 204 /* ClassDeclaration */ || local.kind === 208 /* ModuleDeclaration */ || local.kind === 207 /* EnumDeclaration */) { emitDeclarationName(local); } else { @@ -30160,21 +30567,21 @@ var ts; if (node.flags & 2 /* Ambient */) { return; } - if (node.kind === 201 /* FunctionDeclaration */) { + if (node.kind === 203 /* FunctionDeclaration */) { if (!hoistedFunctionDeclarations) { hoistedFunctionDeclarations = []; } hoistedFunctionDeclarations.push(node); return; } - if (node.kind === 202 /* ClassDeclaration */) { + if (node.kind === 204 /* ClassDeclaration */) { if (!hoistedVars) { hoistedVars = []; } hoistedVars.push(node); return; } - if (node.kind === 205 /* EnumDeclaration */) { + if (node.kind === 207 /* EnumDeclaration */) { if (shouldEmitEnumDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; @@ -30183,7 +30590,7 @@ var ts; } return; } - if (node.kind === 206 /* ModuleDeclaration */) { + if (node.kind === 208 /* ModuleDeclaration */) { if (shouldEmitModuleDeclaration(node)) { if (!hoistedVars) { hoistedVars = []; @@ -30192,17 +30599,17 @@ var ts; } return; } - if (node.kind === 199 /* VariableDeclaration */ || node.kind === 153 /* BindingElement */) { + if (node.kind === 201 /* VariableDeclaration */ || node.kind === 155 /* BindingElement */) { if (shouldHoistVariable(node, false)) { - var name_26 = node.name; - if (name_26.kind === 65 /* Identifier */) { + var name_23 = node.name; + if (name_23.kind === 65 /* Identifier */) { if (!hoistedVars) { hoistedVars = []; } - hoistedVars.push(name_26); + hoistedVars.push(name_23); } else { - ts.forEachChild(name_26, visit); + ts.forEachChild(name_23, visit); } } return; @@ -30226,7 +30633,7 @@ var ts; // if block scoped variables are nested in some another block then // no other functions can use them except ones that are defined at least in the same block return (ts.getCombinedNodeFlags(node) & 12288 /* BlockScoped */) === 0 || - ts.getEnclosingBlockScopeContainer(node).kind === 228 /* SourceFile */; + ts.getEnclosingBlockScopeContainer(node).kind === 230 /* SourceFile */; } function isCurrentFileSystemExternalModule() { return compilerOptions.module === 4 /* System */ && ts.isExternalModule(currentSourceFile); @@ -30279,10 +30686,10 @@ var ts; emitSetters(exportStarFunction); writeLine(); emitExecute(node, startIndex); - emitTempDeclarations(true); decreaseIndent(); writeLine(); write("}"); // return + emitTempDeclarations(true); } function emitSetters(exportStarFunction) { write("setters:["); @@ -30297,21 +30704,21 @@ var ts; var parameterName = "_" + importVariableName; write("function (" + parameterName + ") {"); switch (importNode.kind) { - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: if (!importNode.importClause) { // 'import "..."' case // module is imported only for side-effects, setter body will be empty break; } // fall-through - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: ts.Debug.assert(importVariableName !== ""); increaseIndent(); writeLine(); // save import into the local write(importVariableName + " = " + parameterName + ";"); writeLine(); - var defaultName = importNode.kind === 210 /* ImportDeclaration */ + var defaultName = importNode.kind === 212 /* ImportDeclaration */ ? importNode.importClause.name : importNode.name; if (defaultName) { @@ -30323,10 +30730,10 @@ var ts; emitExportMemberAssignments(defaultName); writeLine(); } - if (importNode.kind === 210 /* ImportDeclaration */ && + if (importNode.kind === 212 /* ImportDeclaration */ && importNode.importClause.namedBindings) { var namedBindings = importNode.importClause.namedBindings; - if (namedBindings.kind === 212 /* NamespaceImport */) { + if (namedBindings.kind === 214 /* NamespaceImport */) { // emit re-export for namespace // import * as n from 'foo' // export {n} @@ -30346,7 +30753,7 @@ var ts; } decreaseIndent(); break; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: ts.Debug.assert(importVariableName !== ""); increaseIndent(); if (importNode.exportClause) { @@ -30389,10 +30796,10 @@ var ts; // - imports/exports are not emitted for system modules // - function declarations are not emitted because they were already hoisted switch (statement.kind) { - case 216 /* ExportDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 201 /* FunctionDeclaration */: + case 218 /* ExportDeclaration */: + case 212 /* ImportDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 203 /* FunctionDeclaration */: continue; } writeLine(); @@ -30415,7 +30822,11 @@ var ts; ts.Debug.assert(!exportFunctionForFile); // make sure that name of 'exports' function does not conflict with existing identifiers exportFunctionForFile = makeUniqueName("exports"); - write("System.register(["); + write("System.register("); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); + } + write("["); for (var i = 0; i < externalImports.length; ++i) { var text = getExternalModuleNameText(externalImports[i]); if (i !== 0) { @@ -30495,8 +30906,8 @@ var ts; collectExternalModuleInfo(node); writeLine(); write("define("); - if (node.amdModuleName) { - write("\"" + node.amdModuleName + "\", "); + if (node.moduleName) { + write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, true); write(") {"); @@ -30634,7 +31045,7 @@ var ts; } emitLeadingComments(node.endOfFileToken); } - function emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers) { + function emitNodeWithoutSourceMap(node) { if (!node) { return; } @@ -30645,7 +31056,7 @@ var ts; if (emitComments) { emitLeadingComments(node); } - emitJavaScriptWorker(node, allowGeneratedIdentifiers); + emitJavaScriptWorker(node); if (emitComments) { emitTrailingComments(node); } @@ -30654,20 +31065,20 @@ var ts; switch (node.kind) { // All of these entities are emitted in a specialized fashion. As such, we allow // the specialized methods for each to handle the comments on the nodes. - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: - case 210 /* ImportDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 215 /* ExportAssignment */: + case 205 /* InterfaceDeclaration */: + case 203 /* FunctionDeclaration */: + case 212 /* ImportDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 217 /* ExportAssignment */: return false; - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return shouldEmitLeadingAndTrailingCommentsForVariableStatement(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: // Only emit the leading/trailing comments for a module if we're actually // emitting the module as well. return shouldEmitModuleDeclaration(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: // Only emit the leading/trailing comments for an enum if we're actually // emitting the module as well. return shouldEmitEnumDeclaration(node); @@ -30676,9 +31087,9 @@ var ts; // then we don't want to emit comments when we emit the body. It will have already // been taken care of when we emitted the 'return' statement for the function // expression body. - if (node.kind !== 180 /* Block */ && + if (node.kind !== 182 /* Block */ && node.parent && - node.parent.kind === 164 /* ArrowFunction */ && + node.parent.kind === 166 /* ArrowFunction */ && node.parent.body === node && compilerOptions.target <= 1 /* ES5 */) { return false; @@ -30686,19 +31097,18 @@ var ts; // Emit comments for everything else. return true; } - function emitJavaScriptWorker(node, allowGeneratedIdentifiers) { - if (allowGeneratedIdentifiers === void 0) { allowGeneratedIdentifiers = true; } + function emitJavaScriptWorker(node) { // Check if the node can be emitted regardless of the ScriptTarget switch (node.kind) { case 65 /* Identifier */: - return emitIdentifier(node, allowGeneratedIdentifiers); - case 130 /* Parameter */: + return emitIdentifier(node); + case 131 /* Parameter */: return emitParameter(node); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return emitMethod(node); - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: return emitAccessor(node); case 93 /* ThisKeyword */: return emitThis(node); @@ -30718,131 +31128,131 @@ var ts; case 12 /* TemplateMiddle */: case 13 /* TemplateTail */: return emitLiteral(node); - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: return emitTemplateExpression(node); - case 178 /* TemplateSpan */: + case 180 /* TemplateSpan */: return emitTemplateSpan(node); - case 127 /* QualifiedName */: + case 128 /* QualifiedName */: return emitQualifiedName(node); - case 151 /* ObjectBindingPattern */: + case 153 /* ObjectBindingPattern */: return emitObjectBindingPattern(node); - case 152 /* ArrayBindingPattern */: + case 154 /* ArrayBindingPattern */: return emitArrayBindingPattern(node); - case 153 /* BindingElement */: + case 155 /* BindingElement */: return emitBindingElement(node); - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return emitArrayLiteral(node); - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return emitObjectLiteral(node); - case 225 /* PropertyAssignment */: + case 227 /* PropertyAssignment */: return emitPropertyAssignment(node); - case 226 /* ShorthandPropertyAssignment */: + case 228 /* ShorthandPropertyAssignment */: return emitShorthandPropertyAssignment(node); - case 128 /* ComputedPropertyName */: + case 129 /* ComputedPropertyName */: return emitComputedPropertyName(node); - case 156 /* PropertyAccessExpression */: + case 158 /* PropertyAccessExpression */: return emitPropertyAccess(node); - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: return emitIndexedAccess(node); - case 158 /* CallExpression */: + case 160 /* CallExpression */: return emitCallExpression(node); - case 159 /* NewExpression */: + case 161 /* NewExpression */: return emitNewExpression(node); - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: return emitTaggedTemplateExpression(node); - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: return emit(node.expression); - case 162 /* ParenthesizedExpression */: + case 164 /* ParenthesizedExpression */: return emitParenExpression(node); - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: return emitFunctionDeclaration(node); - case 165 /* DeleteExpression */: + case 167 /* DeleteExpression */: return emitDeleteExpression(node); - case 166 /* TypeOfExpression */: + case 168 /* TypeOfExpression */: return emitTypeOfExpression(node); - case 167 /* VoidExpression */: + case 169 /* VoidExpression */: return emitVoidExpression(node); - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: return emitPrefixUnaryExpression(node); - case 169 /* PostfixUnaryExpression */: + case 171 /* PostfixUnaryExpression */: return emitPostfixUnaryExpression(node); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return emitBinaryExpression(node); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return emitConditionalExpression(node); - case 174 /* SpreadElementExpression */: + case 176 /* SpreadElementExpression */: return emitSpreadElementExpression(node); - case 173 /* YieldExpression */: + case 175 /* YieldExpression */: return emitYieldExpression(node); - case 176 /* OmittedExpression */: + case 178 /* OmittedExpression */: return; - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return emitBlock(node); - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: return emitVariableStatement(node); - case 182 /* EmptyStatement */: + case 184 /* EmptyStatement */: return write(";"); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: return emitExpressionStatement(node); - case 184 /* IfStatement */: + case 186 /* IfStatement */: return emitIfStatement(node); - case 185 /* DoStatement */: + case 187 /* DoStatement */: return emitDoStatement(node); - case 186 /* WhileStatement */: + case 188 /* WhileStatement */: return emitWhileStatement(node); - case 187 /* ForStatement */: + case 189 /* ForStatement */: return emitForStatement(node); - case 189 /* ForOfStatement */: - case 188 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 190 /* ForInStatement */: return emitForInOrForOfStatement(node); - case 190 /* ContinueStatement */: - case 191 /* BreakStatement */: + case 192 /* ContinueStatement */: + case 193 /* BreakStatement */: return emitBreakOrContinueStatement(node); - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: return emitReturnStatement(node); - case 193 /* WithStatement */: + case 195 /* WithStatement */: return emitWithStatement(node); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: return emitSwitchStatement(node); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: return emitCaseOrDefaultClause(node); - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: return emitLabelledStatement(node); - case 196 /* ThrowStatement */: + case 198 /* ThrowStatement */: return emitThrowStatement(node); - case 197 /* TryStatement */: + case 199 /* TryStatement */: return emitTryStatement(node); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return emitCatchClause(node); - case 198 /* DebuggerStatement */: + case 200 /* DebuggerStatement */: return emitDebuggerStatement(node); - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: return emitVariableDeclaration(node); - case 175 /* ClassExpression */: + case 177 /* ClassExpression */: return emitClassExpression(node); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return emitClassDeclaration(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return emitInterfaceDeclaration(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return emitEnumDeclaration(node); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return emitEnumMember(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return emitModuleDeclaration(node); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: return emitImportDeclaration(node); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: return emitImportEqualsDeclaration(node); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: return emitExportDeclaration(node); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: return emitExportAssignment(node); - case 228 /* SourceFile */: + case 230 /* SourceFile */: return emitSourceFileNode(node); } } @@ -30874,7 +31284,7 @@ var ts; function getLeadingCommentsToEmit(node) { // Emit the leading comments only if the parent's pos doesn't match because parent should take care of emitting these comments if (node.parent) { - if (node.parent.kind === 228 /* SourceFile */ || node.pos !== node.parent.pos) { + if (node.parent.kind === 230 /* SourceFile */ || node.pos !== node.parent.pos) { if (hasDetachedComments(node.pos)) { // get comments without detached comments return getLeadingCommentsWithoutDetachedComments(); @@ -30889,7 +31299,7 @@ var ts; function getTrailingCommentsToEmit(node) { // Emit the trailing comments only if the parent's pos doesn't match because parent should take care of emitting these comments if (node.parent) { - if (node.parent.kind === 228 /* SourceFile */ || node.end !== node.parent.end) { + if (node.parent.kind === 230 /* SourceFile */ || node.end !== node.parent.end) { return ts.getTrailingCommentRanges(currentSourceFile.text, node.end); } } @@ -31086,7 +31496,7 @@ var ts; } ts.createCompilerHost = createCompilerHost; function getPreEmitDiagnostics(program, sourceFile) { - var diagnostics = program.getSyntacticDiagnostics(sourceFile).concat(program.getGlobalDiagnostics()).concat(program.getSemanticDiagnostics(sourceFile)); + var diagnostics = program.getOptionsDiagnostics().concat(program.getSyntacticDiagnostics(sourceFile), program.getGlobalDiagnostics(), program.getSemanticDiagnostics(sourceFile)); if (program.getCompilerOptions().declaration) { diagnostics.concat(program.getDeclarationDiagnostics(sourceFile)); } @@ -31119,16 +31529,21 @@ var ts; function createProgram(rootNames, options, host) { var program; var files = []; - var filesByName = {}; var diagnostics = ts.createDiagnosticCollection(); - var seenNoDefaultLib = options.noLib; var commonSourceDirectory; var diagnosticsProducingTypeChecker; var noDiagnosticsTypeChecker; + var classifiableNames; + var skipDefaultLib = options.noLib; var start = new Date().getTime(); host = host || createCompilerHost(options); + var filesByName = ts.createFileMap(function (fileName) { return host.getCanonicalFileName(fileName); }); ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); - if (!seenNoDefaultLib) { + // Do not process the default library if: + // - The '--noLib' flag is used. + // - A 'no-default-lib' reference comment is encountered in + // processing the root files. + if (!skipDefaultLib) { processRootFile(host.getDefaultLibFileName(options), true); } verifyCompilerOptions(); @@ -31138,11 +31553,12 @@ var ts; getSourceFiles: function () { return files; }, getCompilerOptions: function () { return options; }, getSyntacticDiagnostics: getSyntacticDiagnostics, + getOptionsDiagnostics: getOptionsDiagnostics, getGlobalDiagnostics: getGlobalDiagnostics, getSemanticDiagnostics: getSemanticDiagnostics, getDeclarationDiagnostics: getDeclarationDiagnostics, - getCompilerOptionsDiagnostics: getCompilerOptionsDiagnostics, getTypeChecker: getTypeChecker, + getClassifiableNames: getClassifiableNames, getDiagnosticsProducingTypeChecker: getDiagnosticsProducingTypeChecker, getCommonSourceDirectory: function () { return commonSourceDirectory; }, emit: emit, @@ -31153,6 +31569,18 @@ var ts; getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); } }; return program; + function getClassifiableNames() { + if (!classifiableNames) { + // Initialize a checker so that all our files are bound. + getTypeChecker(); + classifiableNames = {}; + for (var _i = 0; _i < files.length; _i++) { + var sourceFile = files[_i]; + ts.copyMap(sourceFile.classifiableNames, classifiableNames); + } + } + return classifiableNames; + } function getEmitHost(writeFileCallback) { return { getCanonicalFileName: function (fileName) { return host.getCanonicalFileName(fileName); }, @@ -31192,8 +31620,7 @@ var ts; return emitResult; } function getSourceFile(fileName) { - fileName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + return filesByName.get(fileName); } function getDiagnosticsHelper(sourceFile, getDiagnostics) { if (sourceFile) { @@ -31233,16 +31660,14 @@ var ts; return ts.getDeclarationDiagnostics(getEmitHost(writeFile), resolver, sourceFile); } } - function getCompilerOptionsDiagnostics() { + function getOptionsDiagnostics() { var allDiagnostics = []; ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); return ts.sortAndDeduplicateDiagnostics(allDiagnostics); } function getGlobalDiagnostics() { - var typeChecker = getDiagnosticsProducingTypeChecker(); var allDiagnostics = []; - ts.addRange(allDiagnostics, typeChecker.getGlobalDiagnostics()); - ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); + ts.addRange(allDiagnostics, getDiagnosticsProducingTypeChecker().getGlobalDiagnostics()); return ts.sortAndDeduplicateDiagnostics(allDiagnostics); } function hasExtension(fileName) { @@ -31276,14 +31701,17 @@ var ts; } } else { - if (options.allowNonTsExtensions && !findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd)) { - diagnostic = ts.Diagnostics.File_0_not_found; - diagnosticArgument = [fileName]; - } - else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, isDefaultLib, refFile, refPos, refEnd); })) { - diagnostic = ts.Diagnostics.File_0_not_found; - fileName += ".ts"; - diagnosticArgument = [fileName]; + var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd); + if (!nonTsFile) { + if (options.allowNonTsExtensions) { + diagnostic = ts.Diagnostics.File_0_not_found; + diagnosticArgument = [fileName]; + } + else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, isDefaultLib, refFile, refPos, refEnd); })) { + diagnostic = ts.Diagnostics.File_0_not_found; + fileName += ".ts"; + diagnosticArgument = [fileName]; + } } } if (diagnostic) { @@ -31298,18 +31726,18 @@ var ts; // Get source file from normalized fileName function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { var canonicalName = host.getCanonicalFileName(ts.normalizeSlashes(fileName)); - if (ts.hasProperty(filesByName, canonicalName)) { + if (filesByName.contains(canonicalName)) { // We've already looked for this file, use cached result return getSourceFileFromCache(fileName, canonicalName, false); } else { var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + if (filesByName.contains(canonicalAbsolutePath)) { return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); } // We haven't looked for this file, do so now and cache result - var file = filesByName[canonicalName] = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { + var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { if (refFile) { diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } @@ -31317,16 +31745,18 @@ var ts; diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); } }); + filesByName.set(canonicalName, file); if (file) { - seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; + skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib; // Set the source file for normalized absolute path - filesByName[canonicalAbsolutePath] = file; + filesByName.set(canonicalAbsolutePath, file); if (!options.noResolve) { var basePath = ts.getDirectoryPath(fileName); processReferencedFiles(file, basePath); processImportedModules(file, basePath); } if (isDefaultLib) { + file.isDefaultLib = true; files.unshift(file); } else { @@ -31336,7 +31766,7 @@ var ts; return file; } function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { - var file = filesByName[canonicalName]; + var file = filesByName.get(canonicalName); if (file && host.useCaseSensitiveFileNames()) { var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; if (canonicalName !== sourceFileName) { @@ -31354,7 +31784,7 @@ var ts; } function processImportedModules(file, basePath) { ts.forEach(file.statements, function (node) { - if (node.kind === 210 /* ImportDeclaration */ || node.kind === 209 /* ImportEqualsDeclaration */ || node.kind === 216 /* ExportDeclaration */) { + if (node.kind === 212 /* ImportDeclaration */ || node.kind === 211 /* ImportEqualsDeclaration */ || node.kind === 218 /* ExportDeclaration */) { var moduleNameExpr = ts.getExternalModuleName(node); if (moduleNameExpr && moduleNameExpr.kind === 8 /* StringLiteral */) { var moduleNameText = moduleNameExpr.text; @@ -31375,7 +31805,7 @@ var ts; } } } - else if (node.kind === 206 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */ && (node.flags & 2 /* Ambient */ || ts.isDeclarationFile(file))) { + else if (node.kind === 208 /* ModuleDeclaration */ && node.name.kind === 8 /* StringLiteral */ && (node.flags & 2 /* Ambient */ || ts.isDeclarationFile(file))) { // TypeScript 1.0 spec (April 2014): 12.1.6 // An AmbientExternalModuleDeclaration declares an external module. // This type of declaration is permitted only in the global module. @@ -31656,9 +32086,14 @@ var ts; name: "noResolve", type: "boolean" }, + { + name: "skipDefaultLibCheck", + type: "boolean" + }, { name: "out", type: "string", + isFilePath: true, description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file, paramType: ts.Diagnostics.FILE }, @@ -32033,7 +32468,7 @@ var ts; } } function autoCollapse(node) { - return ts.isFunctionBlock(node) && node.parent.kind !== 164 /* ArrowFunction */; + return ts.isFunctionBlock(node) && node.parent.kind !== 166 /* ArrowFunction */; } var depth = 0; var maxDepth = 20; @@ -32045,30 +32480,30 @@ var ts; addOutliningForLeadingCommentsForNode(n); } switch (n.kind) { - case 180 /* Block */: + case 182 /* Block */: if (!ts.isFunctionBlock(n)) { - var parent_7 = n.parent; + var parent_8 = n.parent; var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); // Check if the block is standalone, or 'attached' to some parent statement. // If the latter, we want to collaps the block, but consider its hint span // to be the entire span of the parent. - if (parent_7.kind === 185 /* DoStatement */ || - parent_7.kind === 188 /* ForInStatement */ || - parent_7.kind === 189 /* ForOfStatement */ || - parent_7.kind === 187 /* ForStatement */ || - parent_7.kind === 184 /* IfStatement */ || - parent_7.kind === 186 /* WhileStatement */ || - parent_7.kind === 193 /* WithStatement */ || - parent_7.kind === 224 /* CatchClause */) { - addOutliningSpan(parent_7, openBrace, closeBrace, autoCollapse(n)); + if (parent_8.kind === 187 /* DoStatement */ || + parent_8.kind === 190 /* ForInStatement */ || + parent_8.kind === 191 /* ForOfStatement */ || + parent_8.kind === 189 /* ForStatement */ || + parent_8.kind === 186 /* IfStatement */ || + parent_8.kind === 188 /* WhileStatement */ || + parent_8.kind === 195 /* WithStatement */ || + parent_8.kind === 226 /* CatchClause */) { + addOutliningSpan(parent_8, openBrace, closeBrace, autoCollapse(n)); break; } - if (parent_7.kind === 197 /* TryStatement */) { + if (parent_8.kind === 199 /* TryStatement */) { // Could be the try-block, or the finally-block. - var tryStatement = parent_7; + var tryStatement = parent_8; if (tryStatement.tryBlock === n) { - addOutliningSpan(parent_7, openBrace, closeBrace, autoCollapse(n)); + addOutliningSpan(parent_8, openBrace, closeBrace, autoCollapse(n)); break; } else if (tryStatement.finallyBlock === n) { @@ -32091,23 +32526,23 @@ var ts; break; } // Fallthrough. - case 207 /* ModuleBlock */: { + case 209 /* ModuleBlock */: { var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n)); break; } - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 155 /* ObjectLiteralExpression */: - case 208 /* CaseBlock */: { + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 157 /* ObjectLiteralExpression */: + case 210 /* CaseBlock */: { var openBrace = ts.findChildOfKind(n, 14 /* OpenBraceToken */, sourceFile); var closeBrace = ts.findChildOfKind(n, 15 /* CloseBraceToken */, sourceFile); addOutliningSpan(n, openBrace, closeBrace, autoCollapse(n)); break; } - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: var openBracket = ts.findChildOfKind(n, 18 /* OpenBracketToken */, sourceFile); var closeBracket = ts.findChildOfKind(n, 19 /* CloseBracketToken */, sourceFile); addOutliningSpan(n, openBracket, closeBracket, autoCollapse(n)); @@ -32135,12 +32570,12 @@ var ts; ts.forEach(program.getSourceFiles(), function (sourceFile) { cancellationToken.throwIfCancellationRequested(); var nameToDeclarations = sourceFile.getNamedDeclarations(); - for (var name_27 in nameToDeclarations) { - var declarations = ts.getProperty(nameToDeclarations, name_27); + for (var name_24 in nameToDeclarations) { + var declarations = ts.getProperty(nameToDeclarations, name_24); if (declarations) { // First do a quick check to see if the name of the declaration matches the // last portion of the (possibly) dotted name they're searching for. - var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name_27); + var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name_24); if (!matches) { continue; } @@ -32153,14 +32588,14 @@ var ts; if (!containers) { return undefined; } - matches = patternMatcher.getMatches(containers, name_27); + matches = patternMatcher.getMatches(containers, name_24); if (!matches) { continue; } } var fileName = sourceFile.fileName; var matchKind = bestMatchKind(matches); - rawItems.push({ name: name_27, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); + rawItems.push({ name: name_24, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); } } } @@ -32198,7 +32633,7 @@ var ts; if (text !== undefined) { containers.unshift(text); } - else if (declaration.name.kind === 128 /* ComputedPropertyName */) { + else if (declaration.name.kind === 129 /* ComputedPropertyName */) { return tryAddComputedPropertyName(declaration.name.expression, containers, true); } else { @@ -32219,7 +32654,7 @@ var ts; } return true; } - if (expression.kind === 156 /* PropertyAccessExpression */) { + if (expression.kind === 158 /* PropertyAccessExpression */) { var propertyAccess = expression; if (includeLastPortion) { containers.unshift(propertyAccess.name.text); @@ -32232,7 +32667,7 @@ var ts; var containers = []; // First, if we started with a computed property name, then add all but the last // portion into the container array. - if (declaration.name.kind === 128 /* ComputedPropertyName */) { + if (declaration.name.kind === 129 /* ComputedPropertyName */) { if (!tryAddComputedPropertyName(declaration.name.expression, containers, false)) { return undefined; } @@ -32308,17 +32743,17 @@ var ts; var current = node.parent; while (current) { switch (current.kind) { - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: // If we have a module declared as A.B.C, it is more "intuitive" // to say it only has a single layer of depth do { current = current.parent; - } while (current.kind === 206 /* ModuleDeclaration */); + } while (current.kind === 208 /* ModuleDeclaration */); // fall through - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 205 /* InterfaceDeclaration */: + case 203 /* FunctionDeclaration */: indent++; } current = current.parent; @@ -32329,21 +32764,21 @@ var ts; var childNodes = []; function visit(node) { switch (node.kind) { - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: ts.forEach(node.declarationList.declarations, visit); break; - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: ts.forEach(node.elements, visit); break; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: // Handle named exports case e.g.: // export {a, b as B} from "mod"; if (node.exportClause) { ts.forEach(node.exportClause.elements, visit); } break; - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: var importClause = node.importClause; if (importClause) { // Handle default import case e.g.: @@ -32355,7 +32790,7 @@ var ts; // import * as NS from "mod"; // import {a, b as B} from "mod"; if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 214 /* NamespaceImport */) { childNodes.push(importClause.namedBindings); } else { @@ -32364,21 +32799,21 @@ var ts; } } break; - case 153 /* BindingElement */: - case 199 /* VariableDeclaration */: + case 155 /* BindingElement */: + case 201 /* VariableDeclaration */: if (ts.isBindingPattern(node.name)) { visit(node.name); break; } // Fall through - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: - case 206 /* ModuleDeclaration */: - case 201 /* FunctionDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 218 /* ExportSpecifier */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 205 /* InterfaceDeclaration */: + case 208 /* ModuleDeclaration */: + case 203 /* FunctionDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 216 /* ImportSpecifier */: + case 220 /* ExportSpecifier */: childNodes.push(node); break; } @@ -32426,17 +32861,17 @@ var ts; for (var _i = 0; _i < nodes.length; _i++) { var node = nodes[_i]; switch (node.kind) { - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 205 /* InterfaceDeclaration */: topLevelNodes.push(node); break; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: var moduleDeclaration = node; topLevelNodes.push(node); addTopLevelNodes(getInnermostModule(moduleDeclaration).body.statements, topLevelNodes); break; - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: var functionDeclaration = node; if (isTopLevelFunctionDeclaration(functionDeclaration)) { topLevelNodes.push(node); @@ -32447,12 +32882,12 @@ var ts; } } function isTopLevelFunctionDeclaration(functionDeclaration) { - if (functionDeclaration.kind === 201 /* FunctionDeclaration */) { + if (functionDeclaration.kind === 203 /* FunctionDeclaration */) { // A function declaration is 'top level' if it contains any function declarations // within it. - if (functionDeclaration.body && functionDeclaration.body.kind === 180 /* Block */) { + if (functionDeclaration.body && functionDeclaration.body.kind === 182 /* Block */) { // Proper function declarations can only have identifier names - if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 201 /* FunctionDeclaration */ && !isEmpty(s.name.text); })) { + if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 203 /* FunctionDeclaration */ && !isEmpty(s.name.text); })) { return true; } // Or if it is not parented by another function. i.e all functions @@ -32512,7 +32947,7 @@ var ts; } function createChildItem(node) { switch (node.kind) { - case 130 /* Parameter */: + case 131 /* Parameter */: if (ts.isBindingPattern(node.name)) { break; } @@ -32520,36 +32955,36 @@ var ts; return undefined; } return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); - case 137 /* GetAccessor */: + case 138 /* GetAccessor */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); - case 138 /* SetAccessor */: + case 139 /* SetAccessor */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); - case 227 /* EnumMember */: + case 229 /* EnumMember */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 139 /* CallSignature */: + case 140 /* CallSignature */: return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); - case 140 /* ConstructSignature */: + case 141 /* ConstructSignature */: return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.functionElement); - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: var variableDeclarationNode; - var name_28; - if (node.kind === 153 /* BindingElement */) { - name_28 = node.name; + var name_25; + if (node.kind === 155 /* BindingElement */) { + name_25 = node.name; variableDeclarationNode = node; // binding elements are added only for variable declarations // bubble up to the containing variable declaration - while (variableDeclarationNode && variableDeclarationNode.kind !== 199 /* VariableDeclaration */) { + while (variableDeclarationNode && variableDeclarationNode.kind !== 201 /* VariableDeclaration */) { variableDeclarationNode = variableDeclarationNode.parent; } ts.Debug.assert(variableDeclarationNode !== undefined); @@ -32557,24 +32992,24 @@ var ts; else { ts.Debug.assert(!ts.isBindingPattern(node.name)); variableDeclarationNode = node; - name_28 = node.name; + name_25 = node.name; } if (ts.isConst(variableDeclarationNode)) { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.constElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.constElement); } else if (ts.isLet(variableDeclarationNode)) { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.letElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.letElement); } else { - return createItem(node, getTextOfNode(name_28), ts.ScriptElementKind.variableElement); + return createItem(node, getTextOfNode(name_25), ts.ScriptElementKind.variableElement); } - case 136 /* Constructor */: + case 137 /* Constructor */: return createItem(node, "constructor", ts.ScriptElementKind.constructorImplementationElement); - case 218 /* ExportSpecifier */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: + case 220 /* ExportSpecifier */: + case 216 /* ImportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 213 /* ImportClause */: + case 214 /* NamespaceImport */: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.alias); } return undefined; @@ -32604,17 +33039,17 @@ var ts; } function createTopLevelItem(node) { switch (node.kind) { - case 228 /* SourceFile */: + case 230 /* SourceFile */: return createSourceFileItem(node); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: return createClassItem(node); - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: return createEnumItem(node); - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return createIterfaceItem(node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return createModuleItem(node); - case 201 /* FunctionDeclaration */: + case 203 /* FunctionDeclaration */: return createFunctionItem(node); } return undefined; @@ -32626,7 +33061,7 @@ var ts; // Otherwise, we need to aggregate each identifier to build up the qualified name. var result = []; result.push(moduleDeclaration.name.text); - while (moduleDeclaration.body && moduleDeclaration.body.kind === 206 /* ModuleDeclaration */) { + while (moduleDeclaration.body && moduleDeclaration.body.kind === 208 /* ModuleDeclaration */) { moduleDeclaration = moduleDeclaration.body; result.push(moduleDeclaration.name.text); } @@ -32638,7 +33073,7 @@ var ts; return getNavigationBarItem(moduleName, ts.ScriptElementKind.moduleElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } function createFunctionItem(node) { - if (node.body && node.body.kind === 180 /* Block */) { + if (node.body && node.body.kind === 182 /* Block */) { var childItems = getItemsWorker(sortNodes(node.body.statements), createChildItem); return getNavigationBarItem(!node.name ? "default" : node.name.text, ts.ScriptElementKind.functionElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } @@ -32659,7 +33094,7 @@ var ts; var childItems; if (node.members) { var constructor = ts.forEach(node.members, function (member) { - return member.kind === 136 /* Constructor */ && member; + return member.kind === 137 /* Constructor */ && member; }); // Add the constructor parameters in as children of the class (for property parameters). // Note that *all non-binding pattern named* parameters will be added to the nodes array, but parameters that @@ -32683,7 +33118,7 @@ var ts; } } function removeComputedProperties(node) { - return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 128 /* ComputedPropertyName */; }); + return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 129 /* ComputedPropertyName */; }); } /** * Like removeComputedProperties, but retains the properties with well known symbol names @@ -32692,13 +33127,13 @@ var ts; return ts.filter(node.members, function (member) { return !ts.hasDynamicName(member); }); } function getInnermostModule(node) { - while (node.body.kind === 206 /* ModuleDeclaration */) { + while (node.body.kind === 208 /* ModuleDeclaration */) { node = node.body; } return node; } function getNodeSpan(node) { - return node.kind === 228 /* SourceFile */ + return node.kind === 230 /* SourceFile */ ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); } @@ -33213,7 +33648,7 @@ var ts; var hasTransitionFromUpperToLower = transitionFromUpperToLower(identifier, word, i, wordStart); if (charIsPunctuation(identifier.charCodeAt(i - 1)) || charIsPunctuation(identifier.charCodeAt(i)) || - lastIsDigit != currentIsDigit || + lastIsDigit !== currentIsDigit || hasTransitionFromLowerToUpper || hasTransitionFromUpperToLower) { if (!isAllPunctuation(identifier, wordStart, i)) { @@ -33274,7 +33709,7 @@ var ts; // 3) HTMLDocument -> HTML, Document // // etc. - if (index != wordStart && + if (index !== wordStart && index + 1 < identifier.length) { var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index)); var nextIsLower = isLowerCaseLetter(identifier.charCodeAt(index + 1)); @@ -33493,7 +33928,7 @@ var ts; } return createSignatureHelpItems(candidates, resolvedSignature, argumentInfo); function createJavaScriptSignatureHelpItems(argumentInfo) { - if (argumentInfo.invocation.kind !== 158 /* CallExpression */) { + if (argumentInfo.invocation.kind !== 160 /* CallExpression */) { return undefined; } // See if we can find some symbol with the call expression name that has call signatures. @@ -33501,7 +33936,7 @@ var ts; var expression = callExpression.expression; var name = expression.kind === 65 /* Identifier */ ? expression - : expression.kind === 156 /* PropertyAccessExpression */ + : expression.kind === 158 /* PropertyAccessExpression */ ? expression.name : undefined; if (!name || !name.text) { @@ -33534,7 +33969,7 @@ var ts; * in the argument of an invocation; returns undefined otherwise. */ function getImmediatelyContainingArgumentInfo(node) { - if (node.parent.kind === 158 /* CallExpression */ || node.parent.kind === 159 /* NewExpression */) { + if (node.parent.kind === 160 /* CallExpression */ || node.parent.kind === 161 /* NewExpression */) { var callExpression = node.parent; // There are 3 cases to handle: // 1. The token introduces a list, and should begin a sig help session @@ -33587,25 +34022,25 @@ var ts; }; } } - else if (node.kind === 10 /* NoSubstitutionTemplateLiteral */ && node.parent.kind === 160 /* TaggedTemplateExpression */) { + else if (node.kind === 10 /* NoSubstitutionTemplateLiteral */ && node.parent.kind === 162 /* TaggedTemplateExpression */) { // Check if we're actually inside the template; // otherwise we'll fall out and return undefined. if (ts.isInsideTemplateLiteral(node, position)) { return getArgumentListInfoForTemplate(node.parent, 0); } } - else if (node.kind === 11 /* TemplateHead */ && node.parent.parent.kind === 160 /* TaggedTemplateExpression */) { + else if (node.kind === 11 /* TemplateHead */ && node.parent.parent.kind === 162 /* TaggedTemplateExpression */) { var templateExpression = node.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 172 /* TemplateExpression */); + ts.Debug.assert(templateExpression.kind === 174 /* TemplateExpression */); var argumentIndex = ts.isInsideTemplateLiteral(node, position) ? 0 : 1; return getArgumentListInfoForTemplate(tagExpression, argumentIndex); } - else if (node.parent.kind === 178 /* TemplateSpan */ && node.parent.parent.parent.kind === 160 /* TaggedTemplateExpression */) { + else if (node.parent.kind === 180 /* TemplateSpan */ && node.parent.parent.parent.kind === 162 /* TaggedTemplateExpression */) { var templateSpan = node.parent; var templateExpression = templateSpan.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 172 /* TemplateExpression */); + ts.Debug.assert(templateExpression.kind === 174 /* TemplateExpression */); // If we're just after a template tail, don't show signature help. if (node.kind === 13 /* TemplateTail */ && !ts.isInsideTemplateLiteral(node, position)) { return undefined; @@ -33723,7 +34158,7 @@ var ts; // // This is because a Missing node has no width. However, what we actually want is to include trivia // leading up to the next token in case the user is about to type in a TemplateMiddle or TemplateTail. - if (template.kind === 172 /* TemplateExpression */) { + if (template.kind === 174 /* TemplateExpression */) { var lastSpan = ts.lastOrUndefined(template.templateSpans); if (lastSpan.literal.getFullWidth() === 0) { applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, false); @@ -33732,7 +34167,7 @@ var ts; return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); } function getContainingArgumentInfo(node) { - for (var n = node; n.kind !== 228 /* SourceFile */; n = n.parent) { + for (var n = node; n.kind !== 230 /* SourceFile */; n = n.parent) { if (ts.isFunctionBlock(n)) { return undefined; } @@ -33933,40 +34368,40 @@ var ts; return false; } switch (n.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 155 /* ObjectLiteralExpression */: - case 151 /* ObjectBindingPattern */: - case 146 /* TypeLiteral */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 208 /* CaseBlock */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 157 /* ObjectLiteralExpression */: + case 153 /* ObjectBindingPattern */: + case 148 /* TypeLiteral */: + case 182 /* Block */: + case 209 /* ModuleBlock */: + case 210 /* CaseBlock */: return nodeEndsWith(n, 15 /* CloseBraceToken */, sourceFile); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return isCompletedNode(n.block, sourceFile); - case 159 /* NewExpression */: + case 161 /* NewExpression */: if (!n.arguments) { return true; } // fall through - case 158 /* CallExpression */: - case 162 /* ParenthesizedExpression */: - case 150 /* ParenthesizedType */: + case 160 /* CallExpression */: + case 164 /* ParenthesizedExpression */: + case 152 /* ParenthesizedType */: return nodeEndsWith(n, 17 /* CloseParenToken */, sourceFile); - case 143 /* FunctionType */: - case 144 /* ConstructorType */: + case 145 /* FunctionType */: + case 146 /* ConstructorType */: return isCompletedNode(n.type, sourceFile); - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 140 /* ConstructSignature */: - case 139 /* CallSignature */: - case 164 /* ArrowFunction */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 141 /* ConstructSignature */: + case 140 /* CallSignature */: + case 166 /* ArrowFunction */: if (n.body) { return isCompletedNode(n.body, sourceFile); } @@ -33976,63 +34411,63 @@ var ts; // Even though type parameters can be unclosed, we can get away with // having at least a closing paren. return hasChildOfKind(n, 17 /* CloseParenToken */, sourceFile); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: return n.body && isCompletedNode(n.body, sourceFile); - case 184 /* IfStatement */: + case 186 /* IfStatement */: if (n.elseStatement) { return isCompletedNode(n.elseStatement, sourceFile); } return isCompletedNode(n.thenStatement, sourceFile); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: return isCompletedNode(n.expression, sourceFile); - case 154 /* ArrayLiteralExpression */: - case 152 /* ArrayBindingPattern */: - case 157 /* ElementAccessExpression */: - case 128 /* ComputedPropertyName */: - case 148 /* TupleType */: + case 156 /* ArrayLiteralExpression */: + case 154 /* ArrayBindingPattern */: + case 159 /* ElementAccessExpression */: + case 129 /* ComputedPropertyName */: + case 150 /* TupleType */: return nodeEndsWith(n, 19 /* CloseBracketToken */, sourceFile); - case 141 /* IndexSignature */: + case 142 /* IndexSignature */: if (n.type) { return isCompletedNode(n.type, sourceFile); } return hasChildOfKind(n, 19 /* CloseBracketToken */, sourceFile); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: // there is no such thing as terminator token for CaseClause/DefaultClause so for simplicitly always consider them non-completed return false; - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 188 /* WhileStatement */: return isCompletedNode(n.statement, sourceFile); - case 185 /* DoStatement */: + case 187 /* DoStatement */: // rough approximation: if DoStatement has While keyword - then if node is completed is checking the presence of ')'; var hasWhileKeyword = findChildOfKind(n, 100 /* WhileKeyword */, sourceFile); if (hasWhileKeyword) { return nodeEndsWith(n, 17 /* CloseParenToken */, sourceFile); } return isCompletedNode(n.statement, sourceFile); - case 145 /* TypeQuery */: + case 147 /* TypeQuery */: return isCompletedNode(n.exprName, sourceFile); - case 166 /* TypeOfExpression */: - case 165 /* DeleteExpression */: - case 167 /* VoidExpression */: - case 173 /* YieldExpression */: - case 174 /* SpreadElementExpression */: + case 168 /* TypeOfExpression */: + case 167 /* DeleteExpression */: + case 169 /* VoidExpression */: + case 175 /* YieldExpression */: + case 176 /* SpreadElementExpression */: var unaryWordExpression = n; return isCompletedNode(unaryWordExpression.expression, sourceFile); - case 160 /* TaggedTemplateExpression */: + case 162 /* TaggedTemplateExpression */: return isCompletedNode(n.template, sourceFile); - case 172 /* TemplateExpression */: + case 174 /* TemplateExpression */: var lastSpan = ts.lastOrUndefined(n.templateSpans); return isCompletedNode(lastSpan, sourceFile); - case 178 /* TemplateSpan */: + case 180 /* TemplateSpan */: return ts.nodeIsPresent(n.literal); - case 168 /* PrefixUnaryExpression */: + case 170 /* PrefixUnaryExpression */: return isCompletedNode(n.operand, sourceFile); - case 170 /* BinaryExpression */: + case 172 /* BinaryExpression */: return isCompletedNode(n.right, sourceFile); - case 171 /* ConditionalExpression */: + case 173 /* ConditionalExpression */: return isCompletedNode(n.whenFalse, sourceFile); default: return true; @@ -34088,7 +34523,7 @@ var ts; // for the position of the relevant node (or comma). var syntaxList = ts.forEach(node.parent.getChildren(), function (c) { // find syntax list that covers the span of the node - if (c.kind === 251 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) { + if (c.kind === 253 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) { return c; } }); @@ -34222,7 +34657,7 @@ var ts; } } } - ts.Debug.assert(startNode !== undefined || n.kind === 228 /* SourceFile */); + ts.Debug.assert(startNode !== undefined || n.kind === 230 /* SourceFile */); // Here we know that none of child token nodes embrace the position, // the only known case is when position is at the end of the file. // Try to find the rightmost token in the file without filtering. @@ -34266,17 +34701,17 @@ var ts; } ts.getNodeModifiers = getNodeModifiers; function getTypeArgumentOrTypeParameterList(node) { - if (node.kind === 142 /* TypeReference */ || node.kind === 158 /* CallExpression */) { + if (node.kind === 144 /* TypeReference */ || node.kind === 160 /* CallExpression */) { return node.typeArguments; } - if (ts.isFunctionLike(node) || node.kind === 202 /* ClassDeclaration */ || node.kind === 203 /* InterfaceDeclaration */) { + if (ts.isFunctionLike(node) || node.kind === 204 /* ClassDeclaration */ || node.kind === 205 /* InterfaceDeclaration */) { return node.typeParameters; } return undefined; } ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList; function isToken(n) { - return n.kind >= 0 /* FirstToken */ && n.kind <= 126 /* LastToken */; + return n.kind >= 0 /* FirstToken */ && n.kind <= 127 /* LastToken */; } ts.isToken = isToken; function isWord(kind) { @@ -34331,7 +34766,7 @@ var ts; var ts; (function (ts) { function isFirstDeclarationOfSymbolParameter(symbol) { - return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 130 /* Parameter */; + return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 131 /* Parameter */; } ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter; var displayPartWriter = getDisplayPartWriter(); @@ -34744,7 +35179,7 @@ var ts; if (this.tokensAreOnSameLine === undefined) { var startLine = this.sourceFile.getLineAndCharacterOfPosition(this.currentTokenSpan.pos).line; var endLine = this.sourceFile.getLineAndCharacterOfPosition(this.nextTokenSpan.pos).line; - this.tokensAreOnSameLine = (startLine == endLine); + this.tokensAreOnSameLine = (startLine === endLine); } return this.tokensAreOnSameLine; }; @@ -34763,7 +35198,7 @@ var ts; FormattingContext.prototype.NodeIsOnOneLine = function (node) { var startLine = this.sourceFile.getLineAndCharacterOfPosition(node.getStart(this.sourceFile)).line; var endLine = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line; - return startLine == endLine; + return startLine === endLine; }; FormattingContext.prototype.BlockIsOnOneLine = function (node) { var openBrace = ts.findChildOfKind(node, 14 /* OpenBraceToken */, this.sourceFile); @@ -34923,7 +35358,7 @@ var ts; this.customContextChecks = funcs; } RuleOperationContext.prototype.IsAny = function () { - return this == RuleOperationContext.Any; + return this === RuleOperationContext.Any; }; RuleOperationContext.prototype.InContext = function (context) { if (this.IsAny()) { @@ -35029,7 +35464,7 @@ var ts; this.SpaceAfterTryFinally = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([96 /* TryKeyword */, 81 /* FinallyKeyword */]), 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); // get x() {} // set x(val) {} - this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116 /* GetKeyword */, 121 /* SetKeyword */]), 65 /* Identifier */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */)); + this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116 /* GetKeyword */, 122 /* SetKeyword */]), 65 /* Identifier */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2 /* Space */)); // Special case for binary operators (that are keywords). For these we have to add a space and shouldn't follow any user options. this.SpaceBeforeBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryKeywordOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); this.SpaceAfterBinaryKeywordOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryKeywordOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2 /* Space */)); @@ -35037,9 +35472,9 @@ var ts; // Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses this.NoSpaceAfterConstructor = new formatting.Rule(formatting.RuleDescriptor.create1(114 /* ConstructorKeyword */, 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); // Use of module as a function call. e.g.: import m2 = module("m2"); - this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([117 /* ModuleKeyword */, 119 /* RequireKeyword */]), 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); + this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([118 /* ModuleKeyword */, 120 /* RequireKeyword */]), 16 /* OpenParenToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); // Add a space around certain TypeScript keywords - this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([69 /* ClassKeyword */, 115 /* DeclareKeyword */, 77 /* EnumKeyword */, 78 /* ExportKeyword */, 79 /* ExtendsKeyword */, 116 /* GetKeyword */, 102 /* ImplementsKeyword */, 85 /* ImportKeyword */, 103 /* InterfaceKeyword */, 117 /* ModuleKeyword */, 118 /* NamespaceKeyword */, 106 /* PrivateKeyword */, 108 /* PublicKeyword */, 121 /* SetKeyword */, 109 /* StaticKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); + this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([69 /* ClassKeyword */, 115 /* DeclareKeyword */, 77 /* EnumKeyword */, 78 /* ExportKeyword */, 79 /* ExtendsKeyword */, 116 /* GetKeyword */, 102 /* ImplementsKeyword */, 85 /* ImportKeyword */, 103 /* InterfaceKeyword */, 118 /* ModuleKeyword */, 119 /* NamespaceKeyword */, 106 /* PrivateKeyword */, 108 /* PublicKeyword */, 122 /* SetKeyword */, 109 /* StaticKeyword */]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); this.SpaceBeforeCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([79 /* ExtendsKeyword */, 102 /* ImplementsKeyword */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { this.SpaceAfterModuleName = new formatting.Rule(formatting.RuleDescriptor.create1(8 /* StringLiteral */, 14 /* OpenBraceToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsModuleDeclContext), 2 /* Space */)); @@ -35059,7 +35494,7 @@ var ts; // decorators this.SpaceBeforeAt = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 52 /* AtToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2 /* Space */)); this.NoSpaceAfterAt = new formatting.Rule(formatting.RuleDescriptor.create3(52 /* AtToken */, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8 /* Delete */)); - this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([65 /* Identifier */, 78 /* ExportKeyword */, 73 /* DefaultKeyword */, 69 /* ClassKeyword */, 109 /* StaticKeyword */, 108 /* PublicKeyword */, 106 /* PrivateKeyword */, 107 /* ProtectedKeyword */, 116 /* GetKeyword */, 121 /* SetKeyword */, 18 /* OpenBracketToken */, 35 /* AsteriskToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2 /* Space */)); + this.SpaceAfterDecorator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.FromTokens([65 /* Identifier */, 78 /* ExportKeyword */, 73 /* DefaultKeyword */, 69 /* ClassKeyword */, 109 /* StaticKeyword */, 108 /* PublicKeyword */, 106 /* PrivateKeyword */, 107 /* ProtectedKeyword */, 116 /* GetKeyword */, 122 /* SetKeyword */, 18 /* OpenBracketToken */, 35 /* AsteriskToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), 2 /* Space */)); this.NoSpaceBetweenFunctionKeywordAndStar = new formatting.Rule(formatting.RuleDescriptor.create1(83 /* FunctionKeyword */, 35 /* AsteriskToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), 8 /* Delete */)); this.SpaceAfterStarInGeneratorDeclaration = new formatting.Rule(formatting.RuleDescriptor.create3(35 /* AsteriskToken */, formatting.Shared.TokenRange.FromTokens([65 /* Identifier */, 16 /* OpenParenToken */])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), 2 /* Space */)); this.NoSpaceBetweenYieldKeywordAndStar = new formatting.Rule(formatting.RuleDescriptor.create1(110 /* YieldKeyword */, 35 /* AsteriskToken */), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), 8 /* Delete */)); @@ -35155,9 +35590,9 @@ var ts; } Rules.prototype.getRuleName = function (rule) { var o = this; - for (var name_29 in o) { - if (o[name_29] === rule) { - return name_29; + for (var name_26 in o) { + if (o[name_26] === rule) { + return name_26; } } throw new Error("Unknown rule"); @@ -35166,36 +35601,37 @@ var ts; /// Contexts /// Rules.IsForContext = function (context) { - return context.contextNode.kind === 187 /* ForStatement */; + return context.contextNode.kind === 189 /* ForStatement */; }; Rules.IsNotForContext = function (context) { return !Rules.IsForContext(context); }; Rules.IsBinaryOpContext = function (context) { switch (context.contextNode.kind) { - case 170 /* BinaryExpression */: - case 171 /* ConditionalExpression */: + case 172 /* BinaryExpression */: + case 173 /* ConditionalExpression */: + case 143 /* TypePredicate */: return true; // equals in binding elements: function foo([[x, y] = [1, 2]]) - case 153 /* BindingElement */: + case 155 /* BindingElement */: // equals in type X = ... - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: // equal in import a = module('a'); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: // equal in let a = 0; - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: // equal in p = 0; - case 130 /* Parameter */: - case 227 /* EnumMember */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 131 /* Parameter */: + case 229 /* EnumMember */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return context.currentTokenSpan.kind === 53 /* EqualsToken */ || context.nextTokenSpan.kind === 53 /* EqualsToken */; // "in" keyword in for (let x in []) { } - case 188 /* ForInStatement */: + case 190 /* ForInStatement */: return context.currentTokenSpan.kind === 86 /* InKeyword */ || context.nextTokenSpan.kind === 86 /* InKeyword */; // Technically, "of" is not a binary operator, but format it the same way as "in" - case 189 /* ForOfStatement */: - return context.currentTokenSpan.kind === 126 /* OfKeyword */ || context.nextTokenSpan.kind === 126 /* OfKeyword */; + case 191 /* ForOfStatement */: + return context.currentTokenSpan.kind === 127 /* OfKeyword */ || context.nextTokenSpan.kind === 127 /* OfKeyword */; } return false; }; @@ -35203,7 +35639,7 @@ var ts; return !Rules.IsBinaryOpContext(context); }; Rules.IsConditionalOperatorContext = function (context) { - return context.contextNode.kind === 171 /* ConditionalExpression */; + return context.contextNode.kind === 173 /* ConditionalExpression */; }; Rules.IsSameLineTokenOrBeforeMultilineBlockContext = function (context) { //// This check is mainly used inside SpaceBeforeOpenBraceInControl and SpaceBeforeOpenBraceInFunction. @@ -35247,92 +35683,92 @@ var ts; return true; } switch (node.kind) { - case 180 /* Block */: - case 208 /* CaseBlock */: - case 155 /* ObjectLiteralExpression */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 210 /* CaseBlock */: + case 157 /* ObjectLiteralExpression */: + case 209 /* ModuleBlock */: return true; } return false; }; Rules.IsFunctionDeclContext = function (context) { switch (context.contextNode.kind) { - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: //case SyntaxKind.MemberFunctionDeclaration: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: ///case SyntaxKind.MethodSignature: - case 139 /* CallSignature */: - case 163 /* FunctionExpression */: - case 136 /* Constructor */: - case 164 /* ArrowFunction */: + case 140 /* CallSignature */: + case 165 /* FunctionExpression */: + case 137 /* Constructor */: + case 166 /* ArrowFunction */: //case SyntaxKind.ConstructorDeclaration: //case SyntaxKind.SimpleArrowFunctionExpression: //case SyntaxKind.ParenthesizedArrowFunctionExpression: - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: return true; } return false; }; Rules.IsFunctionDeclarationOrFunctionExpressionContext = function (context) { - return context.contextNode.kind === 201 /* FunctionDeclaration */ || context.contextNode.kind === 163 /* FunctionExpression */; + return context.contextNode.kind === 203 /* FunctionDeclaration */ || context.contextNode.kind === 165 /* FunctionExpression */; }; Rules.IsTypeScriptDeclWithBlockContext = function (context) { return Rules.NodeIsTypeScriptDeclWithBlockContext(context.contextNode); }; Rules.NodeIsTypeScriptDeclWithBlockContext = function (node) { switch (node.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 146 /* TypeLiteral */: - case 206 /* ModuleDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 148 /* TypeLiteral */: + case 208 /* ModuleDeclaration */: return true; } return false; }; Rules.IsAfterCodeBlockContext = function (context) { switch (context.currentTokenParent.kind) { - case 202 /* ClassDeclaration */: - case 206 /* ModuleDeclaration */: - case 205 /* EnumDeclaration */: - case 180 /* Block */: - case 224 /* CatchClause */: - case 207 /* ModuleBlock */: - case 194 /* SwitchStatement */: + case 204 /* ClassDeclaration */: + case 208 /* ModuleDeclaration */: + case 207 /* EnumDeclaration */: + case 182 /* Block */: + case 226 /* CatchClause */: + case 209 /* ModuleBlock */: + case 196 /* SwitchStatement */: return true; } return false; }; Rules.IsControlDeclContext = function (context) { switch (context.contextNode.kind) { - case 184 /* IfStatement */: - case 194 /* SwitchStatement */: - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: - case 197 /* TryStatement */: - case 185 /* DoStatement */: - case 193 /* WithStatement */: + case 186 /* IfStatement */: + case 196 /* SwitchStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 188 /* WhileStatement */: + case 199 /* TryStatement */: + case 187 /* DoStatement */: + case 195 /* WithStatement */: // TODO // case SyntaxKind.ElseClause: - case 224 /* CatchClause */: + case 226 /* CatchClause */: return true; default: return false; } }; Rules.IsObjectContext = function (context) { - return context.contextNode.kind === 155 /* ObjectLiteralExpression */; + return context.contextNode.kind === 157 /* ObjectLiteralExpression */; }; Rules.IsFunctionCallContext = function (context) { - return context.contextNode.kind === 158 /* CallExpression */; + return context.contextNode.kind === 160 /* CallExpression */; }; Rules.IsNewContext = function (context) { - return context.contextNode.kind === 159 /* NewExpression */; + return context.contextNode.kind === 161 /* NewExpression */; }; Rules.IsFunctionCallOrNewContext = function (context) { return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context); @@ -35356,38 +35792,38 @@ var ts; while (ts.isExpression(node)) { node = node.parent; } - return node.kind === 131 /* Decorator */; + return node.kind === 132 /* Decorator */; }; Rules.IsStartOfVariableDeclarationList = function (context) { - return context.currentTokenParent.kind === 200 /* VariableDeclarationList */ && + return context.currentTokenParent.kind === 202 /* VariableDeclarationList */ && context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos; }; Rules.IsNotFormatOnEnter = function (context) { - return context.formattingRequestKind != 2 /* FormatOnEnter */; + return context.formattingRequestKind !== 2 /* FormatOnEnter */; }; Rules.IsModuleDeclContext = function (context) { - return context.contextNode.kind === 206 /* ModuleDeclaration */; + return context.contextNode.kind === 208 /* ModuleDeclaration */; }; Rules.IsObjectTypeContext = function (context) { - return context.contextNode.kind === 146 /* TypeLiteral */; // && context.contextNode.parent.kind !== SyntaxKind.InterfaceDeclaration; + return context.contextNode.kind === 148 /* TypeLiteral */; // && context.contextNode.parent.kind !== SyntaxKind.InterfaceDeclaration; }; Rules.IsTypeArgumentOrParameter = function (token, parent) { if (token.kind !== 24 /* LessThanToken */ && token.kind !== 25 /* GreaterThanToken */) { return false; } switch (parent.kind) { - case 142 /* TypeReference */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 144 /* TypeReference */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: return true; default: return false; @@ -35398,10 +35834,10 @@ var ts; Rules.IsTypeArgumentOrParameter(context.nextTokenSpan, context.nextTokenParent); }; Rules.IsVoidOpContext = function (context) { - return context.currentTokenSpan.kind === 99 /* VoidKeyword */ && context.currentTokenParent.kind === 167 /* VoidExpression */; + return context.currentTokenSpan.kind === 99 /* VoidKeyword */ && context.currentTokenParent.kind === 169 /* VoidExpression */; }; Rules.IsYieldOrYieldStarWithOperand = function (context) { - return context.contextNode.kind === 173 /* YieldExpression */ && context.contextNode.expression !== undefined; + return context.contextNode.kind === 175 /* YieldExpression */ && context.contextNode.expression !== undefined; }; return Rules; })(); @@ -35425,7 +35861,7 @@ var ts; return result; }; RulesMap.prototype.Initialize = function (rules) { - this.mapRowLength = 126 /* LastToken */ + 1; + this.mapRowLength = 127 /* LastToken */ + 1; this.map = new Array(this.mapRowLength * this.mapRowLength); //new Array(this.mapRowLength * this.mapRowLength); // This array is used only during construction of the rulesbucket in the map var rulesBucketConstructionStateList = new Array(this.map.length); //new Array(this.map.length); @@ -35445,13 +35881,13 @@ var ts; }; RulesMap.prototype.FillRule = function (rule, rulesBucketConstructionStateList) { var _this = this; - var specificRule = rule.Descriptor.LeftTokenRange != formatting.Shared.TokenRange.Any && - rule.Descriptor.RightTokenRange != formatting.Shared.TokenRange.Any; + var specificRule = rule.Descriptor.LeftTokenRange !== formatting.Shared.TokenRange.Any && + rule.Descriptor.RightTokenRange !== formatting.Shared.TokenRange.Any; rule.Descriptor.LeftTokenRange.GetTokens().forEach(function (left) { rule.Descriptor.RightTokenRange.GetTokens().forEach(function (right) { var rulesBucketIndex = _this.GetRuleBucketIndex(left, right); var rulesBucket = _this.map[rulesBucketIndex]; - if (rulesBucket == undefined) { + if (rulesBucket === undefined) { rulesBucket = _this.map[rulesBucketIndex] = new RulesBucket(); } rulesBucket.AddRule(rule, specificRule, rulesBucketConstructionStateList, rulesBucketIndex); @@ -35518,7 +35954,7 @@ var ts; RulesBucketConstructionState.prototype.IncreaseInsertionIndex = function (maskPosition) { var value = (this.rulesInsertionIndexBitmap >> maskPosition) & Mask; value++; - ts.Debug.assert((value & Mask) == value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules."); + ts.Debug.assert((value & Mask) === value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules."); var temp = this.rulesInsertionIndexBitmap & ~(Mask << maskPosition); temp |= value << maskPosition; this.rulesInsertionIndexBitmap = temp; @@ -35535,7 +35971,7 @@ var ts; }; RulesBucket.prototype.AddRule = function (rule, specificTokens, constructionState, rulesBucketIndex) { var position; - if (rule.Operation.Action == 1 /* Ignore */) { + if (rule.Operation.Action === 1 /* Ignore */) { position = specificTokens ? RulesPosition.IgnoreRulesSpecific : RulesPosition.IgnoreRulesAny; @@ -35610,7 +36046,7 @@ var ts; return [this.token]; }; TokenSingleValueAccess.prototype.Contains = function (tokenValue) { - return tokenValue == this.token; + return tokenValue === this.token; }; return TokenSingleValueAccess; })(); @@ -35620,7 +36056,7 @@ var ts; } TokenAllAccess.prototype.GetTokens = function () { var result = []; - for (var token = 0 /* FirstToken */; token <= 126 /* LastToken */; token++) { + for (var token = 0 /* FirstToken */; token <= 127 /* LastToken */; token++) { result.push(token); } return result; @@ -35662,9 +36098,9 @@ var ts; }; TokenRange.Any = TokenRange.AllTokens(); TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3 /* MultiLineCommentTrivia */])); - TokenRange.Keywords = TokenRange.FromRange(66 /* FirstKeyword */, 126 /* LastKeyword */); + TokenRange.Keywords = TokenRange.FromRange(66 /* FirstKeyword */, 127 /* LastKeyword */); TokenRange.BinaryOperators = TokenRange.FromRange(24 /* FirstBinaryOperator */, 64 /* LastBinaryOperator */); - TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([86 /* InKeyword */, 87 /* InstanceOfKeyword */, 126 /* OfKeyword */]); + TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([86 /* InKeyword */, 87 /* InstanceOfKeyword */, 127 /* OfKeyword */, 117 /* IsKeyword */]); TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([38 /* PlusPlusToken */, 39 /* MinusMinusToken */, 47 /* TildeToken */, 46 /* ExclamationToken */]); TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([7 /* NumericLiteral */, 65 /* Identifier */, 16 /* OpenParenToken */, 18 /* OpenBracketToken */, 14 /* OpenBraceToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 16 /* OpenParenToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); @@ -35672,7 +36108,7 @@ var ts; TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 16 /* OpenParenToken */, 93 /* ThisKeyword */, 88 /* NewKeyword */]); TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([65 /* Identifier */, 17 /* CloseParenToken */, 19 /* CloseBracketToken */, 88 /* NewKeyword */]); TokenRange.Comments = TokenRange.FromTokens([2 /* SingleLineCommentTrivia */, 3 /* MultiLineCommentTrivia */]); - TokenRange.TypeNames = TokenRange.FromTokens([65 /* Identifier */, 120 /* NumberKeyword */, 122 /* StringKeyword */, 113 /* BooleanKeyword */, 123 /* SymbolKeyword */, 99 /* VoidKeyword */, 112 /* AnyKeyword */]); + TokenRange.TypeNames = TokenRange.FromTokens([65 /* Identifier */, 121 /* NumberKeyword */, 123 /* StringKeyword */, 113 /* BooleanKeyword */, 124 /* SymbolKeyword */, 99 /* VoidKeyword */, 112 /* AnyKeyword */]); return TokenRange; })(); Shared.TokenRange = TokenRange; @@ -35711,6 +36147,7 @@ var ts; return this.rulesMap; }; RulesProvider.prototype.ensureUpToDate = function (options) { + // TODO: Should this be '==='? if (this.options == null || !ts.compareDataObjects(this.options, options)) { var activeRules = this.createActiveRules(options); var rulesMap = formatting.RulesMap.create(activeRules); @@ -35875,17 +36312,17 @@ var ts; // i.e. parent is class declaration with the list of members and node is one of members. function isListElement(parent, node) { switch (parent.kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: return ts.rangeContainsRange(parent.members, node); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: var body = parent.body; - return body && body.kind === 180 /* Block */ && ts.rangeContainsRange(body.statements, node); - case 228 /* SourceFile */: - case 180 /* Block */: - case 207 /* ModuleBlock */: + return body && body.kind === 182 /* Block */ && ts.rangeContainsRange(body.statements, node); + case 230 /* SourceFile */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return ts.rangeContainsRange(parent.statements, node); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return ts.rangeContainsRange(parent.block.statements, node); } return false; @@ -36058,9 +36495,9 @@ var ts; // - source file // - switch\default clauses if (isSomeBlock(parent.kind) || - parent.kind === 228 /* SourceFile */ || - parent.kind === 221 /* CaseClause */ || - parent.kind === 222 /* DefaultClause */) { + parent.kind === 230 /* SourceFile */ || + parent.kind === 223 /* CaseClause */ || + parent.kind === 224 /* DefaultClause */) { indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(); } else { @@ -36096,19 +36533,19 @@ var ts; return node.modifiers[0].kind; } switch (node.kind) { - case 202 /* ClassDeclaration */: return 69 /* ClassKeyword */; - case 203 /* InterfaceDeclaration */: return 103 /* InterfaceKeyword */; - case 201 /* FunctionDeclaration */: return 83 /* FunctionKeyword */; - case 205 /* EnumDeclaration */: return 205 /* EnumDeclaration */; - case 137 /* GetAccessor */: return 116 /* GetKeyword */; - case 138 /* SetAccessor */: return 121 /* SetKeyword */; - case 135 /* MethodDeclaration */: + case 204 /* ClassDeclaration */: return 69 /* ClassKeyword */; + case 205 /* InterfaceDeclaration */: return 103 /* InterfaceKeyword */; + case 203 /* FunctionDeclaration */: return 83 /* FunctionKeyword */; + case 207 /* EnumDeclaration */: return 207 /* EnumDeclaration */; + case 138 /* GetAccessor */: return 116 /* GetKeyword */; + case 139 /* SetAccessor */: return 122 /* SetKeyword */; + case 136 /* MethodDeclaration */: if (node.asteriskToken) { return 35 /* AsteriskToken */; } // fall-through - case 133 /* PropertyDeclaration */: - case 130 /* Parameter */: + case 134 /* PropertyDeclaration */: + case 131 /* Parameter */: return node.name.kind; } } @@ -36241,7 +36678,7 @@ var ts; consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation); return inheritedIndentation; } - var effectiveParentStartLine = child.kind === 131 /* Decorator */ ? childStartLine : undecoratedParentStartLine; + var effectiveParentStartLine = child.kind === 132 /* Decorator */ ? childStartLine : undecoratedParentStartLine; var childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine); processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta); childContextNode = node; @@ -36564,20 +37001,20 @@ var ts; } function isSomeBlock(kind) { switch (kind) { - case 180 /* Block */: - case 207 /* ModuleBlock */: + case 182 /* Block */: + case 209 /* ModuleBlock */: return true; } return false; } function getOpenTokenForList(node, list) { switch (node.kind) { - case 136 /* Constructor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 164 /* ArrowFunction */: + case 137 /* Constructor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 166 /* ArrowFunction */: if (node.typeParameters === list) { return 24 /* LessThanToken */; } @@ -36585,8 +37022,8 @@ var ts; return 16 /* OpenParenToken */; } break; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: if (node.typeArguments === list) { return 24 /* LessThanToken */; } @@ -36594,7 +37031,7 @@ var ts; return 16 /* OpenParenToken */; } break; - case 142 /* TypeReference */: + case 144 /* TypeReference */: if (node.typeArguments === list) { return 24 /* LessThanToken */; } @@ -36693,7 +37130,7 @@ var ts; return 0; } var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; - if (precedingToken.kind === 23 /* CommaToken */ && precedingToken.parent.kind !== 170 /* BinaryExpression */) { + if (precedingToken.kind === 23 /* CommaToken */ && precedingToken.parent.kind !== 172 /* BinaryExpression */) { // previous token is comma that separates items in list - find the previous item and try to derive indentation from it var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); if (actualIndentation !== -1 /* Unknown */) { @@ -36804,7 +37241,7 @@ var ts; // - parent is SourceFile - by default immediate children of SourceFile are not indented except when user indents them manually // - parent and child are not on the same line var useActualIndentation = (ts.isDeclaration(current) || ts.isStatement(current)) && - (parent.kind === 228 /* SourceFile */ || !parentAndChildShareLine); + (parent.kind === 230 /* SourceFile */ || !parentAndChildShareLine); if (!useActualIndentation) { return -1 /* Unknown */; } @@ -36837,7 +37274,7 @@ var ts; return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); } function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) { - if (parent.kind === 184 /* IfStatement */ && parent.elseStatement === child) { + if (parent.kind === 186 /* IfStatement */ && parent.elseStatement === child) { var elseKeyword = ts.findChildOfKind(parent, 76 /* ElseKeyword */, sourceFile); ts.Debug.assert(elseKeyword !== undefined); var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line; @@ -36849,23 +37286,23 @@ var ts; function getContainingList(node, sourceFile) { if (node.parent) { switch (node.parent.kind) { - case 142 /* TypeReference */: + case 144 /* TypeReference */: if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, node.getStart(sourceFile), node.getEnd())) { return node.parent.typeArguments; } break; - case 155 /* ObjectLiteralExpression */: + case 157 /* ObjectLiteralExpression */: return node.parent.properties; - case 154 /* ArrayLiteralExpression */: + case 156 /* ArrayLiteralExpression */: return node.parent.elements; - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: { + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: { var start = node.getStart(sourceFile); if (node.parent.typeParameters && ts.rangeContainsStartEnd(node.parent.typeParameters, start, node.getEnd())) { @@ -36876,8 +37313,8 @@ var ts; } break; } - case 159 /* NewExpression */: - case 158 /* CallExpression */: { + case 161 /* NewExpression */: + case 160 /* CallExpression */: { var start = node.getStart(sourceFile); if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, start, node.getEnd())) { @@ -36956,28 +37393,28 @@ var ts; SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn; function nodeContentIsAlwaysIndented(kind) { switch (kind) { - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 154 /* ArrayLiteralExpression */: - case 180 /* Block */: - case 207 /* ModuleBlock */: - case 155 /* ObjectLiteralExpression */: - case 146 /* TypeLiteral */: - case 148 /* TupleType */: - case 208 /* CaseBlock */: - case 222 /* DefaultClause */: - case 221 /* CaseClause */: - case 162 /* ParenthesizedExpression */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: - case 181 /* VariableStatement */: - case 199 /* VariableDeclaration */: - case 215 /* ExportAssignment */: - case 192 /* ReturnStatement */: - case 171 /* ConditionalExpression */: - case 152 /* ArrayBindingPattern */: - case 151 /* ObjectBindingPattern */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 156 /* ArrayLiteralExpression */: + case 182 /* Block */: + case 209 /* ModuleBlock */: + case 157 /* ObjectLiteralExpression */: + case 148 /* TypeLiteral */: + case 150 /* TupleType */: + case 210 /* CaseBlock */: + case 224 /* DefaultClause */: + case 223 /* CaseClause */: + case 164 /* ParenthesizedExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 183 /* VariableStatement */: + case 201 /* VariableDeclaration */: + case 217 /* ExportAssignment */: + case 194 /* ReturnStatement */: + case 173 /* ConditionalExpression */: + case 154 /* ArrayBindingPattern */: + case 153 /* ObjectBindingPattern */: return true; } return false; @@ -36987,22 +37424,22 @@ var ts; return true; } switch (parent) { - case 185 /* DoStatement */: - case 186 /* WhileStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 187 /* ForStatement */: - case 184 /* IfStatement */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 139 /* CallSignature */: - case 164 /* ArrowFunction */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - return child !== 180 /* Block */; + case 187 /* DoStatement */: + case 188 /* WhileStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 189 /* ForStatement */: + case 186 /* IfStatement */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 140 /* CallSignature */: + case 166 /* ArrowFunction */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + return child !== 182 /* Block */; default: return false; } @@ -37015,8 +37452,7 @@ var ts; var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; /// /// @@ -37085,7 +37521,7 @@ var ts; return this.getEnd() - this.getStart(sourceFile); }; NodeObject.prototype.getFullWidth = function () { - return this.end - this.getFullStart(); + return this.end - this.pos; }; NodeObject.prototype.getLeadingTriviaWidth = function (sourceFile) { return this.getStart(sourceFile) - this.pos; @@ -37107,7 +37543,7 @@ var ts; return pos; }; NodeObject.prototype.createSyntaxList = function (nodes) { - var list = createNode(251 /* SyntaxList */, nodes.pos, nodes.end, 1024 /* Synthetic */, this); + var list = createNode(253 /* SyntaxList */, nodes.pos, nodes.end, 1024 /* Synthetic */, this); list._children = []; var pos = nodes.pos; for (var _i = 0; _i < nodes.length; _i++) { @@ -37126,7 +37562,7 @@ var ts; NodeObject.prototype.createChildren = function (sourceFile) { var _this = this; var children; - if (this.kind >= 127 /* FirstNode */) { + if (this.kind >= 128 /* FirstNode */) { scanner.setText((sourceFile || this.getSourceFile()).text); children = []; var pos = this.pos; @@ -37171,7 +37607,7 @@ var ts; var children = this.getChildren(); for (var _i = 0; _i < children.length; _i++) { var child = children[_i]; - if (child.kind < 127 /* FirstNode */) { + if (child.kind < 128 /* FirstNode */) { return child; } return child.getFirstToken(sourceFile); @@ -37181,7 +37617,7 @@ var ts; var children = this.getChildren(sourceFile); for (var i = children.length - 1; i >= 0; i--) { var child = children[i]; - if (child.kind < 127 /* FirstNode */) { + if (child.kind < 128 /* FirstNode */) { return child; } return child.getLastToken(sourceFile); @@ -37234,7 +37670,7 @@ var ts; if (ts.indexOf(declarations, declaration) === indexOfDeclaration) { var sourceFileOfDeclaration = ts.getSourceFileOfNode(declaration); // If it is parameter - try and get the jsDoc comment with @param tag from function declaration's jsDoc comments - if (canUseParsedParamTagComments && declaration.kind === 130 /* Parameter */) { + if (canUseParsedParamTagComments && declaration.kind === 131 /* Parameter */) { ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedParamJsDocComment) { @@ -37243,15 +37679,15 @@ var ts; }); } // If this is left side of dotted module declaration, there is no doc comments associated with this node - if (declaration.kind === 206 /* ModuleDeclaration */ && declaration.body.kind === 206 /* ModuleDeclaration */) { + if (declaration.kind === 208 /* ModuleDeclaration */ && declaration.body.kind === 208 /* ModuleDeclaration */) { return; } // If this is dotted module name, get the doc comments from the parent - while (declaration.kind === 206 /* ModuleDeclaration */ && declaration.parent.kind === 206 /* ModuleDeclaration */) { + while (declaration.kind === 208 /* ModuleDeclaration */ && declaration.parent.kind === 208 /* ModuleDeclaration */) { declaration = declaration.parent; } // Get the cleaned js doc comment text from the declaration - ts.forEach(getJsDocCommentTextRange(declaration.kind === 199 /* VariableDeclaration */ ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { + ts.forEach(getJsDocCommentTextRange(declaration.kind === 201 /* VariableDeclaration */ ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedJsDocComment) { jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment); @@ -37590,9 +38026,9 @@ var ts; if (result_2 !== undefined) { return result_2; } - if (declaration.name.kind === 128 /* ComputedPropertyName */) { + if (declaration.name.kind === 129 /* ComputedPropertyName */) { var expr = declaration.name.expression; - if (expr.kind === 156 /* PropertyAccessExpression */) { + if (expr.kind === 158 /* PropertyAccessExpression */) { return expr.name.text; } return getTextOfIdentifierOrLiteral(expr); @@ -37612,9 +38048,9 @@ var ts; } function visit(node) { switch (node.kind) { - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: var functionDeclaration = node; var declarationName = getDeclarationName(functionDeclaration); if (declarationName) { @@ -37634,60 +38070,60 @@ var ts; ts.forEachChild(node, visit); } break; - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: - case 209 /* ImportEqualsDeclaration */: - case 218 /* ExportSpecifier */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 211 /* ImportClause */: - case 212 /* NamespaceImport */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 146 /* TypeLiteral */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 207 /* EnumDeclaration */: + case 208 /* ModuleDeclaration */: + case 211 /* ImportEqualsDeclaration */: + case 220 /* ExportSpecifier */: + case 216 /* ImportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 213 /* ImportClause */: + case 214 /* NamespaceImport */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 148 /* TypeLiteral */: addDeclaration(node); // fall through - case 136 /* Constructor */: - case 181 /* VariableStatement */: - case 200 /* VariableDeclarationList */: - case 151 /* ObjectBindingPattern */: - case 152 /* ArrayBindingPattern */: - case 207 /* ModuleBlock */: + case 137 /* Constructor */: + case 183 /* VariableStatement */: + case 202 /* VariableDeclarationList */: + case 153 /* ObjectBindingPattern */: + case 154 /* ArrayBindingPattern */: + case 209 /* ModuleBlock */: ts.forEachChild(node, visit); break; - case 180 /* Block */: + case 182 /* Block */: if (ts.isFunctionBlock(node)) { ts.forEachChild(node, visit); } break; - case 130 /* Parameter */: + case 131 /* Parameter */: // Only consider properties defined as constructor parameters if (!(node.flags & 112 /* AccessibilityModifier */)) { break; } // fall through - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: if (ts.isBindingPattern(node.name)) { ts.forEachChild(node.name, visit); break; } - case 227 /* EnumMember */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 229 /* EnumMember */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: addDeclaration(node); break; - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: // Handle named exports case e.g.: // export {a, b as B} from "mod"; if (node.exportClause) { ts.forEach(node.exportClause.elements, visit); } break; - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: var importClause = node.importClause; if (importClause) { // Handle default import case e.g.: @@ -37699,7 +38135,7 @@ var ts; // import * as NS from "mod"; // import {a, b as B} from "mod"; if (importClause.namedBindings) { - if (importClause.namedBindings.kind === 212 /* NamespaceImport */) { + if (importClause.namedBindings.kind === 214 /* NamespaceImport */) { addDeclaration(importClause.namedBindings); } else { @@ -37900,16 +38336,16 @@ var ts; } return ts.forEach(symbol.declarations, function (declaration) { // Function expressions are local - if (declaration.kind === 163 /* FunctionExpression */) { + if (declaration.kind === 165 /* FunctionExpression */) { return true; } - if (declaration.kind !== 199 /* VariableDeclaration */ && declaration.kind !== 201 /* FunctionDeclaration */) { + if (declaration.kind !== 201 /* VariableDeclaration */ && declaration.kind !== 203 /* FunctionDeclaration */) { return false; } // If the parent is not sourceFile or module block it is local variable - for (var parent_8 = declaration.parent; !ts.isFunctionBlock(parent_8); parent_8 = parent_8.parent) { + for (var parent_9 = declaration.parent; !ts.isFunctionBlock(parent_9); parent_9 = parent_9.parent) { // Reached source file or module block - if (parent_8.kind === 228 /* SourceFile */ || parent_8.kind === 207 /* ModuleBlock */) { + if (parent_9.kind === 230 /* SourceFile */ || parent_9.kind === 209 /* ModuleBlock */) { return false; } } @@ -37953,9 +38389,8 @@ var ts; var HostCache = (function () { function HostCache(host, getCanonicalFileName) { this.host = host; - this.getCanonicalFileName = getCanonicalFileName; // script id => script index - this.fileNameToEntry = {}; + this.fileNameToEntry = ts.createFileMap(getCanonicalFileName); // Initialize the list with the root file names var rootFileNames = host.getScriptFileNames(); for (var _i = 0; _i < rootFileNames.length; _i++) { @@ -37968,9 +38403,6 @@ var ts; HostCache.prototype.compilationSettings = function () { return this._compilationSettings; }; - HostCache.prototype.normalizeFileName = function (fileName) { - return this.getCanonicalFileName(ts.normalizeSlashes(fileName)); - }; HostCache.prototype.createEntry = function (fileName) { var entry; var scriptSnapshot = this.host.getScriptSnapshot(fileName); @@ -37981,13 +38413,14 @@ var ts; scriptSnapshot: scriptSnapshot }; } - return this.fileNameToEntry[this.normalizeFileName(fileName)] = entry; + this.fileNameToEntry.set(fileName, entry); + return entry; }; HostCache.prototype.getEntry = function (fileName) { - return ts.lookUp(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.get(fileName); }; HostCache.prototype.contains = function (fileName) { - return ts.hasProperty(this.fileNameToEntry, this.normalizeFileName(fileName)); + return this.fileNameToEntry.contains(fileName); }; HostCache.prototype.getOrCreateEntry = function (fileName) { if (this.contains(fileName)) { @@ -37996,12 +38429,10 @@ var ts; return this.createEntry(fileName); }; HostCache.prototype.getRootFileNames = function () { - var _this = this; var fileNames = []; - ts.forEachKey(this.fileNameToEntry, function (key) { - var entry = _this.getEntry(key); - if (entry) { - fileNames.push(entry.hostFileName); + this.fileNameToEntry.forEachValue(function (value) { + if (value) { + fileNames.push(value.hostFileName); } }); return fileNames; @@ -38061,7 +38492,7 @@ var ts; * - noLib = true * - noResolve = true */ - function transpile(input, compilerOptions, fileName, diagnostics) { + function transpile(input, compilerOptions, fileName, diagnostics, moduleName) { var options = compilerOptions ? ts.clone(compilerOptions) : getDefaultCompilerOptions(); options.isolatedModules = true; // Filename can be non-ts file. @@ -38075,9 +38506,8 @@ var ts; // Parse var inputFileName = fileName || "module.ts"; var sourceFile = ts.createSourceFile(inputFileName, input, options.target); - // Store syntactic diagnostics - if (diagnostics && sourceFile.parseDiagnostics) { - diagnostics.push.apply(diagnostics, sourceFile.parseDiagnostics); + if (moduleName) { + sourceFile.moduleName = moduleName; } var newLine = ts.getNewLineCharacter(options); // Output @@ -38096,9 +38526,8 @@ var ts; getNewLine: function () { return newLine; } }; var program = ts.createProgram([inputFileName], options, compilerHost); - if (diagnostics) { - diagnostics.push.apply(diagnostics, program.getCompilerOptionsDiagnostics()); - } + ts.addRange(diagnostics, program.getSyntacticDiagnostics(sourceFile)); + ts.addRange(diagnostics, program.getOptionsDiagnostics()); // Emit program.emit(); ts.Debug.assert(outputText !== undefined, "Output generation failed"); @@ -38158,10 +38587,16 @@ var ts; return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, true); } ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; - function createDocumentRegistry() { + function createGetCanonicalFileName(useCaseSensitivefileNames) { + return useCaseSensitivefileNames + ? (function (fileName) { return fileName; }) + : (function (fileName) { return fileName.toLowerCase(); }); + } + function createDocumentRegistry(useCaseSensitiveFileNames) { // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have // for those settings. var buckets = {}; + var getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames); function getKeyFromCompilationSettings(settings) { return "_" + settings.target; // + "|" + settings.propagateEnumConstantoString() } @@ -38169,7 +38604,7 @@ var ts; var key = getKeyFromCompilationSettings(settings); var bucket = ts.lookUp(buckets, key); if (!bucket && createIfMissing) { - buckets[key] = bucket = {}; + buckets[key] = bucket = ts.createFileMap(getCanonicalFileName); } return bucket; } @@ -38178,7 +38613,7 @@ var ts; var entries = ts.lookUp(buckets, name); var sourceFiles = []; for (var i in entries) { - var entry = entries[i]; + var entry = entries.get(i); sourceFiles.push({ name: i, refCount: entry.languageServiceRefCount, @@ -38201,16 +38636,17 @@ var ts; } function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) { var bucket = getBucketForCompilationSettings(compilationSettings, true); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); if (!entry) { ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?"); // Have never seen this file with these settings. Create a new source file for it. var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false); - bucket[fileName] = entry = { + entry = { sourceFile: sourceFile, languageServiceRefCount: 0, owners: [] }; + bucket.set(fileName, entry); } else { // We have an entry for this file. However, it may be for a different version of @@ -38233,11 +38669,11 @@ var ts; function releaseDocument(fileName, compilationSettings) { var bucket = getBucketForCompilationSettings(compilationSettings, false); ts.Debug.assert(bucket !== undefined); - var entry = ts.lookUp(bucket, fileName); + var entry = bucket.get(fileName); entry.languageServiceRefCount--; ts.Debug.assert(entry.languageServiceRefCount >= 0); if (entry.languageServiceRefCount === 0) { - delete bucket[fileName]; + bucket.remove(fileName); } } return { @@ -38300,7 +38736,7 @@ var ts; else { if (token === 65 /* Identifier */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // import d from "mod"; @@ -38310,7 +38746,7 @@ var ts; } else if (token === 53 /* EqualsToken */) { token = scanner.scan(); - if (token === 119 /* RequireKeyword */) { + if (token === 120 /* RequireKeyword */) { token = scanner.scan(); if (token === 16 /* OpenParenToken */) { token = scanner.scan(); @@ -38339,7 +38775,7 @@ var ts; } if (token === 15 /* CloseBraceToken */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // import {a as A} from "mod"; @@ -38355,7 +38791,7 @@ var ts; token = scanner.scan(); if (token === 65 /* Identifier */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // import * as NS from "mod" @@ -38378,7 +38814,7 @@ var ts; } if (token === 15 /* CloseBraceToken */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // export {a as A} from "mod"; @@ -38390,7 +38826,7 @@ var ts; } else if (token === 35 /* AsteriskToken */) { token = scanner.scan(); - if (token === 125 /* FromKeyword */) { + if (token === 126 /* FromKeyword */) { token = scanner.scan(); if (token === 8 /* StringLiteral */) { // export * from "mod" @@ -38413,7 +38849,7 @@ var ts; /// Helpers function getTargetLabel(referenceNode, labelName) { while (referenceNode) { - if (referenceNode.kind === 195 /* LabeledStatement */ && referenceNode.label.text === labelName) { + if (referenceNode.kind === 197 /* LabeledStatement */ && referenceNode.label.text === labelName) { return referenceNode.label; } referenceNode = referenceNode.parent; @@ -38422,12 +38858,12 @@ var ts; } function isJumpStatementTarget(node) { return node.kind === 65 /* Identifier */ && - (node.parent.kind === 191 /* BreakStatement */ || node.parent.kind === 190 /* ContinueStatement */) && + (node.parent.kind === 193 /* BreakStatement */ || node.parent.kind === 192 /* ContinueStatement */) && node.parent.label === node; } function isLabelOfLabeledStatement(node) { return node.kind === 65 /* Identifier */ && - node.parent.kind === 195 /* LabeledStatement */ && + node.parent.kind === 197 /* LabeledStatement */ && node.parent.label === node; } /** @@ -38435,7 +38871,7 @@ var ts; * Note: 'node' cannot be a SourceFile. */ function isLabeledBy(node, labelName) { - for (var owner = node.parent; owner.kind === 195 /* LabeledStatement */; owner = owner.parent) { + for (var owner = node.parent; owner.kind === 197 /* LabeledStatement */; owner = owner.parent) { if (owner.label.text === labelName) { return true; } @@ -38446,25 +38882,25 @@ var ts; return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node); } function isRightSideOfQualifiedName(node) { - return node.parent.kind === 127 /* QualifiedName */ && node.parent.right === node; + return node.parent.kind === 128 /* QualifiedName */ && node.parent.right === node; } function isRightSideOfPropertyAccess(node) { - return node && node.parent && node.parent.kind === 156 /* PropertyAccessExpression */ && node.parent.name === node; + return node && node.parent && node.parent.kind === 158 /* PropertyAccessExpression */ && node.parent.name === node; } function isCallExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 158 /* CallExpression */ && node.parent.expression === node; + return node && node.parent && node.parent.kind === 160 /* CallExpression */ && node.parent.expression === node; } function isNewExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 159 /* NewExpression */ && node.parent.expression === node; + return node && node.parent && node.parent.kind === 161 /* NewExpression */ && node.parent.expression === node; } function isNameOfModuleDeclaration(node) { - return node.parent.kind === 206 /* ModuleDeclaration */ && node.parent.name === node; + return node.parent.kind === 208 /* ModuleDeclaration */ && node.parent.name === node; } function isNameOfFunctionDeclaration(node) { return node.kind === 65 /* Identifier */ && @@ -38473,22 +38909,22 @@ var ts; /** Returns true if node is a name of an object literal property, e.g. "a" in x = { "a": 1 } */ function isNameOfPropertyAssignment(node) { return (node.kind === 65 /* Identifier */ || node.kind === 8 /* StringLiteral */ || node.kind === 7 /* NumericLiteral */) && - (node.parent.kind === 225 /* PropertyAssignment */ || node.parent.kind === 226 /* ShorthandPropertyAssignment */) && node.parent.name === node; + (node.parent.kind === 227 /* PropertyAssignment */ || node.parent.kind === 228 /* ShorthandPropertyAssignment */) && node.parent.name === node; } function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) { if (node.kind === 8 /* StringLiteral */ || node.kind === 7 /* NumericLiteral */) { switch (node.parent.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 206 /* ModuleDeclaration */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 227 /* PropertyAssignment */: + case 229 /* EnumMember */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 208 /* ModuleDeclaration */: return node.parent.name === node; - case 157 /* ElementAccessExpression */: + case 159 /* ElementAccessExpression */: return node.parent.argumentExpression === node; } } @@ -38547,7 +38983,7 @@ var ts; })(BreakContinueSearchType || (BreakContinueSearchType = {})); // A cache of completion entries for keywords, these do not change between sessions var keywordCompletions = []; - for (var i = 66 /* FirstKeyword */; i <= 126 /* LastKeyword */; i++) { + for (var i = 66 /* FirstKeyword */; i <= 127 /* LastKeyword */; i++) { keywordCompletions.push({ name: ts.tokenToString(i), kind: ScriptElementKind.keyword, @@ -38562,17 +38998,17 @@ var ts; return undefined; } switch (node.kind) { - case 228 /* SourceFile */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 202 /* ClassDeclaration */: - case 203 /* InterfaceDeclaration */: - case 205 /* EnumDeclaration */: - case 206 /* ModuleDeclaration */: + case 230 /* SourceFile */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 204 /* ClassDeclaration */: + case 205 /* InterfaceDeclaration */: + case 207 /* EnumDeclaration */: + case 208 /* ModuleDeclaration */: return node; } } @@ -38580,38 +39016,38 @@ var ts; ts.getContainerNode = getContainerNode; /* @internal */ function getNodeKind(node) { switch (node.kind) { - case 206 /* ModuleDeclaration */: return ScriptElementKind.moduleElement; - case 202 /* ClassDeclaration */: return ScriptElementKind.classElement; - case 203 /* InterfaceDeclaration */: return ScriptElementKind.interfaceElement; - case 204 /* TypeAliasDeclaration */: return ScriptElementKind.typeElement; - case 205 /* EnumDeclaration */: return ScriptElementKind.enumElement; - case 199 /* VariableDeclaration */: + case 208 /* ModuleDeclaration */: return ScriptElementKind.moduleElement; + case 204 /* ClassDeclaration */: return ScriptElementKind.classElement; + case 205 /* InterfaceDeclaration */: return ScriptElementKind.interfaceElement; + case 206 /* TypeAliasDeclaration */: return ScriptElementKind.typeElement; + case 207 /* EnumDeclaration */: return ScriptElementKind.enumElement; + case 201 /* VariableDeclaration */: return ts.isConst(node) ? ScriptElementKind.constElement : ts.isLet(node) ? ScriptElementKind.letElement : ScriptElementKind.variableElement; - case 201 /* FunctionDeclaration */: return ScriptElementKind.functionElement; - case 137 /* GetAccessor */: return ScriptElementKind.memberGetAccessorElement; - case 138 /* SetAccessor */: return ScriptElementKind.memberSetAccessorElement; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 203 /* FunctionDeclaration */: return ScriptElementKind.functionElement; + case 138 /* GetAccessor */: return ScriptElementKind.memberGetAccessorElement; + case 139 /* SetAccessor */: return ScriptElementKind.memberSetAccessorElement; + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: return ScriptElementKind.memberFunctionElement; - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return ScriptElementKind.memberVariableElement; - case 141 /* IndexSignature */: return ScriptElementKind.indexSignatureElement; - case 140 /* ConstructSignature */: return ScriptElementKind.constructSignatureElement; - case 139 /* CallSignature */: return ScriptElementKind.callSignatureElement; - case 136 /* Constructor */: return ScriptElementKind.constructorImplementationElement; - case 129 /* TypeParameter */: return ScriptElementKind.typeParameterElement; - case 227 /* EnumMember */: return ScriptElementKind.variableElement; - case 130 /* Parameter */: return (node.flags & 112 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; - case 209 /* ImportEqualsDeclaration */: - case 214 /* ImportSpecifier */: - case 211 /* ImportClause */: - case 218 /* ExportSpecifier */: - case 212 /* NamespaceImport */: + case 142 /* IndexSignature */: return ScriptElementKind.indexSignatureElement; + case 141 /* ConstructSignature */: return ScriptElementKind.constructSignatureElement; + case 140 /* CallSignature */: return ScriptElementKind.callSignatureElement; + case 137 /* Constructor */: return ScriptElementKind.constructorImplementationElement; + case 130 /* TypeParameter */: return ScriptElementKind.typeParameterElement; + case 229 /* EnumMember */: return ScriptElementKind.variableElement; + case 131 /* Parameter */: return (node.flags & 112 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; + case 211 /* ImportEqualsDeclaration */: + case 216 /* ImportSpecifier */: + case 213 /* ImportClause */: + case 220 /* ExportSpecifier */: + case 214 /* NamespaceImport */: return ScriptElementKind.alias; } return ScriptElementKind.unknown; @@ -38634,9 +39070,7 @@ var ts; host.log(message); } } - function getCanonicalFileName(fileName) { - return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); - } + var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames); function getValidSourceFile(fileName) { fileName = ts.normalizeSlashes(fileName); var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); @@ -38827,44 +39261,44 @@ var ts; return false; } switch (node.kind) { - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_a_ts_file)); return true; - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.export_can_only_be_used_in_a_ts_file)); return true; - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: var classDeclaration = node; if (checkModifiers(classDeclaration.modifiers) || checkTypeParameters(classDeclaration.typeParameters)) { return true; } break; - case 223 /* HeritageClause */: + case 225 /* HeritageClause */: var heritageClause = node; if (heritageClause.token === 102 /* ImplementsKeyword */) { diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file)); return true; } break; - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.interface_declarations_can_only_be_used_in_a_ts_file)); return true; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.module_declarations_can_only_be_used_in_a_ts_file)); return true; - case 204 /* TypeAliasDeclaration */: + case 206 /* TypeAliasDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.type_aliases_can_only_be_used_in_a_ts_file)); return true; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 201 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: var functionDeclaration = node; if (checkModifiers(functionDeclaration.modifiers) || checkTypeParameters(functionDeclaration.typeParameters) || @@ -38872,20 +39306,20 @@ var ts; return true; } break; - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: var variableStatement = node; if (checkModifiers(variableStatement.modifiers)) { return true; } break; - case 199 /* VariableDeclaration */: + case 201 /* VariableDeclaration */: var variableDeclaration = node; if (checkTypeAnnotation(variableDeclaration.type)) { return true; } break; - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: var expression = node; if (expression.typeArguments && expression.typeArguments.length > 0) { var start = expression.typeArguments.pos; @@ -38893,7 +39327,7 @@ var ts; return true; } break; - case 130 /* Parameter */: + case 131 /* Parameter */: var parameter = node; if (parameter.modifiers) { var start = parameter.modifiers.pos; @@ -38909,17 +39343,17 @@ var ts; return true; } break; - case 133 /* PropertyDeclaration */: + case 134 /* PropertyDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.property_declarations_can_only_be_used_in_a_ts_file)); return true; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file)); return true; - case 161 /* TypeAssertionExpression */: + case 163 /* TypeAssertionExpression */: var typeAssertionExpression = node; diagnostics.push(ts.createDiagnosticForNode(typeAssertionExpression.type, ts.Diagnostics.type_assertion_expressions_can_only_be_used_in_a_ts_file)); return true; - case 131 /* Decorator */: + case 132 /* Decorator */: diagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.decorators_can_only_be_used_in_a_ts_file)); return true; } @@ -38964,7 +39398,7 @@ var ts; } function getCompilerOptionsDiagnostics() { synchronizeHostData(); - return program.getGlobalDiagnostics(); + return program.getOptionsDiagnostics().concat(program.getGlobalDiagnostics()); } /// Completion function getCompletionEntryDisplayNameForSymbol(symbol, target, performCharacterChecks) { @@ -39053,11 +39487,11 @@ var ts; // visible symbols in the scope, and the node is the current location. var node = currentToken; var isRightOfDot = false; - if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 156 /* PropertyAccessExpression */) { + if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 158 /* PropertyAccessExpression */) { node = contextToken.parent.expression; isRightOfDot = true; } - else if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 127 /* QualifiedName */) { + else if (contextToken && contextToken.kind === 20 /* DotToken */ && contextToken.parent.kind === 128 /* QualifiedName */) { node = contextToken.parent.left; isRightOfDot = true; } @@ -39084,7 +39518,7 @@ var ts; // Right of dot member completion list isMemberCompletion = true; isNewIdentifierLocation = false; - if (node.kind === 65 /* Identifier */ || node.kind === 127 /* QualifiedName */ || node.kind === 156 /* PropertyAccessExpression */) { + if (node.kind === 65 /* Identifier */ || node.kind === 128 /* QualifiedName */ || node.kind === 158 /* PropertyAccessExpression */) { var symbol = typeChecker.getSymbolAtLocation(node); // This is an alias, follow what it aliases if (symbol && symbol.flags & 8388608 /* Alias */) { @@ -39142,13 +39576,13 @@ var ts; symbols = filterContextualMembersList(contextualTypeMembers, containingObjectLiteral.properties); } } - else if (ts.getAncestor(contextToken, 211 /* ImportClause */)) { + else if (ts.getAncestor(contextToken, 213 /* ImportClause */)) { // cursor is in import clause // try to show exported member for imported module isMemberCompletion = true; isNewIdentifierLocation = true; if (showCompletionsInImportsClause(contextToken)) { - var importDeclaration = ts.getAncestor(contextToken, 210 /* ImportDeclaration */); + var importDeclaration = ts.getAncestor(contextToken, 212 /* ImportDeclaration */); ts.Debug.assert(importDeclaration !== undefined); var exports; if (importDeclaration.moduleSpecifier) { @@ -39227,7 +39661,7 @@ var ts; // import {| // import {a,| if (node.kind === 14 /* OpenBraceToken */ || node.kind === 23 /* CommaToken */) { - return node.parent.kind === 213 /* NamedImports */; + return node.parent.kind === 215 /* NamedImports */; } } return false; @@ -39237,38 +39671,38 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23 /* CommaToken */: - return containingNodeKind === 158 /* CallExpression */ // func( a, | - || containingNodeKind === 136 /* Constructor */ // constructor( a, | public, protected, private keywords are allowed here, so show completion - || containingNodeKind === 159 /* NewExpression */ // new C(a, | - || containingNodeKind === 154 /* ArrayLiteralExpression */ // [a, | - || containingNodeKind === 170 /* BinaryExpression */ // let x = (a, | - || containingNodeKind === 143 /* FunctionType */; // var x: (s: string, list| + return containingNodeKind === 160 /* CallExpression */ // func( a, | + || containingNodeKind === 137 /* Constructor */ // constructor( a, | public, protected, private keywords are allowed here, so show completion + || containingNodeKind === 161 /* NewExpression */ // new C(a, | + || containingNodeKind === 156 /* ArrayLiteralExpression */ // [a, | + || containingNodeKind === 172 /* BinaryExpression */ // let x = (a, | + || containingNodeKind === 145 /* FunctionType */; // var x: (s: string, list| case 16 /* OpenParenToken */: - return containingNodeKind === 158 /* CallExpression */ // func( | - || containingNodeKind === 136 /* Constructor */ // constructor( | - || containingNodeKind === 159 /* NewExpression */ // new C(a| - || containingNodeKind === 162 /* ParenthesizedExpression */ // let x = (a| - || containingNodeKind === 150 /* ParenthesizedType */; // function F(pred: (a| this can become an arrow function, where 'a' is the argument + return containingNodeKind === 160 /* CallExpression */ // func( | + || containingNodeKind === 137 /* Constructor */ // constructor( | + || containingNodeKind === 161 /* NewExpression */ // new C(a| + || containingNodeKind === 164 /* ParenthesizedExpression */ // let x = (a| + || containingNodeKind === 152 /* ParenthesizedType */; // function F(pred: (a| this can become an arrow function, where 'a' is the argument case 18 /* OpenBracketToken */: - return containingNodeKind === 154 /* ArrayLiteralExpression */; // [ | - case 117 /* ModuleKeyword */: // module | - case 118 /* NamespaceKeyword */: + return containingNodeKind === 156 /* ArrayLiteralExpression */; // [ | + case 118 /* ModuleKeyword */: // module | + case 119 /* NamespaceKeyword */: return true; case 20 /* DotToken */: - return containingNodeKind === 206 /* ModuleDeclaration */; // module A.| + return containingNodeKind === 208 /* ModuleDeclaration */; // module A.| case 14 /* OpenBraceToken */: - return containingNodeKind === 202 /* ClassDeclaration */; // class A{ | + return containingNodeKind === 204 /* ClassDeclaration */; // class A{ | case 53 /* EqualsToken */: - return containingNodeKind === 199 /* VariableDeclaration */ // let x = a| - || containingNodeKind === 170 /* BinaryExpression */; // x = a| + return containingNodeKind === 201 /* VariableDeclaration */ // let x = a| + || containingNodeKind === 172 /* BinaryExpression */; // x = a| case 11 /* TemplateHead */: - return containingNodeKind === 172 /* TemplateExpression */; // `aa ${| + return containingNodeKind === 174 /* TemplateExpression */; // `aa ${| case 12 /* TemplateMiddle */: - return containingNodeKind === 178 /* TemplateSpan */; // `aa ${10} dd ${| + return containingNodeKind === 180 /* TemplateSpan */; // `aa ${10} dd ${| case 108 /* PublicKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: - return containingNodeKind === 133 /* PropertyDeclaration */; // class A{ public | + return containingNodeKind === 134 /* PropertyDeclaration */; // class A{ public | } // Previous token may have been a keyword that was converted to an identifier. switch (previousToken.getText()) { @@ -39303,12 +39737,12 @@ var ts; function getContainingObjectLiteralApplicableForCompletion(previousToken) { // The locations in an object literal expression that are applicable for completion are property name definition locations. if (previousToken) { - var parent_9 = previousToken.parent; + var parent_10 = previousToken.parent; switch (previousToken.kind) { case 14 /* OpenBraceToken */: // let x = { | case 23 /* CommaToken */: - if (parent_9 && parent_9.kind === 155 /* ObjectLiteralExpression */) { - return parent_9; + if (parent_10 && parent_10.kind === 157 /* ObjectLiteralExpression */) { + return parent_10; } break; } @@ -39317,16 +39751,16 @@ var ts; } function isFunction(kind) { switch (kind) { - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 139 /* CallSignature */: - case 140 /* ConstructSignature */: - case 141 /* IndexSignature */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 140 /* CallSignature */: + case 141 /* ConstructSignature */: + case 142 /* IndexSignature */: return true; } return false; @@ -39336,63 +39770,63 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23 /* CommaToken */: - return containingNodeKind === 199 /* VariableDeclaration */ || - containingNodeKind === 200 /* VariableDeclarationList */ || - containingNodeKind === 181 /* VariableStatement */ || - containingNodeKind === 205 /* EnumDeclaration */ || + return containingNodeKind === 201 /* VariableDeclaration */ || + containingNodeKind === 202 /* VariableDeclarationList */ || + containingNodeKind === 183 /* VariableStatement */ || + containingNodeKind === 207 /* EnumDeclaration */ || isFunction(containingNodeKind) || - containingNodeKind === 202 /* ClassDeclaration */ || - containingNodeKind === 201 /* FunctionDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || - containingNodeKind === 152 /* ArrayBindingPattern */ || - containingNodeKind === 151 /* ObjectBindingPattern */; // function func({ x, y| + containingNodeKind === 204 /* ClassDeclaration */ || + containingNodeKind === 203 /* FunctionDeclaration */ || + containingNodeKind === 205 /* InterfaceDeclaration */ || + containingNodeKind === 154 /* ArrayBindingPattern */ || + containingNodeKind === 153 /* ObjectBindingPattern */; // function func({ x, y| case 20 /* DotToken */: - return containingNodeKind === 152 /* ArrayBindingPattern */; // var [.| + return containingNodeKind === 154 /* ArrayBindingPattern */; // var [.| case 51 /* ColonToken */: - return containingNodeKind === 153 /* BindingElement */; // var {x :html| + return containingNodeKind === 155 /* BindingElement */; // var {x :html| case 18 /* OpenBracketToken */: - return containingNodeKind === 152 /* ArrayBindingPattern */; // var [x| + return containingNodeKind === 154 /* ArrayBindingPattern */; // var [x| case 16 /* OpenParenToken */: - return containingNodeKind === 224 /* CatchClause */ || + return containingNodeKind === 226 /* CatchClause */ || isFunction(containingNodeKind); case 14 /* OpenBraceToken */: - return containingNodeKind === 205 /* EnumDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || - containingNodeKind === 146 /* TypeLiteral */ || - containingNodeKind === 151 /* ObjectBindingPattern */; // function func({ x| + return containingNodeKind === 207 /* EnumDeclaration */ || + containingNodeKind === 205 /* InterfaceDeclaration */ || + containingNodeKind === 148 /* TypeLiteral */ || + containingNodeKind === 153 /* ObjectBindingPattern */; // function func({ x| case 22 /* SemicolonToken */: - return containingNodeKind === 132 /* PropertySignature */ && + return containingNodeKind === 133 /* PropertySignature */ && previousToken.parent && previousToken.parent.parent && - (previousToken.parent.parent.kind === 203 /* InterfaceDeclaration */ || - previousToken.parent.parent.kind === 146 /* TypeLiteral */); // let x : { a; | + (previousToken.parent.parent.kind === 205 /* InterfaceDeclaration */ || + previousToken.parent.parent.kind === 148 /* TypeLiteral */); // let x : { a; | case 24 /* LessThanToken */: - return containingNodeKind === 202 /* ClassDeclaration */ || - containingNodeKind === 201 /* FunctionDeclaration */ || - containingNodeKind === 203 /* InterfaceDeclaration */ || + return containingNodeKind === 204 /* ClassDeclaration */ || + containingNodeKind === 203 /* FunctionDeclaration */ || + containingNodeKind === 205 /* InterfaceDeclaration */ || isFunction(containingNodeKind); case 109 /* StaticKeyword */: - return containingNodeKind === 133 /* PropertyDeclaration */; + return containingNodeKind === 134 /* PropertyDeclaration */; case 21 /* DotDotDotToken */: - return containingNodeKind === 130 /* Parameter */ || - containingNodeKind === 136 /* Constructor */ || + return containingNodeKind === 131 /* Parameter */ || + containingNodeKind === 137 /* Constructor */ || (previousToken.parent && previousToken.parent.parent && - previousToken.parent.parent.kind === 152 /* ArrayBindingPattern */); // var [...z| + previousToken.parent.parent.kind === 154 /* ArrayBindingPattern */); // var [...z| case 108 /* PublicKeyword */: case 106 /* PrivateKeyword */: case 107 /* ProtectedKeyword */: - return containingNodeKind === 130 /* Parameter */; + return containingNodeKind === 131 /* Parameter */; case 69 /* ClassKeyword */: case 77 /* EnumKeyword */: case 103 /* InterfaceKeyword */: case 83 /* FunctionKeyword */: case 98 /* VarKeyword */: case 116 /* GetKeyword */: - case 121 /* SetKeyword */: + case 122 /* SetKeyword */: case 85 /* ImportKeyword */: case 104 /* LetKeyword */: case 70 /* ConstKeyword */: case 110 /* YieldKeyword */: - case 124 /* TypeKeyword */: + case 125 /* TypeKeyword */: return true; } // Previous token may have been a keyword that was converted to an identifier. @@ -39424,7 +39858,7 @@ var ts; return exports; } if (importDeclaration.importClause.namedBindings && - importDeclaration.importClause.namedBindings.kind === 213 /* NamedImports */) { + importDeclaration.importClause.namedBindings.kind === 215 /* NamedImports */) { ts.forEach(importDeclaration.importClause.namedBindings.elements, function (el) { var name = el.propertyName || el.name; exisingImports[name.text] = true; @@ -39441,7 +39875,7 @@ var ts; } var existingMemberNames = {}; ts.forEach(existingMembers, function (m) { - if (m.kind !== 225 /* PropertyAssignment */ && m.kind !== 226 /* ShorthandPropertyAssignment */) { + if (m.kind !== 227 /* PropertyAssignment */ && m.kind !== 228 /* ShorthandPropertyAssignment */) { // Ignore omitted expressions for missing members in the object literal return; } @@ -39491,10 +39925,10 @@ var ts; for (var _i = 0, _a = program.getSourceFiles(); _i < _a.length; _i++) { var sourceFile = _a[_i]; var nameTable = getNameTable(sourceFile); - for (var name_30 in nameTable) { - if (!allNames[name_30]) { - allNames[name_30] = name_30; - var displayName = getCompletionEntryDisplayName(name_30, target, true); + for (var name_27 in nameTable) { + if (!allNames[name_27]) { + allNames[name_27] = name_27; + var displayName = getCompletionEntryDisplayName(name_27, target, true); if (displayName) { var entry = { name: displayName, @@ -39693,7 +40127,7 @@ var ts; var signature; type = typeChecker.getTypeOfSymbolAtLocation(symbol, location); if (type) { - if (location.parent && location.parent.kind === 156 /* PropertyAccessExpression */) { + if (location.parent && location.parent.kind === 158 /* PropertyAccessExpression */) { var right = location.parent.name; // Either the location is on the right of a property access, or on the left and the right is missing if (right === location || (right && right.getFullWidth() === 0)) { @@ -39702,7 +40136,7 @@ var ts; } // try get the call/construct signature from the type if it matches var callExpression; - if (location.kind === 158 /* CallExpression */ || location.kind === 159 /* NewExpression */) { + if (location.kind === 160 /* CallExpression */ || location.kind === 161 /* NewExpression */) { callExpression = location; } else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) { @@ -39715,7 +40149,7 @@ var ts; // Use the first candidate: signature = candidateSignatures[0]; } - var useConstructSignatures = callExpression.kind === 159 /* NewExpression */ || callExpression.expression.kind === 91 /* SuperKeyword */; + var useConstructSignatures = callExpression.kind === 161 /* NewExpression */ || callExpression.expression.kind === 91 /* SuperKeyword */; var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures(); if (!ts.contains(allSignatures, signature.target || signature)) { // Get the first signature if there @@ -39767,24 +40201,24 @@ var ts; } } else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304 /* Accessor */)) || - (location.kind === 114 /* ConstructorKeyword */ && location.parent.kind === 136 /* Constructor */)) { + (location.kind === 114 /* ConstructorKeyword */ && location.parent.kind === 137 /* Constructor */)) { // get the signature from the declaration and write it var functionDeclaration = location.parent; - var allSignatures = functionDeclaration.kind === 136 /* Constructor */ ? type.getConstructSignatures() : type.getCallSignatures(); + var allSignatures = functionDeclaration.kind === 137 /* Constructor */ ? type.getConstructSignatures() : type.getCallSignatures(); if (!typeChecker.isImplementationOfOverload(functionDeclaration)) { signature = typeChecker.getSignatureFromDeclaration(functionDeclaration); } else { signature = allSignatures[0]; } - if (functionDeclaration.kind === 136 /* Constructor */) { + if (functionDeclaration.kind === 137 /* Constructor */) { // show (constructor) Type(...) signature symbolKind = ScriptElementKind.constructorImplementationElement; addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); } else { // (function/method) symbol(..signature) - addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 139 /* CallSignature */ && + addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 140 /* CallSignature */ && !(type.symbol.flags & 2048 /* TypeLiteral */ || type.symbol.flags & 4096 /* ObjectLiteral */) ? type.symbol : symbol, symbolKind); } addSignatureDisplayParts(signature, allSignatures); @@ -39807,7 +40241,7 @@ var ts; } if (symbolFlags & 524288 /* TypeAlias */) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(124 /* TypeKeyword */)); + displayParts.push(ts.keywordPart(125 /* TypeKeyword */)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); displayParts.push(ts.spacePart()); @@ -39827,9 +40261,9 @@ var ts; } if (symbolFlags & 1536 /* Module */) { addNewLineIfDisplayPartsExist(); - var declaration = ts.getDeclarationOfKind(symbol, 206 /* ModuleDeclaration */); + var declaration = ts.getDeclarationOfKind(symbol, 208 /* ModuleDeclaration */); var isNamespace = declaration && declaration.name && declaration.name.kind === 65 /* Identifier */; - displayParts.push(ts.keywordPart(isNamespace ? 118 /* NamespaceKeyword */ : 117 /* ModuleKeyword */)); + displayParts.push(ts.keywordPart(isNamespace ? 119 /* NamespaceKeyword */ : 118 /* ModuleKeyword */)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); } @@ -39850,13 +40284,13 @@ var ts; } else { // Method/function type parameter - var signatureDeclaration = ts.getDeclarationOfKind(symbol, 129 /* TypeParameter */).parent; + var signatureDeclaration = ts.getDeclarationOfKind(symbol, 130 /* TypeParameter */).parent; var signature = typeChecker.getSignatureFromDeclaration(signatureDeclaration); - if (signatureDeclaration.kind === 140 /* ConstructSignature */) { + if (signatureDeclaration.kind === 141 /* ConstructSignature */) { displayParts.push(ts.keywordPart(88 /* NewKeyword */)); displayParts.push(ts.spacePart()); } - else if (signatureDeclaration.kind !== 139 /* CallSignature */ && signatureDeclaration.name) { + else if (signatureDeclaration.kind !== 140 /* CallSignature */ && signatureDeclaration.name) { addFullSymbolName(signatureDeclaration.symbol); } displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeChecker, signature, sourceFile, 32 /* WriteTypeArgumentsOfSignature */)); @@ -39865,7 +40299,7 @@ var ts; if (symbolFlags & 8 /* EnumMember */) { addPrefixForAnyFunctionOrVar(symbol, "enum member"); var declaration = symbol.declarations[0]; - if (declaration.kind === 227 /* EnumMember */) { + if (declaration.kind === 229 /* EnumMember */) { var constantValue = typeChecker.getConstantValue(declaration); if (constantValue !== undefined) { displayParts.push(ts.spacePart()); @@ -39881,13 +40315,13 @@ var ts; displayParts.push(ts.spacePart()); addFullSymbolName(symbol); ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 209 /* ImportEqualsDeclaration */) { + if (declaration.kind === 211 /* ImportEqualsDeclaration */) { var importEqualsDeclaration = declaration; if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) { displayParts.push(ts.spacePart()); displayParts.push(ts.operatorPart(53 /* EqualsToken */)); displayParts.push(ts.spacePart()); - displayParts.push(ts.keywordPart(119 /* RequireKeyword */)); + displayParts.push(ts.keywordPart(120 /* RequireKeyword */)); displayParts.push(ts.punctuationPart(16 /* OpenParenToken */)); displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), SymbolDisplayPartKind.stringLiteral)); displayParts.push(ts.punctuationPart(17 /* CloseParenToken */)); @@ -40014,8 +40448,8 @@ var ts; // Try getting just type at this position and show switch (node.kind) { case 65 /* Identifier */: - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: + case 158 /* PropertyAccessExpression */: + case 128 /* QualifiedName */: case 93 /* ThisKeyword */: case 91 /* SuperKeyword */: // For the identifiers/this/super etc get the type at position @@ -40073,7 +40507,7 @@ var ts; if (isNewExpressionTarget(location) || location.kind === 114 /* ConstructorKeyword */) { if (symbol.flags & 32 /* Class */) { var classDeclaration = symbol.getDeclarations()[0]; - ts.Debug.assert(classDeclaration && classDeclaration.kind === 202 /* ClassDeclaration */); + ts.Debug.assert(classDeclaration && classDeclaration.kind === 204 /* ClassDeclaration */); return tryAddSignature(classDeclaration.members, true, symbolKind, symbolName, containerName, result); } } @@ -40089,8 +40523,8 @@ var ts; var declarations = []; var definition; ts.forEach(signatureDeclarations, function (d) { - if ((selectConstructors && d.kind === 136 /* Constructor */) || - (!selectConstructors && (d.kind === 201 /* FunctionDeclaration */ || d.kind === 135 /* MethodDeclaration */ || d.kind === 134 /* MethodSignature */))) { + if ((selectConstructors && d.kind === 137 /* Constructor */) || + (!selectConstructors && (d.kind === 203 /* FunctionDeclaration */ || d.kind === 136 /* MethodDeclaration */ || d.kind === 135 /* MethodSignature */))) { declarations.push(d); if (d.body) definition = d; @@ -40159,7 +40593,7 @@ var ts; // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition // is performed at the location of property access, we would like to go to definition of the property in the short-hand // assignment. This case and others are handled by the following code. - if (node.parent.kind === 226 /* ShorthandPropertyAssignment */) { + if (node.parent.kind === 228 /* ShorthandPropertyAssignment */) { var shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration); if (!shorthandSymbol) { return []; @@ -40193,7 +40627,7 @@ var ts; var result = []; ts.forEach(type.types, function (t) { if (t.symbol) { - result.push.apply(result, getDefinitionFromSymbol(t.symbol, node)); + ts.addRange(result, getDefinitionFromSymbol(t.symbol, node)); } }); return result; @@ -40288,74 +40722,74 @@ var ts; switch (node.kind) { case 84 /* IfKeyword */: case 76 /* ElseKeyword */: - if (hasKind(node.parent, 184 /* IfStatement */)) { + if (hasKind(node.parent, 186 /* IfStatement */)) { return getIfElseOccurrences(node.parent); } break; case 90 /* ReturnKeyword */: - if (hasKind(node.parent, 192 /* ReturnStatement */)) { + if (hasKind(node.parent, 194 /* ReturnStatement */)) { return getReturnOccurrences(node.parent); } break; case 94 /* ThrowKeyword */: - if (hasKind(node.parent, 196 /* ThrowStatement */)) { + if (hasKind(node.parent, 198 /* ThrowStatement */)) { return getThrowOccurrences(node.parent); } break; case 68 /* CatchKeyword */: - if (hasKind(parent(parent(node)), 197 /* TryStatement */)) { + if (hasKind(parent(parent(node)), 199 /* TryStatement */)) { return getTryCatchFinallyOccurrences(node.parent.parent); } break; case 96 /* TryKeyword */: case 81 /* FinallyKeyword */: - if (hasKind(parent(node), 197 /* TryStatement */)) { + if (hasKind(parent(node), 199 /* TryStatement */)) { return getTryCatchFinallyOccurrences(node.parent); } break; case 92 /* SwitchKeyword */: - if (hasKind(node.parent, 194 /* SwitchStatement */)) { + if (hasKind(node.parent, 196 /* SwitchStatement */)) { return getSwitchCaseDefaultOccurrences(node.parent); } break; case 67 /* CaseKeyword */: case 73 /* DefaultKeyword */: - if (hasKind(parent(parent(parent(node))), 194 /* SwitchStatement */)) { + if (hasKind(parent(parent(parent(node))), 196 /* SwitchStatement */)) { return getSwitchCaseDefaultOccurrences(node.parent.parent.parent); } break; case 66 /* BreakKeyword */: case 71 /* ContinueKeyword */: - if (hasKind(node.parent, 191 /* BreakStatement */) || hasKind(node.parent, 190 /* ContinueStatement */)) { + if (hasKind(node.parent, 193 /* BreakStatement */) || hasKind(node.parent, 192 /* ContinueStatement */)) { return getBreakOrContinueStatementOccurences(node.parent); } break; case 82 /* ForKeyword */: - if (hasKind(node.parent, 187 /* ForStatement */) || - hasKind(node.parent, 188 /* ForInStatement */) || - hasKind(node.parent, 189 /* ForOfStatement */)) { + if (hasKind(node.parent, 189 /* ForStatement */) || + hasKind(node.parent, 190 /* ForInStatement */) || + hasKind(node.parent, 191 /* ForOfStatement */)) { return getLoopBreakContinueOccurrences(node.parent); } break; case 100 /* WhileKeyword */: case 75 /* DoKeyword */: - if (hasKind(node.parent, 186 /* WhileStatement */) || hasKind(node.parent, 185 /* DoStatement */)) { + if (hasKind(node.parent, 188 /* WhileStatement */) || hasKind(node.parent, 187 /* DoStatement */)) { return getLoopBreakContinueOccurrences(node.parent); } break; case 114 /* ConstructorKeyword */: - if (hasKind(node.parent, 136 /* Constructor */)) { + if (hasKind(node.parent, 137 /* Constructor */)) { return getConstructorOccurrences(node.parent); } break; case 116 /* GetKeyword */: - case 121 /* SetKeyword */: - if (hasKind(node.parent, 137 /* GetAccessor */) || hasKind(node.parent, 138 /* SetAccessor */)) { + case 122 /* SetKeyword */: + if (hasKind(node.parent, 138 /* GetAccessor */) || hasKind(node.parent, 139 /* SetAccessor */)) { return getGetAndSetOccurrences(node.parent); } default: if (ts.isModifier(node.kind) && node.parent && - (ts.isDeclaration(node.parent) || node.parent.kind === 181 /* VariableStatement */)) { + (ts.isDeclaration(node.parent) || node.parent.kind === 183 /* VariableStatement */)) { return getModifierOccurrences(node.kind, node.parent); } } @@ -40371,10 +40805,10 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 196 /* ThrowStatement */) { + if (node.kind === 198 /* ThrowStatement */) { statementAccumulator.push(node); } - else if (node.kind === 197 /* TryStatement */) { + else if (node.kind === 199 /* TryStatement */) { var tryStatement = node; if (tryStatement.catchClause) { aggregate(tryStatement.catchClause); @@ -40402,19 +40836,19 @@ var ts; function getThrowStatementOwner(throwStatement) { var child = throwStatement; while (child.parent) { - var parent_10 = child.parent; - if (ts.isFunctionBlock(parent_10) || parent_10.kind === 228 /* SourceFile */) { - return parent_10; + var parent_11 = child.parent; + if (ts.isFunctionBlock(parent_11) || parent_11.kind === 230 /* SourceFile */) { + return parent_11; } // A throw-statement is only owned by a try-statement if the try-statement has // a catch clause, and if the throw-statement occurs within the try block. - if (parent_10.kind === 197 /* TryStatement */) { - var tryStatement = parent_10; + if (parent_11.kind === 199 /* TryStatement */) { + var tryStatement = parent_11; if (tryStatement.tryBlock === child && tryStatement.catchClause) { return child; } } - child = parent_10; + child = parent_11; } return undefined; } @@ -40423,7 +40857,7 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 191 /* BreakStatement */ || node.kind === 190 /* ContinueStatement */) { + if (node.kind === 193 /* BreakStatement */ || node.kind === 192 /* ContinueStatement */) { statementAccumulator.push(node); } else if (!ts.isFunctionLike(node)) { @@ -40437,25 +40871,25 @@ var ts; return actualOwner && actualOwner === owner; } function getBreakOrContinueOwner(statement) { - for (var node_1 = statement.parent; node_1; node_1 = node_1.parent) { - switch (node_1.kind) { - case 194 /* SwitchStatement */: - if (statement.kind === 190 /* ContinueStatement */) { + for (var node_2 = statement.parent; node_2; node_2 = node_2.parent) { + switch (node_2.kind) { + case 196 /* SwitchStatement */: + if (statement.kind === 192 /* ContinueStatement */) { continue; } // Fall through. - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 186 /* WhileStatement */: - case 185 /* DoStatement */: - if (!statement.label || isLabeledBy(node_1, statement.label.text)) { - return node_1; + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 188 /* WhileStatement */: + case 187 /* DoStatement */: + if (!statement.label || isLabeledBy(node_2, statement.label.text)) { + return node_2; } break; default: // Don't cross function boundaries. - if (ts.isFunctionLike(node_1)) { + if (ts.isFunctionLike(node_2)) { return undefined; } break; @@ -40467,18 +40901,18 @@ var ts; var container = declaration.parent; // Make sure we only highlight the keyword when it makes sense to do so. if (ts.isAccessibilityModifier(modifier)) { - if (!(container.kind === 202 /* ClassDeclaration */ || - (declaration.kind === 130 /* Parameter */ && hasKind(container, 136 /* Constructor */)))) { + if (!(container.kind === 204 /* ClassDeclaration */ || + (declaration.kind === 131 /* Parameter */ && hasKind(container, 137 /* Constructor */)))) { return undefined; } } else if (modifier === 109 /* StaticKeyword */) { - if (container.kind !== 202 /* ClassDeclaration */) { + if (container.kind !== 204 /* ClassDeclaration */) { return undefined; } } else if (modifier === 78 /* ExportKeyword */ || modifier === 115 /* DeclareKeyword */) { - if (!(container.kind === 207 /* ModuleBlock */ || container.kind === 228 /* SourceFile */)) { + if (!(container.kind === 209 /* ModuleBlock */ || container.kind === 230 /* SourceFile */)) { return undefined; } } @@ -40490,20 +40924,20 @@ var ts; var modifierFlag = getFlagFromModifier(modifier); var nodes; switch (container.kind) { - case 207 /* ModuleBlock */: - case 228 /* SourceFile */: + case 209 /* ModuleBlock */: + case 230 /* SourceFile */: nodes = container.statements; break; - case 136 /* Constructor */: + case 137 /* Constructor */: nodes = container.parameters.concat(container.parent.members); break; - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: nodes = container.members; // If we're an accessibility modifier, we're in an instance member and should search // the constructor's parameter list for instance members as well. if (modifierFlag & 112 /* AccessibilityModifier */) { var constructor = ts.forEach(container.members, function (member) { - return member.kind === 136 /* Constructor */ && member; + return member.kind === 137 /* Constructor */ && member; }); if (constructor) { nodes = nodes.concat(constructor.parameters); @@ -40551,13 +40985,13 @@ var ts; } function getGetAndSetOccurrences(accessorDeclaration) { var keywords = []; - tryPushAccessorKeyword(accessorDeclaration.symbol, 137 /* GetAccessor */); - tryPushAccessorKeyword(accessorDeclaration.symbol, 138 /* SetAccessor */); + tryPushAccessorKeyword(accessorDeclaration.symbol, 138 /* GetAccessor */); + tryPushAccessorKeyword(accessorDeclaration.symbol, 139 /* SetAccessor */); return ts.map(keywords, getHighlightSpanForNode); function tryPushAccessorKeyword(accessorSymbol, accessorKind) { var accessor = ts.getDeclarationOfKind(accessorSymbol, accessorKind); if (accessor) { - ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116 /* GetKeyword */, 121 /* SetKeyword */); }); + ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116 /* GetKeyword */, 122 /* SetKeyword */); }); } } } @@ -40575,7 +41009,7 @@ var ts; var keywords = []; if (pushKeywordIf(keywords, loopNode.getFirstToken(), 82 /* ForKeyword */, 100 /* WhileKeyword */, 75 /* DoKeyword */)) { // If we succeeded and got a do-while loop, then start looking for a 'while' keyword. - if (loopNode.kind === 185 /* DoStatement */) { + if (loopNode.kind === 187 /* DoStatement */) { var loopTokens = loopNode.getChildren(); for (var i = loopTokens.length - 1; i >= 0; i--) { if (pushKeywordIf(keywords, loopTokens[i], 100 /* WhileKeyword */)) { @@ -40596,13 +41030,13 @@ var ts; var owner = getBreakOrContinueOwner(breakOrContinueStatement); if (owner) { switch (owner.kind) { - case 187 /* ForStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: - case 185 /* DoStatement */: - case 186 /* WhileStatement */: + case 189 /* ForStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: + case 187 /* DoStatement */: + case 188 /* WhileStatement */: return getLoopBreakContinueOccurrences(owner); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: return getSwitchCaseDefaultOccurrences(owner); } } @@ -40656,7 +41090,7 @@ var ts; function getReturnOccurrences(returnStatement) { var func = ts.getContainingFunction(returnStatement); // If we didn't find a containing function with a block body, bail out. - if (!(func && hasKind(func.body, 180 /* Block */))) { + if (!(func && hasKind(func.body, 182 /* Block */))) { return undefined; } var keywords = []; @@ -40672,7 +41106,7 @@ var ts; function getIfElseOccurrences(ifStatement) { var keywords = []; // Traverse upwards through all parent if-statements linked by their else-branches. - while (hasKind(ifStatement.parent, 184 /* IfStatement */) && ifStatement.parent.elseStatement === ifStatement) { + while (hasKind(ifStatement.parent, 186 /* IfStatement */) && ifStatement.parent.elseStatement === ifStatement) { ifStatement = ifStatement.parent; } // Now traverse back down through the else branches, aggregating if/else keywords of if-statements. @@ -40685,7 +41119,7 @@ var ts; break; } } - if (!hasKind(ifStatement.elseStatement, 184 /* IfStatement */)) { + if (!hasKind(ifStatement.elseStatement, 186 /* IfStatement */)) { break; } ifStatement = ifStatement.elseStatement; @@ -40864,17 +41298,17 @@ var ts; } function isImportOrExportSpecifierName(location) { return location.parent && - (location.parent.kind === 214 /* ImportSpecifier */ || location.parent.kind === 218 /* ExportSpecifier */) && + (location.parent.kind === 216 /* ImportSpecifier */ || location.parent.kind === 220 /* ExportSpecifier */) && location.parent.propertyName === location; } function isImportOrExportSpecifierImportSymbol(symbol) { return (symbol.flags & 8388608 /* Alias */) && ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 214 /* ImportSpecifier */ || declaration.kind === 218 /* ExportSpecifier */; + return declaration.kind === 216 /* ImportSpecifier */ || declaration.kind === 220 /* ExportSpecifier */; }); } function getDeclaredName(symbol, location) { // Special case for function expressions, whose names are solely local to their bodies. - var functionExpression = ts.forEach(symbol.declarations, function (d) { return d.kind === 163 /* FunctionExpression */ ? d : undefined; }); + var functionExpression = ts.forEach(symbol.declarations, function (d) { return d.kind === 165 /* FunctionExpression */ ? d : undefined; }); // When a name gets interned into a SourceFile's 'identifiers' Map, // its name is escaped and stored in the same way its symbol name/identifier // name should be stored. Function expressions, however, are a special case, @@ -40901,7 +41335,7 @@ var ts; return location.getText(); } // Special case for function expressions, whose names are solely local to their bodies. - var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 163 /* FunctionExpression */ ? d : undefined; }); + var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 165 /* FunctionExpression */ ? d : undefined; }); // When a name gets interned into a SourceFile's 'identifiers' Map, // its name is escaped and stored in the same way its symbol name/identifier // name should be stored. Function expressions, however, are a special case, @@ -40925,7 +41359,7 @@ var ts; if (symbol.flags & (4 /* Property */ | 8192 /* Method */)) { var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32 /* Private */) ? d : undefined; }); if (privateDeclaration) { - return ts.getAncestor(privateDeclaration, 202 /* ClassDeclaration */); + return ts.getAncestor(privateDeclaration, 204 /* ClassDeclaration */); } } // If the symbol is an import we would like to find it if we are looking for what it imports. @@ -40951,7 +41385,7 @@ var ts; // Different declarations have different containers, bail out return undefined; } - if (container.kind === 228 /* SourceFile */ && !ts.isExternalModule(container)) { + if (container.kind === 230 /* SourceFile */ && !ts.isExternalModule(container)) { // This is a global variable and not an external module, any declaration defined // within this scope is visible outside the file return undefined; @@ -41139,13 +41573,13 @@ var ts; // Whether 'super' occurs in a static context within a class. var staticFlag = 128 /* Static */; switch (searchSpaceNode.kind) { - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class break; @@ -41177,27 +41611,27 @@ var ts; // Whether 'this' occurs in a static context within a class. var staticFlag = 128 /* Static */; switch (searchSpaceNode.kind) { - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (ts.isObjectLiteralMethod(searchSpaceNode)) { break; } // fall through - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class break; - case 228 /* SourceFile */: + case 230 /* SourceFile */: if (ts.isExternalModule(searchSpaceNode)) { return undefined; } // Fall through - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: break; // Computed properties in classes are not handled here because references to this are illegal, // so there is no point finding references to them. @@ -41206,7 +41640,7 @@ var ts; } var references = []; var possiblePositions; - if (searchSpaceNode.kind === 228 /* SourceFile */) { + if (searchSpaceNode.kind === 230 /* SourceFile */) { ts.forEach(sourceFiles, function (sourceFile) { possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd()); getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, references); @@ -41237,27 +41671,27 @@ var ts; } var container = ts.getThisContainer(node, false); switch (searchSpaceNode.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: if (searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: if (ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: // Make sure the container belongs to the same class // and has the appropriate static modifier from the original container. if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128 /* Static */) === staticFlag) { result.push(getReferenceEntryFromNode(node)); } break; - case 228 /* SourceFile */: - if (container.kind === 228 /* SourceFile */ && !ts.isExternalModule(container)) { + case 230 /* SourceFile */: + if (container.kind === 230 /* SourceFile */ && !ts.isExternalModule(container)) { result.push(getReferenceEntryFromNode(node)); } break; @@ -41311,11 +41745,11 @@ var ts; function getPropertySymbolsFromBaseTypes(symbol, propertyName, result) { if (symbol && symbol.flags & (32 /* Class */ | 64 /* Interface */)) { ts.forEach(symbol.getDeclarations(), function (declaration) { - if (declaration.kind === 202 /* ClassDeclaration */) { + if (declaration.kind === 204 /* ClassDeclaration */) { getPropertySymbolFromTypeReference(ts.getClassExtendsHeritageClauseElement(declaration)); ts.forEach(ts.getClassImplementsHeritageClauseElements(declaration), getPropertySymbolFromTypeReference); } - else if (declaration.kind === 203 /* InterfaceDeclaration */) { + else if (declaration.kind === 205 /* InterfaceDeclaration */) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), getPropertySymbolFromTypeReference); } }); @@ -41376,19 +41810,19 @@ var ts; if (isNameOfPropertyAssignment(node)) { var objectLiteral = node.parent.parent; var contextualType = typeChecker.getContextualType(objectLiteral); - var name_31 = node.text; + var name_28 = node.text; if (contextualType) { if (contextualType.flags & 16384 /* Union */) { // This is a union type, first see if the property we are looking for is a union property (i.e. exists in all types) // if not, search the constituent types for the property - var unionProperty = contextualType.getProperty(name_31); + var unionProperty = contextualType.getProperty(name_28); if (unionProperty) { return [unionProperty]; } else { var result_4 = []; ts.forEach(contextualType.types, function (t) { - var symbol = t.getProperty(name_31); + var symbol = t.getProperty(name_28); if (symbol) { result_4.push(symbol); } @@ -41397,7 +41831,7 @@ var ts; } } else { - var symbol_1 = contextualType.getProperty(name_31); + var symbol_1 = contextualType.getProperty(name_28); if (symbol_1) { return [symbol_1]; } @@ -41455,10 +41889,10 @@ var ts; } var parent = node.parent; if (parent) { - if (parent.kind === 169 /* PostfixUnaryExpression */ || parent.kind === 168 /* PrefixUnaryExpression */) { + if (parent.kind === 171 /* PostfixUnaryExpression */ || parent.kind === 170 /* PrefixUnaryExpression */) { return true; } - else if (parent.kind === 170 /* BinaryExpression */ && parent.left === node) { + else if (parent.kind === 172 /* BinaryExpression */ && parent.left === node) { var operator = parent.operatorToken.kind; return 53 /* FirstAssignment */ <= operator && operator <= 64 /* LastAssignment */; } @@ -41492,33 +41926,33 @@ var ts; } function getMeaningFromDeclaration(node) { switch (node.kind) { - case 130 /* Parameter */: - case 199 /* VariableDeclaration */: - case 153 /* BindingElement */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: - case 225 /* PropertyAssignment */: - case 226 /* ShorthandPropertyAssignment */: - case 227 /* EnumMember */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 136 /* Constructor */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 201 /* FunctionDeclaration */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: - case 224 /* CatchClause */: + case 131 /* Parameter */: + case 201 /* VariableDeclaration */: + case 155 /* BindingElement */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: + case 227 /* PropertyAssignment */: + case 228 /* ShorthandPropertyAssignment */: + case 229 /* EnumMember */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 137 /* Constructor */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 203 /* FunctionDeclaration */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + case 226 /* CatchClause */: return 1 /* Value */; - case 129 /* TypeParameter */: - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: - case 146 /* TypeLiteral */: + case 130 /* TypeParameter */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: + case 148 /* TypeLiteral */: return 2 /* Type */; - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: return 1 /* Value */ | 2 /* Type */; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: if (node.name.kind === 8 /* StringLiteral */) { return 4 /* Namespace */ | 1 /* Value */; } @@ -41528,15 +41962,15 @@ var ts; else { return 4 /* Namespace */; } - case 213 /* NamedImports */: - case 214 /* ImportSpecifier */: - case 209 /* ImportEqualsDeclaration */: - case 210 /* ImportDeclaration */: - case 215 /* ExportAssignment */: - case 216 /* ExportDeclaration */: + case 215 /* NamedImports */: + case 216 /* ImportSpecifier */: + case 211 /* ImportEqualsDeclaration */: + case 212 /* ImportDeclaration */: + case 217 /* ExportAssignment */: + case 218 /* ExportDeclaration */: return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; // An external module can be a Value - case 228 /* SourceFile */: + case 230 /* SourceFile */: return 4 /* Namespace */ | 1 /* Value */; } return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; @@ -41546,7 +41980,8 @@ var ts; if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) { node = node.parent; } - return node.parent.kind === 142 /* TypeReference */ || node.parent.kind === 177 /* ExpressionWithTypeArguments */; + return node.parent.kind === 144 /* TypeReference */ || + (node.parent.kind === 179 /* ExpressionWithTypeArguments */ && !ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent)); } function isNamespaceReference(node) { return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node); @@ -41554,32 +41989,32 @@ var ts; function isPropertyAccessNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 156 /* PropertyAccessExpression */) { - while (root.parent && root.parent.kind === 156 /* PropertyAccessExpression */) { + if (root.parent.kind === 158 /* PropertyAccessExpression */) { + while (root.parent && root.parent.kind === 158 /* PropertyAccessExpression */) { root = root.parent; } isLastClause = root.name === node; } - if (!isLastClause && root.parent.kind === 177 /* ExpressionWithTypeArguments */ && root.parent.parent.kind === 223 /* HeritageClause */) { + if (!isLastClause && root.parent.kind === 179 /* ExpressionWithTypeArguments */ && root.parent.parent.kind === 225 /* HeritageClause */) { var decl = root.parent.parent.parent; - return (decl.kind === 202 /* ClassDeclaration */ && root.parent.parent.token === 102 /* ImplementsKeyword */) || - (decl.kind === 203 /* InterfaceDeclaration */ && root.parent.parent.token === 79 /* ExtendsKeyword */); + return (decl.kind === 204 /* ClassDeclaration */ && root.parent.parent.token === 102 /* ImplementsKeyword */) || + (decl.kind === 205 /* InterfaceDeclaration */ && root.parent.parent.token === 79 /* ExtendsKeyword */); } return false; } function isQualifiedNameNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 127 /* QualifiedName */) { - while (root.parent && root.parent.kind === 127 /* QualifiedName */) { + if (root.parent.kind === 128 /* QualifiedName */) { + while (root.parent && root.parent.kind === 128 /* QualifiedName */) { root = root.parent; } isLastClause = root.right === node; } - return root.parent.kind === 142 /* TypeReference */ && !isLastClause; + return root.parent.kind === 144 /* TypeReference */ && !isLastClause; } function isInRightSideOfImport(node) { - while (node.parent.kind === 127 /* QualifiedName */) { + while (node.parent.kind === 128 /* QualifiedName */) { node = node.parent; } return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node; @@ -41589,15 +42024,15 @@ var ts; // import a = |b|; // Namespace // import a = |b.c|; // Value, type, namespace // import a = |b.c|.d; // Namespace - if (node.parent.kind === 127 /* QualifiedName */ && + if (node.parent.kind === 128 /* QualifiedName */ && node.parent.right === node && - node.parent.parent.kind === 209 /* ImportEqualsDeclaration */) { + node.parent.parent.kind === 211 /* ImportEqualsDeclaration */) { return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; } return 4 /* Namespace */; } function getMeaningFromLocation(node) { - if (node.parent.kind === 215 /* ExportAssignment */) { + if (node.parent.kind === 217 /* ExportAssignment */) { return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */; } else if (isInRightSideOfImport(node)) { @@ -41637,8 +42072,8 @@ var ts; return; } switch (node.kind) { - case 156 /* PropertyAccessExpression */: - case 127 /* QualifiedName */: + case 158 /* PropertyAccessExpression */: + case 128 /* QualifiedName */: case 8 /* StringLiteral */: case 80 /* FalseKeyword */: case 95 /* TrueKeyword */: @@ -41661,7 +42096,7 @@ var ts; // If this is name of a module declarations, check if this is right side of dotted module name // If parent of the module declaration which is parent of this node is module declaration and its body is the module declaration that this node is name of // Then this name is name from dotted module - if (nodeForStartPos.parent.parent.kind === 206 /* ModuleDeclaration */ && + if (nodeForStartPos.parent.parent.kind === 208 /* ModuleDeclaration */ && nodeForStartPos.parent.parent.body === nodeForStartPos.parent) { // Use parent module declarations name for start pos nodeForStartPos = nodeForStartPos.parent.parent.name; @@ -41695,6 +42130,7 @@ var ts; var sourceFile = getValidSourceFile(fileName); var typeChecker = program.getTypeChecker(); var result = []; + var classifiableNames = program.getClassifiableNames(); processNode(sourceFile); return { spans: result, endOfLineState: 0 /* None */ }; function pushClassification(start, length, type) { @@ -41704,6 +42140,9 @@ var ts; } function classifySymbol(symbol, meaningAtPosition) { var flags = symbol.getFlags(); + if ((flags & 788448 /* Classifiable */) === 0 /* None */) { + return; + } if (flags & 32 /* Class */) { return 11 /* className */; } @@ -41736,19 +42175,26 @@ var ts; */ function hasValueSideModule(symbol) { return ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 206 /* ModuleDeclaration */ && ts.getModuleInstanceState(declaration) == 1 /* Instantiated */; + return declaration.kind === 208 /* ModuleDeclaration */ && + ts.getModuleInstanceState(declaration) === 1 /* Instantiated */; }); } } function processNode(node) { // Only walk into nodes that intersect the requested span. - if (node && ts.textSpanIntersectsWith(span, node.getStart(), node.getWidth())) { - if (node.kind === 65 /* Identifier */ && node.getWidth() > 0) { - var symbol = typeChecker.getSymbolAtLocation(node); - if (symbol) { - var type = classifySymbol(symbol, getMeaningFromLocation(node)); - if (type) { - pushClassification(node.getStart(), node.getWidth(), type); + if (node && ts.textSpanIntersectsWith(span, node.getFullStart(), node.getFullWidth())) { + if (node.kind === 65 /* Identifier */ && !ts.nodeIsMissing(node)) { + var identifier = node; + // Only bother calling into the typechecker if this is an identifier that + // could possibly resolve to a type name. This makes classification run + // in a third of the time it would normally take. + if (classifiableNames[identifier.text]) { + var symbol = typeChecker.getSymbolAtLocation(node); + if (symbol) { + var type = classifySymbol(symbol, getMeaningFromLocation(node)); + if (type) { + pushClassification(node.getStart(), node.getWidth(), type); + } } } } @@ -41795,6 +42241,8 @@ var ts; function getEncodedSyntacticClassifications(fileName, span) { // doesn't use compiler - no need to synchronize with host var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var spanStart = span.start; + var spanLength = span.length; // Make a scanner we can get trivia from. var triviaScanner = ts.createScanner(2 /* Latest */, false, sourceFile.text); var mergeConflictScanner = ts.createScanner(2 /* Latest */, false, sourceFile.text); @@ -41806,42 +42254,47 @@ var ts; result.push(length); result.push(type); } - function classifyLeadingTrivia(token) { - var tokenStart = ts.skipTrivia(sourceFile.text, token.pos, false); - if (tokenStart === token.pos) { - return; - } - // token has trivia. Classify them appropriately. + function classifyLeadingTriviaAndGetTokenStart(token) { triviaScanner.setTextPos(token.pos); while (true) { var start = triviaScanner.getTextPos(); + // only bother scanning if we have something that could be trivia. + if (!ts.couldStartTrivia(sourceFile.text, start)) { + return start; + } var kind = triviaScanner.scan(); var end = triviaScanner.getTextPos(); var width = end - start; // The moment we get something that isn't trivia, then stop processing. if (!ts.isTrivia(kind)) { - return; + return start; + } + // Don't bother with newlines/whitespace. + if (kind === 4 /* NewLineTrivia */ || kind === 5 /* WhitespaceTrivia */) { + continue; } // Only bother with the trivia if it at least intersects the span of interest. - if (ts.textSpanIntersectsWith(span, start, width)) { - if (ts.isComment(kind)) { - classifyComment(token, kind, start, width); + if (ts.isComment(kind)) { + classifyComment(token, kind, start, width); + // Classifying a comment might cause us to reuse the trivia scanner + // (because of jsdoc comments). So after we classify the comment make + // sure we set the scanner position back to where it needs to be. + triviaScanner.setTextPos(end); + continue; + } + if (kind === 6 /* ConflictMarkerTrivia */) { + var text = sourceFile.text; + var ch = text.charCodeAt(start); + // for the <<<<<<< and >>>>>>> markers, we just add them in as comments + // in the classification stream. + if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) { + pushClassification(start, width, 1 /* comment */); continue; } - if (kind === 6 /* ConflictMarkerTrivia */) { - var text = sourceFile.text; - var ch = text.charCodeAt(start); - // for the <<<<<<< and >>>>>>> markers, we just add them in as comments - // in the classification stream. - if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) { - pushClassification(start, width, 1 /* comment */); - continue; - } - // for the ======== add a comment for the first line, and then lex all - // subsequent lines up until the end of the conflict marker. - ts.Debug.assert(ch === 61 /* equals */); - classifyDisabledMergeCode(text, start, end); - } + // for the ======== add a comment for the first line, and then lex all + // subsequent lines up until the end of the conflict marker. + ts.Debug.assert(ch === 61 /* equals */); + classifyDisabledMergeCode(text, start, end); } } } @@ -41875,16 +42328,16 @@ var ts; pushClassification(tag.tagName.pos, tag.tagName.end - tag.tagName.pos, 18 /* docCommentTagName */); pos = tag.tagName.end; switch (tag.kind) { - case 247 /* JSDocParameterTag */: + case 249 /* JSDocParameterTag */: processJSDocParameterTag(tag); break; - case 250 /* JSDocTemplateTag */: + case 252 /* JSDocTemplateTag */: processJSDocTemplateTag(tag); break; - case 249 /* JSDocTypeTag */: + case 251 /* JSDocTypeTag */: processElement(tag.typeExpression); break; - case 248 /* JSDocReturnTag */: + case 250 /* JSDocReturnTag */: processElement(tag.typeExpression); break; } @@ -41942,11 +42395,13 @@ var ts; } } function classifyToken(token) { - classifyLeadingTrivia(token); - if (token.getWidth() > 0) { + var tokenStart = classifyLeadingTriviaAndGetTokenStart(token); + var tokenWidth = token.end - tokenStart; + ts.Debug.assert(tokenWidth >= 0); + if (tokenWidth > 0) { var type = classifyTokenType(token.kind, token); if (type) { - pushClassification(token.getStart(), token.getWidth(), type); + pushClassification(tokenStart, tokenWidth, type); } } } @@ -41970,16 +42425,16 @@ var ts; if (token) { if (tokenKind === 53 /* EqualsToken */) { // the '=' in a variable declaration is special cased here. - if (token.parent.kind === 199 /* VariableDeclaration */ || - token.parent.kind === 133 /* PropertyDeclaration */ || - token.parent.kind === 130 /* Parameter */) { + if (token.parent.kind === 201 /* VariableDeclaration */ || + token.parent.kind === 134 /* PropertyDeclaration */ || + token.parent.kind === 131 /* Parameter */) { return 5 /* operator */; } } - if (token.parent.kind === 170 /* BinaryExpression */ || - token.parent.kind === 168 /* PrefixUnaryExpression */ || - token.parent.kind === 169 /* PostfixUnaryExpression */ || - token.parent.kind === 171 /* ConditionalExpression */) { + if (token.parent.kind === 172 /* BinaryExpression */ || + token.parent.kind === 170 /* PrefixUnaryExpression */ || + token.parent.kind === 171 /* PostfixUnaryExpression */ || + token.parent.kind === 173 /* ConditionalExpression */) { return 5 /* operator */; } } @@ -42002,32 +42457,32 @@ var ts; else if (tokenKind === 65 /* Identifier */) { if (token) { switch (token.parent.kind) { - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: if (token.parent.name === token) { return 11 /* className */; } return; - case 129 /* TypeParameter */: + case 130 /* TypeParameter */: if (token.parent.name === token) { return 15 /* typeParameterName */; } return; - case 203 /* InterfaceDeclaration */: + case 205 /* InterfaceDeclaration */: if (token.parent.name === token) { return 13 /* interfaceName */; } return; - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: if (token.parent.name === token) { return 12 /* enumName */; } return; - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: if (token.parent.name === token) { return 14 /* moduleName */; } return; - case 130 /* Parameter */: + case 131 /* Parameter */: if (token.parent.name === token) { return 17 /* parameterName */; } @@ -42042,10 +42497,10 @@ var ts; return; } // Ignore nodes that don't intersect the original span to classify. - if (ts.textSpanIntersectsWith(span, element.getFullStart(), element.getFullWidth())) { + if (ts.decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) { var children = element.getChildren(sourceFile); - for (var _i = 0; _i < children.length; _i++) { - var child = children[_i]; + for (var i = 0, n = children.length; i < n; i++) { + var child = children[i]; if (ts.isToken(child)) { classifyToken(child); } @@ -42372,7 +42827,7 @@ var ts; // then we want 'something' to be in the name table. Similarly, if we have // "a['propname']" then we want to store "propname" in the name table. if (ts.isDeclarationName(node) || - node.parent.kind === 220 /* ExternalModuleReference */ || + node.parent.kind === 222 /* ExternalModuleReference */ || isArgumentOfElementAccessExpression(node)) { nameTable[node.text] = node.text; } @@ -42385,7 +42840,7 @@ var ts; function isArgumentOfElementAccessExpression(node) { return node && node.parent && - node.parent.kind === 157 /* ElementAccessExpression */ && + node.parent.kind === 159 /* ElementAccessExpression */ && node.parent.argumentExpression === node; } /// Classifier @@ -42433,7 +42888,7 @@ var ts; function canFollow(keyword1, keyword2) { if (ts.isAccessibilityModifier(keyword1)) { if (keyword2 === 116 /* GetKeyword */ || - keyword2 === 121 /* SetKeyword */ || + keyword2 === 122 /* SetKeyword */ || keyword2 === 114 /* ConstructorKeyword */ || keyword2 === 109 /* StaticKeyword */) { // Allow things like "public get", "public constructor" and "public static". @@ -42592,10 +43047,10 @@ var ts; angleBracketStack--; } else if (token === 112 /* AnyKeyword */ || - token === 122 /* StringKeyword */ || - token === 120 /* NumberKeyword */ || + token === 123 /* StringKeyword */ || + token === 121 /* NumberKeyword */ || token === 113 /* BooleanKeyword */ || - token === 123 /* SymbolKeyword */) { + token === 124 /* SymbolKeyword */) { if (angleBracketStack > 0 && !syntacticClassifierAbsent) { // If it looks like we're could be in something generic, don't classify this // as a keyword. We may just get overwritten by the syntactic classifier, @@ -42766,7 +43221,7 @@ var ts; } } function isKeyword(token) { - return token >= 66 /* FirstKeyword */ && token <= 126 /* LastKeyword */; + return token >= 66 /* FirstKeyword */ && token <= 127 /* LastKeyword */; } function classFromKind(token) { if (isKeyword(token)) { @@ -42824,7 +43279,7 @@ var ts; getNodeConstructor: function (kind) { function Node() { } - var proto = kind === 228 /* SourceFile */ ? new SourceFileObject() : new NodeObject(); + var proto = kind === 230 /* SourceFile */ ? new SourceFileObject() : new NodeObject(); proto.kind = kind; proto.pos = 0; proto.end = 0; @@ -42894,125 +43349,125 @@ var ts; function spanInNode(node) { if (node) { if (ts.isExpression(node)) { - if (node.parent.kind === 185 /* DoStatement */) { + if (node.parent.kind === 187 /* DoStatement */) { // Set span as if on while keyword return spanInPreviousNode(node); } - if (node.parent.kind === 187 /* ForStatement */) { + if (node.parent.kind === 189 /* ForStatement */) { // For now lets set the span on this expression, fix it later return textSpan(node); } - if (node.parent.kind === 170 /* BinaryExpression */ && node.parent.operatorToken.kind === 23 /* CommaToken */) { + if (node.parent.kind === 172 /* BinaryExpression */ && node.parent.operatorToken.kind === 23 /* CommaToken */) { // if this is comma expression, the breakpoint is possible in this expression return textSpan(node); } - if (node.parent.kind == 164 /* ArrowFunction */ && node.parent.body == node) { + if (node.parent.kind === 166 /* ArrowFunction */ && node.parent.body === node) { // If this is body of arrow function, it is allowed to have the breakpoint return textSpan(node); } } switch (node.kind) { - case 181 /* VariableStatement */: + case 183 /* VariableStatement */: // Span on first variable declaration return spanInVariableDeclaration(node.declarationList.declarations[0]); - case 199 /* VariableDeclaration */: - case 133 /* PropertyDeclaration */: - case 132 /* PropertySignature */: + case 201 /* VariableDeclaration */: + case 134 /* PropertyDeclaration */: + case 133 /* PropertySignature */: return spanInVariableDeclaration(node); - case 130 /* Parameter */: + case 131 /* Parameter */: return spanInParameterDeclaration(node); - case 201 /* FunctionDeclaration */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 163 /* FunctionExpression */: - case 164 /* ArrowFunction */: + case 203 /* FunctionDeclaration */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 137 /* Constructor */: + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: return spanInFunctionDeclaration(node); - case 180 /* Block */: + case 182 /* Block */: if (ts.isFunctionBlock(node)) { return spanInFunctionBlock(node); } // Fall through - case 207 /* ModuleBlock */: + case 209 /* ModuleBlock */: return spanInBlock(node); - case 224 /* CatchClause */: + case 226 /* CatchClause */: return spanInBlock(node.block); - case 183 /* ExpressionStatement */: + case 185 /* ExpressionStatement */: // span on the expression return textSpan(node.expression); - case 192 /* ReturnStatement */: + case 194 /* ReturnStatement */: // span on return keyword and expression if present return textSpan(node.getChildAt(0), node.expression); - case 186 /* WhileStatement */: + case 188 /* WhileStatement */: // Span on while(...) return textSpan(node, ts.findNextToken(node.expression, node)); - case 185 /* DoStatement */: + case 187 /* DoStatement */: // span in statement of the do statement return spanInNode(node.statement); - case 198 /* DebuggerStatement */: + case 200 /* DebuggerStatement */: // span on debugger keyword return textSpan(node.getChildAt(0)); - case 184 /* IfStatement */: + case 186 /* IfStatement */: // set on if(..) span return textSpan(node, ts.findNextToken(node.expression, node)); - case 195 /* LabeledStatement */: + case 197 /* LabeledStatement */: // span in statement return spanInNode(node.statement); - case 191 /* BreakStatement */: - case 190 /* ContinueStatement */: + case 193 /* BreakStatement */: + case 192 /* ContinueStatement */: // On break or continue keyword and label if present return textSpan(node.getChildAt(0), node.label); - case 187 /* ForStatement */: + case 189 /* ForStatement */: return spanInForStatement(node); - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: // span on for (a in ...) return textSpan(node, ts.findNextToken(node.expression, node)); - case 194 /* SwitchStatement */: + case 196 /* SwitchStatement */: // span on switch(...) return textSpan(node, ts.findNextToken(node.expression, node)); - case 221 /* CaseClause */: - case 222 /* DefaultClause */: + case 223 /* CaseClause */: + case 224 /* DefaultClause */: // span in first statement of the clause return spanInNode(node.statements[0]); - case 197 /* TryStatement */: + case 199 /* TryStatement */: // span in try block return spanInBlock(node.tryBlock); - case 196 /* ThrowStatement */: + case 198 /* ThrowStatement */: // span in throw ... return textSpan(node, node.expression); - case 215 /* ExportAssignment */: + case 217 /* ExportAssignment */: // span on export = id return textSpan(node, node.expression); - case 209 /* ImportEqualsDeclaration */: + case 211 /* ImportEqualsDeclaration */: // import statement without including semicolon return textSpan(node, node.moduleReference); - case 210 /* ImportDeclaration */: + case 212 /* ImportDeclaration */: // import statement without including semicolon return textSpan(node, node.moduleSpecifier); - case 216 /* ExportDeclaration */: + case 218 /* ExportDeclaration */: // import statement without including semicolon return textSpan(node, node.moduleSpecifier); - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: // span on complete module if it is instantiated if (ts.getModuleInstanceState(node) !== 1 /* Instantiated */) { return undefined; } - case 202 /* ClassDeclaration */: - case 205 /* EnumDeclaration */: - case 227 /* EnumMember */: - case 158 /* CallExpression */: - case 159 /* NewExpression */: + case 204 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 229 /* EnumMember */: + case 160 /* CallExpression */: + case 161 /* NewExpression */: // span on complete node return textSpan(node); - case 193 /* WithStatement */: + case 195 /* WithStatement */: // span in statement return spanInNode(node.statement); // No breakpoint in interface, type alias - case 203 /* InterfaceDeclaration */: - case 204 /* TypeAliasDeclaration */: + case 205 /* InterfaceDeclaration */: + case 206 /* TypeAliasDeclaration */: return undefined; // Tokens: case 22 /* SemicolonToken */: @@ -43042,11 +43497,11 @@ var ts; return spanInNextNode(node); default: // If this is name of property assignment, set breakpoint in the initializer - if (node.parent.kind === 225 /* PropertyAssignment */ && node.parent.name === node) { + if (node.parent.kind === 227 /* PropertyAssignment */ && node.parent.name === node) { return spanInNode(node.parent.initializer); } // Breakpoint in type assertion goes to its operand - if (node.parent.kind === 161 /* TypeAssertionExpression */ && node.parent.type === node) { + if (node.parent.kind === 163 /* TypeAssertionExpression */ && node.parent.type === node) { return spanInNode(node.parent.expression); } // return type of function go to previous token @@ -43059,12 +43514,12 @@ var ts; } function spanInVariableDeclaration(variableDeclaration) { // If declaration of for in statement, just set the span in parent - if (variableDeclaration.parent.parent.kind === 188 /* ForInStatement */ || - variableDeclaration.parent.parent.kind === 189 /* ForOfStatement */) { + if (variableDeclaration.parent.parent.kind === 190 /* ForInStatement */ || + variableDeclaration.parent.parent.kind === 191 /* ForOfStatement */) { return spanInNode(variableDeclaration.parent.parent); } - var isParentVariableStatement = variableDeclaration.parent.parent.kind === 181 /* VariableStatement */; - var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 187 /* ForStatement */ && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); + var isParentVariableStatement = variableDeclaration.parent.parent.kind === 183 /* VariableStatement */; + var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 189 /* ForStatement */ && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); var declarations = isParentVariableStatement ? variableDeclaration.parent.parent.declarationList.declarations : isDeclarationOfForStatement @@ -43118,7 +43573,7 @@ var ts; } function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) { return !!(functionDeclaration.flags & 1 /* Export */) || - (functionDeclaration.parent.kind === 202 /* ClassDeclaration */ && functionDeclaration.kind !== 136 /* Constructor */); + (functionDeclaration.parent.kind === 204 /* ClassDeclaration */ && functionDeclaration.kind !== 137 /* Constructor */); } function spanInFunctionDeclaration(functionDeclaration) { // No breakpoints in the function signature @@ -43141,18 +43596,18 @@ var ts; } function spanInBlock(block) { switch (block.parent.kind) { - case 206 /* ModuleDeclaration */: + case 208 /* ModuleDeclaration */: if (ts.getModuleInstanceState(block.parent) !== 1 /* Instantiated */) { return undefined; } // Set on parent if on same line otherwise on first statement - case 186 /* WhileStatement */: - case 184 /* IfStatement */: - case 188 /* ForInStatement */: - case 189 /* ForOfStatement */: + case 188 /* WhileStatement */: + case 186 /* IfStatement */: + case 190 /* ForInStatement */: + case 191 /* ForOfStatement */: return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); // Set span on previous token if it starts on same line otherwise on the first statement of the block - case 187 /* ForStatement */: + case 189 /* ForStatement */: return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]); } // Default action is to set on first statement @@ -43160,7 +43615,7 @@ var ts; } function spanInForStatement(forStatement) { if (forStatement.initializer) { - if (forStatement.initializer.kind === 200 /* VariableDeclarationList */) { + if (forStatement.initializer.kind === 202 /* VariableDeclarationList */) { var variableDeclarationList = forStatement.initializer; if (variableDeclarationList.declarations.length > 0) { return spanInNode(variableDeclarationList.declarations[0]); @@ -43180,13 +43635,13 @@ var ts; // Tokens: function spanInOpenBraceToken(node) { switch (node.parent.kind) { - case 205 /* EnumDeclaration */: + case 207 /* EnumDeclaration */: var enumDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile)); - case 202 /* ClassDeclaration */: + case 204 /* ClassDeclaration */: var classDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile)); - case 208 /* CaseBlock */: + case 210 /* CaseBlock */: return spanInNodeIfStartsOnSameLine(node.parent.parent, node.parent.clauses[0]); } // Default to parent node @@ -43194,25 +43649,25 @@ var ts; } function spanInCloseBraceToken(node) { switch (node.parent.kind) { - case 207 /* ModuleBlock */: + case 209 /* ModuleBlock */: // If this is not instantiated module block no bp span if (ts.getModuleInstanceState(node.parent.parent) !== 1 /* Instantiated */) { return undefined; } - case 205 /* EnumDeclaration */: - case 202 /* ClassDeclaration */: + case 207 /* EnumDeclaration */: + case 204 /* ClassDeclaration */: // Span on close brace token return textSpan(node); - case 180 /* Block */: + case 182 /* Block */: if (ts.isFunctionBlock(node.parent)) { // Span on close brace token return textSpan(node); } // fall through. - case 224 /* CatchClause */: + case 226 /* CatchClause */: return spanInNode(ts.lastOrUndefined(node.parent.statements)); ; - case 208 /* CaseBlock */: + case 210 /* CaseBlock */: // breakpoint in last statement of the last clause var caseBlock = node.parent; var lastClause = ts.lastOrUndefined(caseBlock.clauses); @@ -43226,7 +43681,7 @@ var ts; } } function spanInOpenParenToken(node) { - if (node.parent.kind === 185 /* DoStatement */) { + if (node.parent.kind === 187 /* DoStatement */) { // Go to while keyword and do action instead return spanInPreviousNode(node); } @@ -43236,17 +43691,17 @@ var ts; function spanInCloseParenToken(node) { // Is this close paren token of parameter list, set span in previous token switch (node.parent.kind) { - case 163 /* FunctionExpression */: - case 201 /* FunctionDeclaration */: - case 164 /* ArrowFunction */: - case 135 /* MethodDeclaration */: - case 134 /* MethodSignature */: - case 137 /* GetAccessor */: - case 138 /* SetAccessor */: - case 136 /* Constructor */: - case 186 /* WhileStatement */: - case 185 /* DoStatement */: - case 187 /* ForStatement */: + case 165 /* FunctionExpression */: + case 203 /* FunctionDeclaration */: + case 166 /* ArrowFunction */: + case 136 /* MethodDeclaration */: + case 135 /* MethodSignature */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + case 137 /* Constructor */: + case 188 /* WhileStatement */: + case 187 /* DoStatement */: + case 189 /* ForStatement */: return spanInPreviousNode(node); // Default to parent node default: @@ -43257,19 +43712,19 @@ var ts; } function spanInColonToken(node) { // Is this : specifying return annotation of the function declaration - if (ts.isFunctionLike(node.parent) || node.parent.kind === 225 /* PropertyAssignment */) { + if (ts.isFunctionLike(node.parent) || node.parent.kind === 227 /* PropertyAssignment */) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInGreaterThanOrLessThanToken(node) { - if (node.parent.kind === 161 /* TypeAssertionExpression */) { + if (node.parent.kind === 163 /* TypeAssertionExpression */) { return spanInNode(node.parent.expression); } return spanInNode(node.parent); } function spanInWhileKeyword(node) { - if (node.parent.kind === 185 /* DoStatement */) { + if (node.parent.kind === 187 /* DoStatement */) { // Set span on while expression return textSpan(node, ts.findNextToken(node.parent.expression, node.parent)); } @@ -43320,6 +43775,7 @@ var ts; ScriptSnapshotShimAdapter.prototype.getChangeRange = function (oldSnapshot) { var oldSnapshotShim = oldSnapshot; var encoded = this.scriptSnapshotShim.getChangeRange(oldSnapshotShim.scriptSnapshotShim); + // TODO: should this be '==='? if (encoded == null) { return null; } @@ -43331,12 +43787,18 @@ var ts; var LanguageServiceShimHostAdapter = (function () { function LanguageServiceShimHostAdapter(shimHost) { this.shimHost = shimHost; + this.loggingEnabled = false; + this.tracingEnabled = false; } LanguageServiceShimHostAdapter.prototype.log = function (s) { - this.shimHost.log(s); + if (this.loggingEnabled) { + this.shimHost.log(s); + } }; LanguageServiceShimHostAdapter.prototype.trace = function (s) { - this.shimHost.trace(s); + if (this.tracingEnabled) { + this.shimHost.trace(s); + } }; LanguageServiceShimHostAdapter.prototype.error = function (s) { this.shimHost.error(s); @@ -43348,8 +43810,12 @@ var ts; } return this.shimHost.getProjectVersion(); }; + LanguageServiceShimHostAdapter.prototype.useCaseSensitiveFileNames = function () { + return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false; + }; LanguageServiceShimHostAdapter.prototype.getCompilationSettings = function () { var settingsJson = this.shimHost.getCompilationSettings(); + // TODO: should this be '==='? if (settingsJson == null || settingsJson == "") { throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings"); return null; @@ -43415,13 +43881,13 @@ var ts; return CoreServicesShimHostAdapter; })(); ts.CoreServicesShimHostAdapter = CoreServicesShimHostAdapter; - function simpleForwardCall(logger, actionDescription, action, noPerfLogging) { - if (!noPerfLogging) { + function simpleForwardCall(logger, actionDescription, action, logPerformance) { + if (logPerformance) { logger.log(actionDescription); var start = Date.now(); } var result = action(); - if (!noPerfLogging) { + if (logPerformance) { var end = Date.now(); logger.log(actionDescription + " completed in " + (end - start) + " msec"); if (typeof (result) === "string") { @@ -43434,9 +43900,9 @@ var ts; } return result; } - function forwardJSONCall(logger, actionDescription, action, noPerfLogging) { + function forwardJSONCall(logger, actionDescription, action, logPerformance) { try { - var result = simpleForwardCall(logger, actionDescription, action, noPerfLogging); + var result = simpleForwardCall(logger, actionDescription, action, logPerformance); return JSON.stringify({ result: result }); } catch (err) { @@ -43478,10 +43944,11 @@ var ts; _super.call(this, factory); this.host = host; this.languageService = languageService; + this.logPerformance = false; this.logger = this.host; } LanguageServiceShimObject.prototype.forwardJSONCall = function (actionDescription, action) { - return forwardJSONCall(this.logger, actionDescription, action, false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); }; /// DISPOSE /** @@ -43788,12 +44255,12 @@ var ts; function ClassifierShimObject(factory, logger) { _super.call(this, factory); this.logger = logger; + this.logPerformance = false; this.classifier = ts.createClassifier(); } ClassifierShimObject.prototype.getEncodedLexicalClassifications = function (text, lexState, syntacticClassifierAbsent) { var _this = this; - return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, - /*noPerfLogging:*/ true); + return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, this.logPerformance); }; /// COLORIZATION ClassifierShimObject.prototype.getClassificationsForLine = function (text, lexState, classifyKeywordsInGenerics) { @@ -43815,9 +44282,10 @@ var ts; _super.call(this, factory); this.logger = logger; this.host = host; + this.logPerformance = false; } CoreServicesShimObject.prototype.forwardJSONCall = function (actionDescription, action) { - return forwardJSONCall(this.logger, actionDescription, action, false); + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); }; CoreServicesShimObject.prototype.getPreProcessedFileInfo = function (fileName, sourceTextSnapshot) { return this.forwardJSONCall("getPreProcessedFileInfo('" + fileName + "')", function () { @@ -43874,7 +44342,6 @@ var ts; var TypeScriptServicesFactory = (function () { function TypeScriptServicesFactory() { this._shims = []; - this.documentRegistry = ts.createDocumentRegistry(); } /* * Returns script API version. @@ -43884,6 +44351,9 @@ var ts; }; TypeScriptServicesFactory.prototype.createLanguageServiceShim = function (host) { try { + if (this.documentRegistry === undefined) { + this.documentRegistry = ts.createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames()); + } var hostAdapter = new LanguageServiceShimHostAdapter(host); var languageService = ts.createLanguageService(hostAdapter, this.documentRegistry); return new LanguageServiceShimObject(this, host, languageService); From 25553446ef95cf8f664165e4517794c898797095 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 22 Jun 2015 10:31:00 -0700 Subject: [PATCH 160/309] Misc cleanup --- src/compiler/checker.ts | 193 +++++++------ src/compiler/commandLineParser.ts | 10 +- .../diagnosticInformationMap.generated.ts | 9 +- src/compiler/diagnosticMessages.json | 21 +- src/compiler/parser.ts | 102 ++++--- .../reference/jsxAndTypeAssertion.errors.txt | 13 +- .../reference/jsxAndTypeAssertion.js | 6 +- .../jsxInvalidEsprimaTestSuite.errors.txt | 264 +++++++++++------- .../reference/jsxInvalidEsprimaTestSuite.js | 45 +-- .../tsxAttributeInvalidNames.errors.txt | 43 ++- .../reference/tsxAttributeInvalidNames.js | 13 +- .../tsxElementResolution10.errors.txt | 4 +- .../tsxElementResolution18.errors.txt | 4 +- .../tsxElementResolution8.errors.txt | 8 +- .../reference/tsxOpeningClosingNames.js | 14 + .../reference/tsxOpeningClosingNames.symbols | 20 ++ .../reference/tsxOpeningClosingNames.types | 28 ++ .../jsx/tsxAttributeInvalidNames.tsx | 3 +- .../jsx/tsxOpeningClosingNames.tsx | 11 + 19 files changed, 512 insertions(+), 299 deletions(-) create mode 100644 tests/baselines/reference/tsxOpeningClosingNames.js create mode 100644 tests/baselines/reference/tsxOpeningClosingNames.symbols create mode 100644 tests/baselines/reference/tsxOpeningClosingNames.types create mode 100644 tests/cases/conformance/jsx/tsxOpeningClosingNames.tsx diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3ee4b57b44a..bb3096bf70a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -117,6 +117,7 @@ namespace ts { let globalTemplateStringsArrayType: ObjectType; let globalESSymbolType: ObjectType; let jsxElementType: ObjectType; + /** Lazily loaded, use getJsxIntrinsicElementType() */ let jsxIntrinsicElementsType: ObjectType; let globalIterableType: GenericType; let globalIteratorType: GenericType; @@ -165,11 +166,11 @@ namespace ts { }; let JsxNames = { - JSX: 'JSX', - IntrinsicElements: 'IntrinsicElements', - ElementClass: 'ElementClass', - ElementAttributesPropertyNameContainer: 'ElementAttributesProperty', - Element: 'Element' + JSX: "JSX", + IntrinsicElements: "IntrinsicElements", + ElementClass: "ElementClass", + ElementAttributesPropertyNameContainer: "ElementAttributesProperty", + Element: "Element" }; let subtypeRelation: Map = {}; @@ -3775,7 +3776,11 @@ namespace ts { return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), arity); } - function getExportedTypeOfNamespace(namespace: string, name: string): Type { + /** + * Returns a type that is inside a namespace at the global scope, e.g. + * getExportedTypeFromNamespace('JSX', 'Element') returns the JSX.Element type + */ + function getExportedTypeFromNamespace(namespace: string, name: string): Type { var namespaceSymbol = getGlobalSymbol(namespace, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined); var typeSymbol = namespaceSymbol && getSymbol(namespaceSymbol.exports, name, SymbolFlags.Type); return (typeSymbol && getDeclaredTypeOfSymbol(typeSymbol)) || unknownType; @@ -6334,12 +6339,12 @@ namespace ts { return getTypeOfPropertyOfType(attrsType, attrib.name.text); } } - else if (expr.kind === SyntaxKind.JsxSpreadAttribute) { + + if (expr.kind === SyntaxKind.JsxSpreadAttribute) { return getJsxElementAttributesType(expr.parent); } - else { - return undefined; - } + + return undefined; } // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily @@ -6692,43 +6697,59 @@ namespace ts { return jsxElementType; } + function tagNamesAreEquivalent(lhs: EntityName, rhs: EntityName): boolean { + if(lhs.kind !== rhs.kind) { + return false; + } + if(lhs.kind === SyntaxKind.Identifier) { + return (lhs).text === (rhs).text; + } + return (lhs).right.text === (rhs).right.text && + tagNamesAreEquivalent((lhs).left, (rhs).left); + } + function checkJsxElement(node: JsxElement) { // Check that the closing tag matches - let expectedClosingTag = getTextOfNode(node.openingElement.tagName); - if (expectedClosingTag !== getTextOfNode(node.closingElement.tagName)) { - error(node.closingElement, Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, expectedClosingTag); + if(!tagNamesAreEquivalent(node.openingElement.tagName, node.closingElement.tagName)) { + error(node.closingElement, Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, getTextOfNode(node.openingElement.tagName)); } // Check attributes checkJsxOpeningLikeElement(node.openingElement); // Check children - for (var i = 0, n = node.children.length; i < n; i++) { - if (node.children[i].kind === SyntaxKind.JsxExpression) { - checkJsxExpression(node.children[i]); - } - else if (node.children[i].kind === SyntaxKind.JsxElement) { - checkJsxElement(node.children[i]); - } - else if (node.children[i].kind === SyntaxKind.JsxSelfClosingElement) { - checkJsxSelfClosingElement(node.children[i]); - } - else { - // No checks for JSX Text - Debug.assert(node.children[i].kind === SyntaxKind.JsxText); + let children = node.children; + for (var i = 0, n = children.length; i < n; i++) { + switch (children[i].kind) { + case SyntaxKind.JsxExpression: + checkJsxExpression(children[i]); + break; + case SyntaxKind.JsxElement: + checkJsxElement(children[i]); + break; + case SyntaxKind.JsxSelfClosingElement: + checkJsxSelfClosingElement(children[i]); + break; + default: + // No checks for JSX Text + Debug.assert(children[i].kind === SyntaxKind.JsxText); } } return jsxElementType; } - /// Returns true iff the JSX element name would be a valid identifier, ignoring restrictions about keywords not being identifiers + /** + * Returns true iff the JSX element name would be a valid JS identifier, ignoring restrictions about keywords not being identifiers + */ function isIdentifierLike(name: string) { // - is the only character supported in JSX attribute names that isn't valid in JavaScript identifiers return name.indexOf('-') < 0; } - /// Returns true iff React would emit this tag name as a string rather than an identifier or qualified name + /** + * Returns true iff React would emit this tag name as a string rather than an identifier or qualified name + */ function isJsxIntrinsicIdentifier(tagName: Identifier|QualifiedName) { if (tagName.kind === SyntaxKind.QualifiedName) { return false; @@ -6740,7 +6761,7 @@ namespace ts { } function checkJsxAttribute(node: JsxAttribute, elementAttributesType: Type, nameTable: Map) { - var correspondingPropType: Type = undefined; + let correspondingPropType: Type = undefined; // Look up the corresponding property for this attribute if (elementAttributesType === emptyObjectType && isIdentifierLike(node.name.text)) { @@ -6748,14 +6769,12 @@ namespace ts { error(node.parent, Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, getJsxElementPropertiesName()); } else if (elementAttributesType && !isTypeAny(elementAttributesType)) { - var correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text); + let correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text); correspondingPropType = correspondingPropSymbol && getTypeOfSymbol(correspondingPropSymbol); - if (!correspondingPropType) { // If there's no corresponding property with this name, error - if (isIdentifierLike(node.name.text)) { - error(node.name, Diagnostics.Property_0_does_not_exist_on_type_1, node.name.text, typeToString(elementAttributesType)); - return unknownType; - } + if (!correspondingPropType && isIdentifierLike(node.name.text)) { + error(node.name, Diagnostics.Property_0_does_not_exist_on_type_1, node.name.text, typeToString(elementAttributesType)); + return unknownType; } } @@ -6779,17 +6798,17 @@ namespace ts { function checkJsxSpreadAttribute(node: JsxSpreadAttribute, elementAttributesType: Type, nameTable: Map) { let type = checkExpression(node.expression); let props = getPropertiesOfType(type); - for (var i = 0; i < props.length; i++) { + for(let prop of props) { // Is there a corresponding property in the element attributes type? Skip checking of properties // that have already been assigned to, as these are not actually pushed into the resulting type - if (!nameTable[props[i].name]) { - let targetPropSym = getPropertyOfType(elementAttributesType, props[i].name); + if (!nameTable[prop.name]) { + let targetPropSym = getPropertyOfType(elementAttributesType, prop.name); if (targetPropSym) { - let msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, props[i].name); - checkTypeAssignableTo(getTypeOfSymbol(props[i]), getTypeOfSymbol(targetPropSym), node, undefined, msg); + let msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, prop.name); + checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(targetPropSym), node, undefined, msg); } - nameTable[props[i].name] = true; + nameTable[prop.name] = true; } } } @@ -6813,7 +6832,7 @@ namespace ts { /// Otherwise, returns unknownSymbol. function getJsxElementTagSymbol(node: JsxOpeningLikeElement): Symbol { let flags: JsxFlags = JsxFlags.UnknownElement; - var links = getNodeLinks(node); + let links = getNodeLinks(node); if (!links.resolvedSymbol) { if (isJsxIntrinsicIdentifier(node.tagName)) { links.resolvedSymbol = lookupIntrinsicTag(node); @@ -6827,7 +6846,7 @@ namespace ts { let intrinsicElementsType = getJsxIntrinsicElementsType(); if (intrinsicElementsType !== unknownType) { // Property case - let intrinsicProp = getPropertyOfType(intrinsicElementsType, getTextOfNode(node.tagName)); + let intrinsicProp = getPropertyOfType(intrinsicElementsType, (node.tagName).text); if (intrinsicProp) { links.jsxFlags |= JsxFlags.IntrinsicNamedElement; return intrinsicProp; @@ -6841,7 +6860,7 @@ namespace ts { } // Wasn't found - error(node, Diagnostics.Property_0_does_not_exist_on_type_1, getTextOfNode(node.tagName), 'JSX.' + JsxNames.IntrinsicElements); + error(node, Diagnostics.Property_0_does_not_exist_on_type_1, (node.tagName).text, 'JSX.' + JsxNames.IntrinsicElements); return unknownSymbol; } else { @@ -6852,74 +6871,74 @@ namespace ts { } function lookupClassTag(node: JsxOpeningLikeElement): Symbol { - let valueSym: Symbol; + let valueSymbol: Symbol; // Look up the value in the current scope if (node.tagName.kind === SyntaxKind.Identifier) { - valueSym = getResolvedSymbol(node.tagName); + valueSymbol = getResolvedSymbol(node.tagName); } else { - valueSym = checkQualifiedName(node.tagName).symbol; + valueSymbol = checkQualifiedName(node.tagName).symbol; } - if (valueSym !== unknownSymbol) { + if (valueSymbol !== unknownSymbol) { links.jsxFlags |= JsxFlags.ClassElement; } - return valueSym || unknownSymbol; + return valueSymbol || unknownSymbol; } } - /// Given a JSX element that is a class element, finds the Element Instance Type. If the - /// element is not a class element, or the class element type cannot be determined, returns 'undefined'. - /// For example, in the element , the element instance type is `MyClass` (not `typeof MyClass`). + /** + * Given a JSX element that is a class element, finds the Element Instance Type. If the + * element is not a class element, or the class element type cannot be determined, returns 'undefined'. + * For example, in the element , the element instance type is `MyClass` (not `typeof MyClass`). + */ function getJsxElementInstanceType(node: JsxOpeningLikeElement) { if (!(getNodeLinks(node).jsxFlags & JsxFlags.ClassElement)) { // There is no such thing as an instance type for a non-class element return undefined; } - var classSymbol = getJsxElementTagSymbol(node); + let classSymbol = getJsxElementTagSymbol(node); if (classSymbol === unknownSymbol) { // Couldn't find the class instance type. Error has already been issued return anyType; } - var valueType = getTypeOfSymbol(classSymbol); + let valueType = getTypeOfSymbol(classSymbol); if (isTypeAny(valueType)) { // Short-circuit if the class tag is using an element type 'any' return anyType; } // Resolve the signatures, preferring constructors - var signatures = getSignaturesOfType(valueType, SignatureKind.Construct); + let signatures = getSignaturesOfType(valueType, SignatureKind.Construct); if (signatures.length === 0) { // No construct signatures, try call signatures signatures = getSignaturesOfType(valueType, SignatureKind.Call); + + if (signatures.length === 0) { + // We found no signatures at all, which is an error + error(node.tagName, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node.tagName)); + return undefined; + } } - if (signatures.length === 0) { - // We found no signatures at all, which is an error - error(node.tagName, Diagnostics.JSX_element_0_is_not_a_constructor_function, getTextOfNode(node.tagName)); + + // Check that the constructor/factory returns an object type + let returnType = getUnionType(signatures.map(s => getReturnTypeOfSignature(s))); + if (!isTypeAny(returnType) && !(returnType.flags & TypeFlags.ObjectType)) { + error(node.tagName, Diagnostics.The_return_type_of_a_JSX_element_constructor_must_return_an_object_type); return undefined; } - else { - // Check that the constructor/factory returns an object type - var returnType = getUnionType(signatures.map(s => getReturnTypeOfSignature(s))); - if (!isTypeAny(returnType) && !(returnType.flags & TypeFlags.ObjectType)) { - error(node.tagName, Diagnostics.The_return_type_of_a_JSX_element_constructor_must_return_an_object_type); - return undefined; - } - - // Issue an error if this return type isn't assignable to JSX.ElementClass - // TODO: Move this to a 'check' function - var elemClassType = getJsxGlobalElementClassType(); - if (elemClassType) { - checkTypeRelatedTo(returnType, elemClassType, assignableRelation, node, Diagnostics.JSX_element_0_is_not_a_constructor_function_for_JSX_elements); - } - - return returnType; + // Issue an error if this return type isn't assignable to JSX.ElementClass + let elemClassType = getJsxGlobalElementClassType(); + if (elemClassType) { + checkTypeRelatedTo(returnType, elemClassType, assignableRelation, node, Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements); } + + return returnType; } /// e.g. "props" for React.d.ts, @@ -6954,8 +6973,10 @@ namespace ts { } } - /// Given an opening/self-closing element, get the 'element attributes type', i.e. the type that tells - /// us which attributes are valid on a given element. + /** + * Given an opening/self-closing element, get the 'element attributes type', i.e. the type that tells + * us which attributes are valid on a given element. + */ function getJsxElementAttributesType(node: JsxOpeningLikeElement): Type { let links = getNodeLinks(node); if (!links.resolvedType) { @@ -7011,9 +7032,11 @@ namespace ts { return links.resolvedType; } - /// Given a JSX attribute, returns the symbol for the corresponds property - /// of the element attributes type. Will return unknownSymbol for attributes - /// that have no matching element attributes type property. + /** + * Given a JSX attribute, returns the symbol for the corresponds property + * of the element attributes type. Will return unknownSymbol for attributes + * that have no matching element attributes type property. + */ function getJsxAttributePropertySymbol(attrib: JsxAttribute): Symbol { let attributesType = getJsxElementAttributesType(attrib.parent); let prop = getPropertyOfType(attributesType, attrib.name.text); @@ -7021,7 +7044,7 @@ namespace ts { } function getJsxGlobalElementClassType(): Type { - var jsxNS = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined); + let jsxNS = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined); if (jsxNS) { let sym = getSymbol(jsxNS.exports, JsxNames.ElementClass, SymbolFlags.Type); let elemClassType = sym && getDeclaredTypeOfSymbol(sym); @@ -7053,13 +7076,13 @@ namespace ts { checkGrammarJsxElement(node); checkJsxPreconditions(node); - var targetAttributesType = getJsxElementAttributesType(node); + let targetAttributesType = getJsxElementAttributesType(node); - var nameTable: Map = {}; + let nameTable: Map = {}; // Process this array in right-to-left order so we know which // attributes (mostly from spreads) are being overwritten and // thus should have their types ignored - for (var i = node.attributes.length - 1; i >= 0; i--) { + for (let i = node.attributes.length - 1; i >= 0; i--) { if (node.attributes[i].kind === SyntaxKind.JsxAttribute) { checkJsxAttribute((node.attributes[i]), targetAttributesType, nameTable); } @@ -7072,7 +7095,7 @@ namespace ts { // Check that all required properties have been provided if (targetAttributesType) { let targetProperties = getPropertiesOfType(targetAttributesType); - for (var i = 0; i < targetProperties.length; i++) { + for (let i = 0; i < targetProperties.length; i++) { if (!(targetProperties[i].flags & SymbolFlags.Optional) && nameTable[targetProperties[i].name] === undefined) { @@ -13070,7 +13093,7 @@ namespace ts { globalNumberType = getGlobalType("Number"); globalBooleanType = getGlobalType("Boolean"); globalRegExpType = getGlobalType("RegExp"); - jsxElementType = getExportedTypeOfNamespace("JSX", JsxNames.Element); + jsxElementType = getExportedTypeFromNamespace("JSX", JsxNames.Element); getGlobalClassDecoratorType = memoize(() => getGlobalType("ClassDecorator")); getGlobalPropertyDecoratorType = memoize(() => getGlobalType("PropertyDecorator")); getGlobalMethodDecoratorType = memoize(() => getGlobalType("MethodDecorator")); diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 648724ad94e..021d194b9e8 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -410,17 +410,17 @@ namespace ts { } function getFileNames(): string[] { - var fileNames: string[] = []; + let fileNames: string[] = []; if (hasProperty(json, "files")) { if (json["files"] instanceof Array) { fileNames = map(json["files"], s => combinePaths(basePath, s)); } } else { - var exclude = json["exclude"] instanceof Array ? map(json["exclude"], normalizeSlashes) : undefined; - var sysFiles = host.readDirectory(basePath, ".ts", exclude).concat(host.readDirectory(basePath, ".tsx", exclude)); - for (var i = 0; i < sysFiles.length; i++) { - var name = sysFiles[i]; + let exclude = json["exclude"] instanceof Array ? map(json["exclude"], normalizeSlashes) : undefined; + let sysFiles = host.readDirectory(basePath, ".ts", exclude).concat(host.readDirectory(basePath, ".tsx", exclude)); + for (let i = 0; i < sysFiles.length; i++) { + let name = sysFiles[i]; if (fileExtensionIs(name, ".d.ts")) { let baseName = name.substr(0, name.length - ".d.ts".length); if (!contains(sysFiles, baseName + ".tsx") && !contains(sysFiles, baseName + ".ts")) { diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index bd3737ee4bf..0d908973594 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -393,12 +393,11 @@ namespace ts { The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: { code: 2601, category: DiagnosticCategory.Error, key: "The return type of a JSX element constructor must return an object type." }, The_global_type_JSX_Element_must_exist_when_using_JSX: { code: 2602, category: DiagnosticCategory.Error, key: "The global type 'JSX.Element' must exist when using JSX." }, Property_0_in_type_1_is_not_assignable_to_type_2: { code: 2603, category: DiagnosticCategory.Error, key: "Property '{0}' in type '{1}' is not assignable to type '{2}'" }, - JSX_element_0_is_not_a_constructor_function: { code: 2604, category: DiagnosticCategory.Error, key: "JSX element '{0}' is not a constructor function." }, - JSX_element_0_is_not_a_constructor_function_for_JSX_elements: { code: 2605, category: DiagnosticCategory.Error, key: "JSX element '{0}' is not a constructor function for JSX elements." }, + JSX_element_type_0_does_not_have_any_construct_or_call_signatures: { code: 2604, category: DiagnosticCategory.Error, key: "JSX element type '{0}' does not have any construct or call signatures." }, + JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements: { code: 2605, category: DiagnosticCategory.Error, key: "JSX element type '{0}' is not a constructor function for JSX elements." }, Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: { code: 2606, category: DiagnosticCategory.Error, key: "Property '{0}' of JSX spread attribute is not assignable to target property." }, JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: { code: 2607, category: DiagnosticCategory.Error, key: "JSX element class does not support attributes because it does not have a '{0}' property" }, The_global_type_JSX_0_may_not_have_more_than_one_property: { code: 2608, category: DiagnosticCategory.Error, key: "The global type 'JSX.{0}' may not have more than one property" }, - JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 2609, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because no interface JSX.{0} exists" }, Cannot_emit_namespaced_JSX_elements_in_React: { code: 2650, category: DiagnosticCategory.Error, key: "Cannot emit namespaced JSX elements in React" }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, @@ -543,7 +542,7 @@ namespace ts { NEWLINE: { code: 6061, category: DiagnosticCategory.Message, key: "NEWLINE" }, Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." }, Specifies_how_to_transform_JSX_syntax_during_compilation: { code: 6080, category: DiagnosticCategory.Message, key: "Specifies how to transform JSX syntax during compilation." }, - Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: DiagnosticCategory.Message, key: "Argument for --jsx must be 'preserve' or 'react'." }, + Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: DiagnosticCategory.Message, key: "Argument for '--jsx' must be 'preserve' or 'react'." }, Option_experimentalDecorators_must_also_be_specified_when_option_emitDecoratorMetadata_is_specified: { code: 6064, category: DiagnosticCategory.Error, key: "Option 'experimentalDecorators' must also be specified when option 'emitDecoratorMetadata' is specified." }, Enables_experimental_support_for_ES7_decorators: { code: 6065, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 decorators." }, Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: DiagnosticCategory.Message, key: "Enables experimental support for emitting type metadata for decorators." }, @@ -563,6 +562,7 @@ namespace ts { _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7023, category: DiagnosticCategory.Error, key: "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." }, Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: DiagnosticCategory.Error, key: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." }, Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: DiagnosticCategory.Error, key: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." }, + JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" }, You_cannot_rename_this_element: { code: 8000, category: DiagnosticCategory.Error, key: "You cannot rename this element." }, You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: DiagnosticCategory.Error, key: "You cannot rename elements that are defined in the standard TypeScript library." }, import_can_only_be_used_in_a_ts_file: { code: 8002, category: DiagnosticCategory.Error, key: "'import ... =' can only be used in a .ts file." }, @@ -582,7 +582,6 @@ namespace ts { decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." }, - class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration: { code: 9004, category: DiagnosticCategory.Error, key: "'class' declarations are only supported directly inside a module or as a top level declaration." }, JSX_attributes_must_only_be_assigned_a_non_empty_expression: { code: 17000, category: DiagnosticCategory.Error, key: "JSX attributes must only be assigned a non-empty 'expression'." }, JSX_elements_cannot_have_multiple_attributes_with_the_same_name: { code: 17001, category: DiagnosticCategory.Error, key: "JSX elements cannot have multiple attributes with the same name." }, Expected_corresponding_JSX_closing_tag_for_0: { code: 17002, category: DiagnosticCategory.Error, key: "Expected corresponding JSX closing tag for '{0}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 23ab3b89f70..21e352af339 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1562,11 +1562,11 @@ "category": "Error", "code": 2603 }, - "JSX element '{0}' is not a constructor function.": { + "JSX element type '{0}' does not have any construct or call signatures.": { "category": "Error", "code": 2604 }, - "JSX element '{0}' is not a constructor function for JSX elements.": { + "JSX element type '{0}' is not a constructor function for JSX elements.": { "category": "Error", "code": 2605 }, @@ -1582,11 +1582,6 @@ "category": "Error", "code": 2608 }, - "JSX element implicitly has type 'any' because no interface JSX.{0} exists": { - "category": "Error", - "code": 2609 - }, - "Cannot emit namespaced JSX elements in React": { "category": "Error", "code": 2650 @@ -2165,7 +2160,7 @@ "category": "Message", "code": 6080 }, - "Argument for --jsx must be 'preserve' or 'react'.": { + "Argument for '--jsx' must be 'preserve' or 'react'.": { "category": "Message", "code": 6081 }, @@ -2246,6 +2241,12 @@ "category": "Error", "code": 7025 }, + "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists": { + "category": "Error", + "code": 7026 + }, + + "You cannot rename this element.": { "category": "Error", "code": 8000 @@ -2323,10 +2324,6 @@ "category": "Error", "code": 9003 }, - "'class' declarations are only supported directly inside a module or as a top level declaration.": { - "category": "Error", - "code": 9004 - }, "JSX attributes must only be assigned a non-empty 'expression'.": { "category": "Error", "code": 17000 diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index d89ab3a771b..adb2ba0e206 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1205,7 +1205,7 @@ namespace ts { case ParsingContext.JsxAttributes: return isIdentifierOrKeyword() || token === SyntaxKind.OpenBraceToken; case ParsingContext.JsxChildren: - return token === SyntaxKind.LessThanToken || token === SyntaxKind.OpenBraceToken || token === SyntaxKind.JsxText; + return true; case ParsingContext.JSDocFunctionParameters: case ParsingContext.JSDocTypeArguments: case ParsingContext.JSDocTupleTypes: @@ -1297,10 +1297,10 @@ namespace ts { case ParsingContext.HeritageClauses: return token === SyntaxKind.OpenBraceToken || token === SyntaxKind.CloseBraceToken; case ParsingContext.JsxAttributes: - // For error recovery, include } here (otherwise an over-braced {expr}} will close the surrounding statement block and mess up the entire file). - return token === SyntaxKind.GreaterThanToken || token === SyntaxKind.SlashToken || token === SyntaxKind.CloseBraceToken; + // REMOVE -> // For error recovery, include } here (otherwise an over-braced {expr}} will close the surrounding statement block and mess up the entire file). + return token === SyntaxKind.GreaterThanToken || token === SyntaxKind.SlashToken; case ParsingContext.JsxChildren: - return token === SyntaxKind.LessThanSlashToken; + return token === SyntaxKind.LessThanToken && lookAhead(nextTokenIsSlash); case ParsingContext.JSDocFunctionParameters: return token === SyntaxKind.CloseParenToken || token === SyntaxKind.ColonToken || token === SyntaxKind.CloseBraceToken; case ParsingContext.JSDocTypeArguments: @@ -3113,7 +3113,13 @@ namespace ts { case SyntaxKind.VoidKeyword: return parseVoidExpression(); case SyntaxKind.LessThanToken: - return sourceFile.isTSXFile ? parseJsxElementOrSelfClosingElement() : parseTypeAssertion(); + if (!sourceFile.isTSXFile) { + return parseTypeAssertion(); + } + if(lookAhead(nextTokenIsIdentifier)) { + return parseJsxElementOrSelfClosingElement(); + } + // Fall through default: return parsePostfixExpressionOrHigher(); } @@ -3241,36 +3247,14 @@ namespace ts { return finishNode(node); } - function parseJsxChild(): JsxChild { - let result: JsxChild = undefined; - switch (token) { - case SyntaxKind.JsxText: - result = createNode(SyntaxKind.JsxText); - token = scanner.scanJsxToken(); - result = finishNode(result); - break; - case SyntaxKind.OpenBraceToken: - result = parseJsxExpression(); - break; - default: - Debug.assert(token === SyntaxKind.LessThanToken); - result = parseJsxElementOrSelfClosingElement(); - break; - } - token = scanner.reScanJsxToken(); - Debug.assert(result !== undefined, "parsed some JSX child"); - return result; - } - function parseJsxElementOrSelfClosingElement(): JsxElement|JsxSelfClosingElement { let opening = parseJsxOpeningOrSelfClosingElement(); if (opening.kind === SyntaxKind.JsxOpeningElement) { let node = createNode(SyntaxKind.JsxElement, opening.pos); node.openingElement = opening; - // Rescan since parsing the > messed up the scanner state - token = scanner.reScanJsxToken(); - node.children = parseList(ParsingContext.JsxChildren, parseJsxChild); + debugger; + node.children = parseJsxChildren(node.openingElement.tagName); node.closingElement = parseJsxClosingElement(); return finishNode(node); } @@ -3280,6 +3264,49 @@ namespace ts { return opening; } } + + function parseJsxText(): JsxText { + let node = createNode(SyntaxKind.JsxText, scanner.getStartPos()); + token = scanner.scanJsxToken(); + return finishNode(node); + } + + function parseJsxChild(): JsxChild { + switch (token) { + case SyntaxKind.JsxText: + return parseJsxText(); + case SyntaxKind.OpenBraceToken: + return parseJsxExpression(); + case SyntaxKind.LessThanToken: + return parseJsxElementOrSelfClosingElement(); + } + Debug.fail('Unknown JSX child kind ' + token); + } + + function parseJsxChildren(openingTagName: EntityName): NodeArray { + let result = >[]; + result.pos = scanner.getStartPos(); + let saveParsingContext = parsingContext; + parsingContext |= 1 << ParsingContext.JsxChildren; + + while(true) { + token = scanner.reScanJsxToken(); + if (token === SyntaxKind.LessThanSlashToken) { + break; + } + else if (token === SyntaxKind.EndOfFileToken) { + parseErrorAtCurrentToken(Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, getTextOfNodeFromSourceText(sourceText, openingTagName)); + break; + } + result.push(parseJsxChild()); + } + + result.end = scanner.getTokenPos(); + + parsingContext = saveParsingContext; + + return result; + } function parseJsxOpeningOrSelfClosingElement(): JsxOpeningElement|JsxSelfClosingElement { let fullStart = scanner.getStartPos(); @@ -3287,17 +3314,18 @@ namespace ts { parseExpected(SyntaxKind.LessThanToken); let tagName = parseJsxElementName(); + let attributes = parseList(ParsingContext.JsxAttributes, parseJsxAttribute); let node: JsxOpeningLikeElement; - if (token === SyntaxKind.SlashToken) { - node = createNode(SyntaxKind.JsxSelfClosingElement, fullStart); - nextToken(); + if (parseOptional(SyntaxKind.GreaterThanToken)) { + node = createNode(SyntaxKind.JsxOpeningElement, fullStart); } else { - node = createNode(SyntaxKind.JsxOpeningElement, fullStart); - } - parseExpected(SyntaxKind.GreaterThanToken); + parseExpected(SyntaxKind.SlashToken); + parseExpected(SyntaxKind.GreaterThanToken); + node = createNode(SyntaxKind.JsxSelfClosingElement, fullStart); + } node.tagName = tagName; node.attributes = attributes; @@ -4818,6 +4846,10 @@ namespace ts { return nextToken() === SyntaxKind.OpenParenToken; } + function nextTokenIsSlash() { + return nextToken() === SyntaxKind.SlashToken; + } + function nextTokenIsCommaOrFromKeyword() { nextToken(); return token === SyntaxKind.CommaToken || diff --git a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt index 8e7132007d8..ead030952a5 100644 --- a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt +++ b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt @@ -60,15 +60,14 @@ tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expect !!! error TS1005: '}' expected. x = {}}>hello; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1005: '}' expected. - x = {}}>hello{{}}; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. @@ -78,9 +77,7 @@ tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expect !!! error TS1005: '}' expected. - x = x, x = ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. @@ -88,10 +85,8 @@ tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expect !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - {{/foo/.test(x) ? : }} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~~~ @@ -108,14 +103,10 @@ tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expect !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ~~~~ ~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. !!! error TS1005: ':' expected. diff --git a/tests/baselines/reference/jsxAndTypeAssertion.js b/tests/baselines/reference/jsxAndTypeAssertion.js index 26af23a2051..0b402b43de2 100644 --- a/tests/baselines/reference/jsxAndTypeAssertion.js +++ b/tests/baselines/reference/jsxAndTypeAssertion.js @@ -35,7 +35,9 @@ x = ; x = hello {} }; -x = }>hello} x=}>hello{}}; +x = }>hello}/>; + +x = }>hello{}}; x = x, x = ; @@ -44,4 +46,4 @@ x = x, x = ; } -}}>>; +}}/>; diff --git a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt index 7f3d60f8361..9cef517fa1b 100644 --- a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt +++ b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt @@ -1,49 +1,66 @@ -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,2): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,3): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,2): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,1): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,3): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,3): error TS1005: ';' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,6): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,2): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,3): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,6): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,7): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,6): error TS1005: '{' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,6): error TS2304: Cannot find name 'd'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,9): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,10): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,1): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,4): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(8,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(8,4): error TS17002: Expected corresponding JSX closing tag for 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(9,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(9,13): error TS1002: Unterminated string literal. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,1): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,3): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,6): error TS17002: Expected corresponding JSX closing tag for 'a'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,3): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,5): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,11): error TS1005: '>' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,3): error TS1005: ';' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,4): error TS2304: Cannot find name 'b'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,4): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,6): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,8): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,3): error TS1005: ';' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,4): error TS2304: Cannot find name 'b'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,4): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,8): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,10): error TS1161: Unterminated regular expression literal. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,2): error TS2304: Cannot find name 'a'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,5): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,13): error TS1005: '>' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,5): error TS1005: ';' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2304: Cannot find name 'c'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,8): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,10): error TS1161: Unterminated regular expression literal. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,2): error TS2304: Cannot find name 'a'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,8): error TS17002: Expected corresponding JSX closing tag for 'a.b.c'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,2): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,7): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,8): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,10): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,2): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,5): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,7): error TS1161: Unterminated regular expression literal. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,2): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,4): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,9): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,3): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,12): error TS1005: '>' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,3): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,14): error TS1005: '>' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,5): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,7): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,4): error TS2304: Cannot find name 'foo'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,9): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,11): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,11): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,13): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,2): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,4): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(19,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(20,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. @@ -76,29 +93,33 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,7): error TS1003: tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(34,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,4): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS1005: '; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~ -!!! error TS1003: Identifier expected. + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. ; - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~ -!!! error TS1003: Identifier expected. - <:a />; - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ -!!! error TS1003: Identifier expected. +!!! error TS2304: Cannot find name 'a'. + ~ +!!! error TS1005: ';' expected. + +!!! error TS1161: Unterminated regular expression literal. + <:a />; + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS2304: Cannot find name 'a'. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1109: Expression expected. ; ~~~~~~~~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. @@ -113,8 +134,10 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 ; ~ !!! error TS1003: Identifier expected. - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS2304: Cannot find name 'a'. + ~ +!!! error TS1109: Expression expected. ; ~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. @@ -128,70 +151,111 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 ; ~ !!! error TS1003: Identifier expected. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS2304: Cannot find name 'a'. ~ -!!! error TS1003: Identifier expected. - ~~~~ -!!! error TS17002: Expected corresponding JSX closing tag for 'a'. +!!! error TS1005: ';' expected. + ~ +!!! error TS2304: Cannot find name 'b'. + ~~~~~~~ +!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. ; - ~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS2304: Cannot find name 'a'. ~ -!!! error TS1003: Identifier expected. - ~ -!!! error TS1003: Identifier expected. - ~ -!!! error TS1005: '>' expected. +!!! error TS1005: ';' expected. + ~ +!!! error TS2304: Cannot find name 'b'. + ~~~~~~~~~~~~~ +!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. ; - ~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS2304: Cannot find name 'a'. ~ -!!! error TS1003: Identifier expected. - ~ -!!! error TS1005: '>' expected. +!!! error TS1005: ';' expected. + ~ +!!! error TS2304: Cannot find name 'c'. + ~~~~~~~~~~~ +!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. + ~~~~~~~~~~~ + ~~~~~~~~~~~ + ~~~~~~~~~~~ + ~~~~~~~~~~~ + ~~~~~~~~~~~ + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. ; - ~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~~~~~~~ +!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. + ~~~~~~~~~~~~ + ~~~~~~~~~~~~ + ~~~~~~~~~~~~ + ~~~~~~~~~~~~ ~ !!! error TS2304: Cannot find name 'a'. - ~~~~ -!!! error TS17002: Expected corresponding JSX closing tag for 'a.b.c'. + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. <.a>; - ~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~~~~~ +!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. + ~~~~~~~~~~ + ~~~~~~~~~~ + ~~~~~~~~~~ ~ -!!! error TS1003: Identifier expected. - ~ -!!! error TS1003: Identifier expected. +!!! error TS1109: Expression expected. + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. ; - ~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~~~~~~~~~~ +!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. + ~~~~~~~~~~ + ~~~~~~~~~~ ~ !!! error TS2304: Cannot find name 'a'. ~ !!! error TS1003: Identifier expected. - ~ -!!! error TS1003: Identifier expected. + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. ; - ~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~ -!!! error TS1003: Identifier expected. - ~ -!!! error TS1005: '>' expected. + ~~~~~~~~~~~~~~~~~~ +!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. + ~~~~~~~~~~~~~~~~~~ + ~ +!!! error TS2304: Cannot find name 'a'. + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. ; - ~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~ -!!! error TS1003: Identifier expected. - ~ -!!! error TS1005: '>' expected. + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. + ~ +!!! error TS2304: Cannot find name 'a'. + ~ +!!! error TS1109: Expression expected. + +!!! error TS1161: Unterminated regular expression literal. ; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS2304: Cannot find name 'a'. ~~~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ; @@ -213,7 +277,7 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 ~ !!! error TS1005: '}' expected. ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1003: Identifier expected. @@ -259,25 +323,19 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 ~ !!! error TS1005: '{' expected. ; - ~~~~~~~~~ + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1003: Identifier expected. }; - ~~~~~~~~~ ~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ; - ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~~~~~~~~~~~~~~~ + ~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~ !!! error TS1003: Identifier expected. -!!! error TS1005: 'one
/* intervening comment */
two
;; ; //// [jsxInvalidEsprimaTestSuite.jsx] -< />; -; -< a=/>; - }> -; -; - + < a; +b > < /b>; + < a; +b.c > < /a:b.c>; + < a.b; +c > < /a.b:c>; + < a.b.c > < /a>; + < .a > < /.a>; + < a. > < /a.>; + < a[foo] > < /a[foo]>; + < a['foo'] > < /a['foo']>; + < a > ; ; var x =
one
two
;; var x =
one
/* intervening comment */ /* intervening comment */
two
;; {"str"};}; -; -
"app">; +, id="b" />; +
"app">;
;
stuff
{}...props}>; @@ -66,6 +71,6 @@ var x =
one
/* intervening comment */ /* intervening comment */
>; >; ; -}>; +/>}>; }; -;>; + .../*hai*/asdf/>;; diff --git a/tests/baselines/reference/tsxAttributeInvalidNames.errors.txt b/tests/baselines/reference/tsxAttributeInvalidNames.errors.txt index 055062237d8..90d0d003c28 100644 --- a/tests/baselines/reference/tsxAttributeInvalidNames.errors.txt +++ b/tests/baselines/reference/tsxAttributeInvalidNames.errors.txt @@ -1,14 +1,23 @@ -tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx(9,8): error TS1003: Identifier expected. tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx(10,8): error TS1003: Identifier expected. -tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx(10,22): error TS1005: '; ~~ !!! error TS1003: Identifier expected. - ; + ~~~~ +!!! error TS1005: ';' expected. + ~~~~ +!!! error TS2304: Cannot find name 'data'. + ~~~~ +!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. + ~ +!!! error TS1005: ':' expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1109: Expression expected. + ; + ~~~~~~ +!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. ~ !!! error TS1003: Identifier expected. - -!!! error TS1005: '; -; +; //// [tsxAttributeInvalidNames.jsx] // Invalid names - 32data={32} />; - -data={32} />;; +; +32; +data = { 32: } / > ; + - data; +{ + 32; +} +/>;; diff --git a/tests/baselines/reference/tsxElementResolution10.errors.txt b/tests/baselines/reference/tsxElementResolution10.errors.txt index 987851191c5..6dcee7d18fa 100644 --- a/tests/baselines/reference/tsxElementResolution10.errors.txt +++ b/tests/baselines/reference/tsxElementResolution10.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/jsx/tsxElementResolution10.tsx(13,1): error TS2605: JSX element '{ x: number; }' is not a constructor function for JSX elements. +tests/cases/conformance/jsx/tsxElementResolution10.tsx(13,1): error TS2605: JSX element type '{ x: number; }' is not a constructor function for JSX elements. Property 'render' is missing in type '{ x: number; }'. @@ -17,7 +17,7 @@ tests/cases/conformance/jsx/tsxElementResolution10.tsx(13,1): error TS2605: JSX var Obj1: Obj1type; ; // Error, no render member ~~~~~~~~~~~~~~~ -!!! error TS2605: JSX element '{ x: number; }' is not a constructor function for JSX elements. +!!! error TS2605: JSX element type '{ x: number; }' is not a constructor function for JSX elements. !!! error TS2605: Property 'render' is missing in type '{ x: number; }'. interface Obj2type { diff --git a/tests/baselines/reference/tsxElementResolution18.errors.txt b/tests/baselines/reference/tsxElementResolution18.errors.txt index 75d28616bf0..a4728b2f749 100644 --- a/tests/baselines/reference/tsxElementResolution18.errors.txt +++ b/tests/baselines/reference/tsxElementResolution18.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/jsx/tsxElementResolution18.tsx(6,1): error TS2609: JSX element implicitly has type 'any' because no interface JSX.IntrinsicElements exists +tests/cases/conformance/jsx/tsxElementResolution18.tsx(6,1): error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists ==== tests/cases/conformance/jsx/tsxElementResolution18.tsx (1 errors) ==== @@ -9,5 +9,5 @@ tests/cases/conformance/jsx/tsxElementResolution18.tsx(6,1): error TS2609: JSX e // Error under implicit any
; ~~~~~~~~~~~~~ -!!! error TS2609: JSX element implicitly has type 'any' because no interface JSX.IntrinsicElements exists +!!! error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution8.errors.txt b/tests/baselines/reference/tsxElementResolution8.errors.txt index 644b43b471b..5710c4e177d 100644 --- a/tests/baselines/reference/tsxElementResolution8.errors.txt +++ b/tests/baselines/reference/tsxElementResolution8.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/jsx/tsxElementResolution8.tsx(8,2): error TS2604: JSX element 'Div' is not a constructor function. +tests/cases/conformance/jsx/tsxElementResolution8.tsx(8,2): error TS2604: JSX element type 'Div' does not have any construct or call signatures. tests/cases/conformance/jsx/tsxElementResolution8.tsx(16,2): error TS2601: The return type of a JSX element constructor must return an object type. tests/cases/conformance/jsx/tsxElementResolution8.tsx(29,2): error TS2601: The return type of a JSX element constructor must return an object type. -tests/cases/conformance/jsx/tsxElementResolution8.tsx(34,2): error TS2604: JSX element 'Obj3' is not a constructor function. +tests/cases/conformance/jsx/tsxElementResolution8.tsx(34,2): error TS2604: JSX element type 'Obj3' does not have any construct or call signatures. ==== tests/cases/conformance/jsx/tsxElementResolution8.tsx (4 errors) ==== @@ -14,7 +14,7 @@ tests/cases/conformance/jsx/tsxElementResolution8.tsx(34,2): error TS2604: JSX e var Div = 3;
; ~~~ -!!! error TS2604: JSX element 'Div' is not a constructor function. +!!! error TS2604: JSX element type 'Div' does not have any construct or call signatures. // OK function Fact(): any { return null; } @@ -46,5 +46,5 @@ tests/cases/conformance/jsx/tsxElementResolution8.tsx(34,2): error TS2604: JSX e var Obj3: Obj3; ; // Error ~~~~ -!!! error TS2604: JSX element 'Obj3' is not a constructor function. +!!! error TS2604: JSX element type 'Obj3' does not have any construct or call signatures. \ No newline at end of file diff --git a/tests/baselines/reference/tsxOpeningClosingNames.js b/tests/baselines/reference/tsxOpeningClosingNames.js new file mode 100644 index 00000000000..80adad0f406 --- /dev/null +++ b/tests/baselines/reference/tsxOpeningClosingNames.js @@ -0,0 +1,14 @@ +//// [tsxOpeningClosingNames.tsx] +declare module JSX { + interface Element { } +} + +declare module A.B.C { + var D: any; +} + +foo + + +//// [tsxOpeningClosingNames.jsx] +foo; diff --git a/tests/baselines/reference/tsxOpeningClosingNames.symbols b/tests/baselines/reference/tsxOpeningClosingNames.symbols new file mode 100644 index 00000000000..3ff2a3ff68d --- /dev/null +++ b/tests/baselines/reference/tsxOpeningClosingNames.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/jsx/tsxOpeningClosingNames.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxOpeningClosingNames.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxOpeningClosingNames.tsx, 0, 20)) +} + +declare module A.B.C { +>A : Symbol(A, Decl(tsxOpeningClosingNames.tsx, 2, 1)) +>B : Symbol(B, Decl(tsxOpeningClosingNames.tsx, 4, 17)) +>C : Symbol(C, Decl(tsxOpeningClosingNames.tsx, 4, 19)) + + var D: any; +>D : Symbol(D, Decl(tsxOpeningClosingNames.tsx, 5, 5)) +} + +foo +>D : Symbol(unknown) + diff --git a/tests/baselines/reference/tsxOpeningClosingNames.types b/tests/baselines/reference/tsxOpeningClosingNames.types new file mode 100644 index 00000000000..b02564ae104 --- /dev/null +++ b/tests/baselines/reference/tsxOpeningClosingNames.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/jsx/tsxOpeningClosingNames.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element +} + +declare module A.B.C { +>A : typeof A +>B : typeof B +>C : typeof C + + var D: any; +>D : any +} + +foo +>foo : JSX.Element +>A : any +>B : any +>C : any +>D : any +>A : any +>B : any +>C : any +>D : any + diff --git a/tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx b/tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx index a3a8d293535..4471c5a9c92 100644 --- a/tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx +++ b/tests/cases/conformance/jsx/tsxAttributeInvalidNames.tsx @@ -4,9 +4,10 @@ declare module JSX { interface Element { } interface IntrinsicElements { test1: { "data-foo"?: string }; + test2: { "data-foo"?: string }; } } // Invalid names ; -; \ No newline at end of file +; \ No newline at end of file diff --git a/tests/cases/conformance/jsx/tsxOpeningClosingNames.tsx b/tests/cases/conformance/jsx/tsxOpeningClosingNames.tsx new file mode 100644 index 00000000000..8f21517474f --- /dev/null +++ b/tests/cases/conformance/jsx/tsxOpeningClosingNames.tsx @@ -0,0 +1,11 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } +} + +declare module A.B.C { + var D: any; +} + +foo From e448d8b9320b61fa9e9a5b846d8139ac9bbf6082 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 22 Jun 2015 11:53:38 -0700 Subject: [PATCH 161/309] Treat (s.languageVariant === LanguageVariant.JSX && !jsxDesugaring); if (targetSourceFile === undefined) { forEach(host.getSourceFiles(), sourceFile => { if (shouldEmitToOwnFile(sourceFile, compilerOptions)) { - let jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, (!sourceFile.isTSXFile || jsxDesugaring) ? ".js" : ".jsx"); + let jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, shouldEmitJsx(sourceFile) ? ".jsx" : ".js"); emitFile(jsFilePath, sourceFile); } }); @@ -70,7 +71,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { else { // targetSourceFile is specified (e.g calling emitter from language service or calling getSemanticDiagnostic from language service) if (shouldEmitToOwnFile(targetSourceFile, compilerOptions)) { - let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, (host.getSourceFiles().every(f => !f.isTSXFile) || jsxDesugaring) ? ".js" : ".jsx"); + let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, host.getSourceFiles().some(shouldEmitJsx) ? ".jsx" : ".js"); emitFile(jsFilePath, targetSourceFile); } else if (!isDeclarationFile(targetSourceFile) && compilerOptions.out) { diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index adb2ba0e206..6da63a4f18e 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -544,6 +544,7 @@ namespace ts { scanner.setText(sourceText); scanner.setOnError(scanError); scanner.setScriptTarget(languageVersion); + scanner.setLanguageVariant(isTsx(fileName) ? LanguageVariant.JSX : LanguageVariant.Standard); } function clearState() { @@ -656,7 +657,7 @@ namespace ts { sourceFile.languageVersion = languageVersion; sourceFile.fileName = normalizePath(fileName); sourceFile.flags = fileExtensionIs(sourceFile.fileName, ".d.ts") ? NodeFlags.DeclarationFile : 0; - sourceFile.isTSXFile = fileExtensionIs(sourceFile.fileName, ".tsx"); + sourceFile.languageVariant = fileExtensionIs(sourceFile.fileName, ".tsx") ? LanguageVariant.JSX : LanguageVariant.Standard; return sourceFile; } @@ -2839,7 +2840,7 @@ namespace ts { } // JSX overrides - if (sourceFile.isTSXFile) { + if (sourceFile.languageVariant === LanguageVariant.JSX) { let isArrowFunctionInJsx = lookAhead(() => { let third = nextToken(); let fourth = nextToken(); @@ -3113,7 +3114,7 @@ namespace ts { case SyntaxKind.VoidKeyword: return parseVoidExpression(); case SyntaxKind.LessThanToken: - if (!sourceFile.isTSXFile) { + if (sourceFile.languageVariant !== LanguageVariant.JSX) { return parseTypeAssertion(); } if(lookAhead(nextTokenIsIdentifier)) { @@ -5050,7 +5051,7 @@ namespace ts { } function processReferenceComments(sourceFile: SourceFile): void { - let triviaScanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/false, sourceText); + let triviaScanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/false, LanguageVariant.Standard, sourceText); let referencedFiles: FileReference[] = []; let amdDependencies: { path: string; name: string }[] = []; let amdModuleName: string; diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 4ce0dadc1cd..1cae922f082 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -30,6 +30,7 @@ namespace ts { setText(text: string, start?: number, length?: number): void; setOnError(onError: ErrorCallback): void; setScriptTarget(scriptTarget: ScriptTarget): void; + setLanguageVariant(variant: LanguageVariant): void; setTextPos(textPos: number): void; // Invokes the provided callback then unconditionally restores the scanner to the state it // was in immediately prior to invoking the callback. The result of invoking the callback @@ -630,6 +631,7 @@ namespace ts { // Creates a scanner over a (possibly unspecified) range of a piece of text. export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, + languageVariant = LanguageVariant.Standard, text?: string, onError?: ErrorCallback, start?: number, @@ -675,6 +677,7 @@ namespace ts { scan, setText, setScriptTarget, + setLanguageVariant, setOnError, setTextPos, tryScan, @@ -1309,6 +1312,9 @@ namespace ts { if (text.charCodeAt(pos + 1) === CharacterCodes.equals) { return pos += 2, token = SyntaxKind.LessThanEqualsToken; } + if (text.charCodeAt(pos + 1) === CharacterCodes.slash && languageVariant === LanguageVariant.JSX) { + return pos += 2, token = SyntaxKind.LessThanSlashToken; + } return pos++, token = SyntaxKind.LessThanToken; case CharacterCodes.equals: if (isConflictMarkerTrivia(text, pos)) { @@ -1588,6 +1594,10 @@ namespace ts { languageVersion = scriptTarget; } + function setLanguageVariant(variant: LanguageVariant) { + languageVariant = variant; + } + function setTextPos(textPos: number) { Debug.assert(textPos >= 0); pos = textPos; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index d78d38d5ba7..3a34137a2b4 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1223,7 +1223,7 @@ namespace ts { amdDependencies: {path: string; name: string}[]; moduleName: string; referencedFiles: FileReference[]; - isTSXFile: boolean; + languageVariant: LanguageVariant; /** * lib.d.ts should have a reference comment like @@ -1988,6 +1988,11 @@ namespace ts { Latest = ES6, } + export const enum LanguageVariant { + Standard, + JSX + } + export interface ParsedCommandLine { options: CompilerOptions; fileNames: string[]; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 7ec599babbc..29f91e8c502 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -274,7 +274,7 @@ namespace ts { } export function getSpanOfTokenAtPosition(sourceFile: SourceFile, pos: number): TextSpan { - let scanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/ true, sourceFile.text, /*onError:*/ undefined, pos); + let scanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/ true, sourceFile.languageVariant, sourceFile.text, /*onError:*/ undefined, pos); scanner.scan(); let start = scanner.getTokenPos(); return createTextSpanFromBounds(start, scanner.getTextPos()); @@ -1957,6 +1957,10 @@ namespace ts { return fileExtensionIs(fileName, ".js"); } + export function isTsx(fileName: string) { + return fileExtensionIs(fileName, ".tsx"); + } + /** * Replace each instance of non-ascii characters by one, two, three, or four escape sequences * representing the UTF-8 encoding of the character, and return the expanded char code list. diff --git a/src/services/services.ts b/src/services/services.ts index 7e1aba31d54..cc35eca49dd 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -737,7 +737,6 @@ namespace ts { public amdDependencies: { name: string; path: string }[]; public moduleName: string; public referencedFiles: FileReference[]; - public isTSXFile: boolean; public syntacticDiagnostics: Diagnostic[]; public referenceDiagnostics: Diagnostic[]; @@ -752,6 +751,7 @@ namespace ts { public symbolCount: number; public version: string; public languageVersion: ScriptTarget; + public languageVariant: LanguageVariant; public identifiers: Map; public nameTable: Map; @@ -2916,7 +2916,7 @@ namespace ts { else if (contextToken && contextToken.kind === SyntaxKind.DotToken && contextToken.parent.kind === SyntaxKind.QualifiedName) { node = (contextToken.parent).left; isRightOfDot = true; - } else if (contextToken && contextToken.kind === SyntaxKind.LessThanToken && sourceFile.isTSXFile) { + } else if (contextToken && contextToken.kind === SyntaxKind.LessThanToken && sourceFile.languageVariant === LanguageVariant.JSX) { isRightOfOpenTag = true; location = contextToken; } @@ -6167,8 +6167,8 @@ namespace ts { let spanLength = span.length; // Make a scanner we can get trivia from. - let triviaScanner = createScanner(ScriptTarget.Latest, /*skipTrivia:*/ false, sourceFile.text); - let mergeConflictScanner = createScanner(ScriptTarget.Latest, /*skipTrivia:*/ false, sourceFile.text); + let triviaScanner = createScanner(ScriptTarget.Latest, /*skipTrivia:*/ false, sourceFile.languageVariant, sourceFile.text); + let mergeConflictScanner = createScanner(ScriptTarget.Latest, /*skipTrivia:*/ false, sourceFile.languageVariant, sourceFile.text); let result: number[] = []; processElement(sourceFile); diff --git a/tests/baselines/reference/tsxErrorRecovery1.errors.txt b/tests/baselines/reference/tsxErrorRecovery1.errors.txt new file mode 100644 index 00000000000..dc4f4d51afe --- /dev/null +++ b/tests/baselines/reference/tsxErrorRecovery1.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/jsx/tsxErrorRecovery1.tsx(5,19): error TS1109: Expression expected. + + +==== tests/cases/conformance/jsx/tsxErrorRecovery1.tsx (1 errors) ==== + + declare namespace JSX { interface Element { } } + + function foo() { + var x =
{
+ ~~ +!!! error TS1109: Expression expected. + } + // Shouldn't see any errors down here + var y = { a: 1 }; + \ No newline at end of file diff --git a/tests/baselines/reference/tsxErrorRecovery1.js b/tests/baselines/reference/tsxErrorRecovery1.js new file mode 100644 index 00000000000..8d20951f6ed --- /dev/null +++ b/tests/baselines/reference/tsxErrorRecovery1.js @@ -0,0 +1,17 @@ +//// [tsxErrorRecovery1.tsx] + +declare namespace JSX { interface Element { } } + +function foo() { + var x =
{
+} +// Shouldn't see any errors down here +var y = { a: 1 }; + + +//// [tsxErrorRecovery1.jsx] +function foo() { + var x =
{}
; +} +// Shouldn't see any errors down here +var y = { a: 1 }; diff --git a/tests/cases/conformance/jsx/tsxErrorRecovery1.tsx b/tests/cases/conformance/jsx/tsxErrorRecovery1.tsx new file mode 100644 index 00000000000..881b3c95376 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxErrorRecovery1.tsx @@ -0,0 +1,10 @@ +//@filename: file.tsx +//@jsx: preserve + +declare namespace JSX { interface Element { } } + +function foo() { + var x =
{
+} +// Shouldn't see any errors down here +var y = { a: 1 }; From c9a925eb758ab023197c9e269e3d60fa1f808753 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 22 Jun 2015 11:53:55 -0700 Subject: [PATCH 162/309] Unrelated baseline noise --- .../jsxInvalidEsprimaTestSuite.errors.txt | 229 +++++++++--------- .../reference/jsxInvalidEsprimaTestSuite.js | 35 +-- .../reference/tsxAttributeResolution.js | 2 - .../reference/tsxAttributeResolution.symbols | 9 +- .../reference/tsxAttributeResolution.types | 1 - .../jsx/tsxAttributeResolution.tsx | 2 +- 6 files changed, 138 insertions(+), 140 deletions(-) diff --git a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt index 9cef517fa1b..f509044703a 100644 --- a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt +++ b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt @@ -1,8 +1,9 @@ -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,1): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,3): error TS1161: Unterminated regular expression literal. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,2): error TS2304: Cannot find name 'a'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,3): error TS1005: ';' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,6): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,3): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,4): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,3): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,1): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,2): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,3): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,6): error TS1109: Expression expected. @@ -23,44 +24,47 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,1): error TS1003: tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,2): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,3): error TS1005: ';' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,4): error TS2304: Cannot find name 'b'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,4): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,6): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,8): error TS1161: Unterminated regular expression literal. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,2): error TS2304: Cannot find name 'a'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,3): error TS1005: ';' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,4): error TS2304: Cannot find name 'b'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,4): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,8): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,10): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,8): error TS2304: Cannot find name 'b'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,10): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,3): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,5): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,11): error TS1005: '>' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,12): error TS2304: Cannot find name 'b'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,16): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,2): error TS2304: Cannot find name 'a'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,5): error TS1005: ';' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2304: Cannot find name 'c'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,6): error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,8): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,10): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,5): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,13): error TS1005: '>' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,14): error TS2304: Cannot find name 'c'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,16): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,2): error TS2304: Cannot find name 'a'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,8): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,10): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,8): error TS17002: Expected corresponding JSX closing tag for 'a.b.c'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,1): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,2): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,5): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,7): error TS1161: Unterminated regular expression literal. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,7): error TS1128: Declaration or statement expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,8): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,10): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,2): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,4): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,5): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,7): error TS1161: Unterminated regular expression literal. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,9): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,3): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,4): error TS2304: Cannot find name 'foo'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,9): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,11): error TS1161: Unterminated regular expression literal. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,11): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,13): error TS2304: Cannot find name 'foo'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,18): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,3): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,11): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,13): error TS1161: Unterminated regular expression literal. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,2): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,13): error TS2304: Cannot find name 'a'. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,22): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,4): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(19,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(20,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. @@ -96,22 +100,24 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,4): error TS1003: tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002: Expected corresponding JSX closing tag for 'a'. -==== tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx (96 errors) ==== +==== tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx (100 errors) ==== declare var React: any; ; + ~~ +!!! error TS1128: Declaration or statement expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1109: Expression expected. + ; + ~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. + <:a />; ~ !!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. - ; - ~ -!!! error TS2304: Cannot find name 'a'. - ~ -!!! error TS1005: ';' expected. - -!!! error TS1161: Unterminated regular expression literal. - <:a />; ~ !!! error TS1109: Expression expected. ~ @@ -157,105 +163,96 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 !!! error TS1005: ';' expected. ~ !!! error TS2304: Cannot find name 'b'. - ~~~~~~~ -!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. - ~ + ~~ !!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. - ; - ~ -!!! error TS2304: Cannot find name 'a'. - ~ -!!! error TS1005: ';' expected. - ~ + ~ !!! error TS2304: Cannot find name 'b'. - ~~~~~~~~~~~~~ -!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. - ~ + ~ +!!! error TS1109: Expression expected. + ; + ~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1005: '>' expected. + ~ +!!! error TS2304: Cannot find name 'b'. + ~ !!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. ; + ~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS2304: Cannot find name 'a'. ~ -!!! error TS1005: ';' expected. - ~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1005: '>' expected. + ~ !!! error TS2304: Cannot find name 'c'. - ~~~~~~~~~~~ -!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. - ~~~~~~~~~~~ - ~~~~~~~~~~~ - ~~~~~~~~~~~ - ~~~~~~~~~~~ - ~~~~~~~~~~~ - ~ + ~ !!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. ; - ~~~~~~~~~~~~ -!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. - ~~~~~~~~~~~~ - ~~~~~~~~~~~~ - ~~~~~~~~~~~~ - ~~~~~~~~~~~~ + ~~~~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS2304: Cannot find name 'a'. - ~ -!!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. + ~~~~ +!!! error TS17002: Expected corresponding JSX closing tag for 'a.b.c'. <.a>; - ~~~~~~~~~~ -!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. - ~~~~~~~~~~ - ~~~~~~~~~~ - ~~~~~~~~~~ + ~ +!!! error TS1109: Expression expected. ~ !!! error TS1109: Expression expected. - ~ + ~~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~ +!!! error TS2304: Cannot find name 'a'. + ~ !!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. ; - ~~~~~~~~~~ -!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. - ~~~~~~~~~~ - ~~~~~~~~~~ + ~~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS2304: Cannot find name 'a'. ~ !!! error TS1003: Identifier expected. - ~ -!!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. + ~ +!!! error TS1003: Identifier expected. ; - ~~~~~~~~~~~~~~~~~~ -!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. - ~~~~~~~~~~~~~~~~~~ - ~ -!!! error TS2304: Cannot find name 'a'. + ~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. ~~~ !!! error TS2304: Cannot find name 'foo'. - ~ + ~~ !!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. - ; - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2365: Operator '<' cannot be applied to types 'boolean' and 'RegExp'. - ~ -!!! error TS2304: Cannot find name 'a'. ~ -!!! error TS1109: Expression expected. - -!!! error TS1161: Unterminated regular expression literal. - ; - ~ !!! error TS2304: Cannot find name 'a'. + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~ +!!! error TS1109: Expression expected. + ; + ~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. + ~ +!!! error TS1003: Identifier expected. + ~~ +!!! error TS1109: Expression expected. + ~ +!!! error TS2304: Cannot find name 'a'. + ~ +!!! error TS1109: Expression expected. + ; + ~~~ +!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~~~ !!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ; diff --git a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.js b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.js index 537a2ff002b..a53cf33410d 100644 --- a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.js +++ b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.js @@ -36,9 +36,8 @@ var x =
one
/* intervening comment */
two
;; ; //// [jsxInvalidEsprimaTestSuite.jsx] - < />; - < a; -/>; + > ; +; < ; a / > ; }/> @@ -46,17 +45,23 @@ a / > ; ; Date: Mon, 22 Jun 2015 12:56:10 -0700 Subject: [PATCH 164/309] moved comment --- src/compiler/checker.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3e0a04b123e..c01674d3513 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4584,7 +4584,9 @@ namespace ts { for (let targetProp of properties) { let sourceProp = getPropertyOfType(source, targetProp.name); - if (sourceProp !== targetProp) { // sourceProp !== targetProp -- ie: source and target have distinct declarations with the same name + if (sourceProp !== targetProp) { + // sourceProp !== targetProp -- ie: source and target have distinct declarations with the same name + if (!sourceProp) { if (!(targetProp.flags & SymbolFlags.Optional) || requireOptionalProperties) { if (reportErrors) { From 92ef6f5409e468597c118ca5e1c8b32d50f5636b Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 22 Jun 2015 13:29:19 -0700 Subject: [PATCH 165/309] responded to some of Daniel's comments --- src/compiler/checker.ts | 33 ++++++++++++++-------------- src/compiler/diagnosticMessages.json | 2 +- 2 files changed, 18 insertions(+), 17 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c01674d3513..34928296570 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6671,15 +6671,15 @@ namespace ts { /** * Check whether the requested property access is valid. - * Returns true if node passed the check, and false otherwise. + * Returns true if node is a valid property access, and false otherwise. * @param node The node to be checked. - * @param left The left hand side of the property access (eg: the super is `super.*`). + * @param left The left hand side of the property access (e.g.: the super in `super.foo`). * @param type The type of left. * @param prop The symbol for the right hand side of the property access. */ - function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol) : boolean { + function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol): boolean { let flags = getDeclarationFlagsFromSymbol(prop); - let declaringClass : InterfaceType; + let declaringClass: InterfaceType; if (left.kind === SyntaxKind.SuperKeyword) { let errorNode = (node).name ? @@ -6693,8 +6693,7 @@ namespace ts { // - In a static member function or static member accessor // where this references the constructor function object of a derived class, // a super property access is permitted and must specify a public static member function of the base class. - if (getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { // prop is a property access - + if (getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { // prop is a property access. error(errorNode, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); return false; } @@ -6715,11 +6714,8 @@ namespace ts { return true; } - // Property is known to be private or protected at this point. - // Get the declaring and enclosing class instance types. let enclosingClassDeclaration = getAncestor(node, SyntaxKind.ClassDeclaration); - // Debug.assert(!!enclosingClassDeclaration, "Should be defined"); let enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; declaringClass = getDeclaredTypeOfSymbol(prop.parent); @@ -7558,7 +7554,7 @@ namespace ts { } // If the expression is of abstract type, then it cannot be instantiated. - var valueDecl = (expressionType.symbol ? expressionType.symbol.valueDeclaration : undefined); + let valueDecl = expressionType.symbol && expressionType.symbol.valueDeclaration; if (valueDecl && valueDecl.flags & NodeFlags.Abstract) { error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declarationNameToString(valueDecl.name)); } @@ -7650,8 +7646,8 @@ namespace ts { } /** - * Performs typechecking on the given node, which is a call/new expression. - * @param node The call expression to be checked. + * Syntactically and semantically checks a call or new expression. + * @param node The call/new expression to be checked. * @returns On success, the expression's signature's return type. On failure, anyType. */ function checkCallExpression(node: CallExpression): Type { @@ -8341,7 +8337,7 @@ namespace ts { if (!checkForDisallowedESSymbolOperand(operator)) { return booleanType; } - // Otherwise fall through + // Fall through case SyntaxKind.EqualsEqualsToken: case SyntaxKind.ExclamationEqualsToken: case SyntaxKind.EqualsEqualsEqualsToken: @@ -9265,7 +9261,8 @@ namespace ts { // the node in question is abstract. if (node.flags & NodeFlags.Abstract) { error(errorNode, Diagnostics.All_declarations_of_an_abstract_member_function_must_be_consecutive); - } else { + } + else { error(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); } } @@ -10775,7 +10772,9 @@ namespace ts { Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration."); - if (derived === base) { // derived class inherits base without override/redeclaration + if (derived === base) { + // derived class inherits base without override/redeclaration + let derivedClassDecl = getDeclarationOfKind(type.symbol, SyntaxKind.ClassDeclaration); Debug.assert(derivedClassDecl !== undefined); @@ -10784,7 +10783,9 @@ namespace ts { error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2, typeToString(type), typeToString(baseType), symbolToString(baseProperty)); } - } else { // derived overrides base + } + else { + // derived overrides base. let derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived); if ((baseDeclarationFlags & NodeFlags.Private) || (derivedDeclarationFlags & NodeFlags.Private)) { // either base or derived property is private - not override, skip it diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index b14d885dd9a..8df76ec8961 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1575,7 +1575,7 @@ "category": "Error", "code": 2514 }, - "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'." : { + "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'.": { "category": "Error", "code": 2515 }, From 16c834420c7a95323dd33326f279866b8c72999b Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 22 Jun 2015 13:55:09 -0700 Subject: [PATCH 166/309] More cleanup --- src/compiler/checker.ts | 27 ++++++++++---------- src/compiler/emitter.ts | 55 ++++++++++++++++++++++++++-------------- src/compiler/parser.ts | 5 ++-- src/harness/harness.ts | 9 ++++--- src/services/services.ts | 30 ++++++++++++---------- 5 files changed, 76 insertions(+), 50 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index bb3096bf70a..99544f466aa 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6698,19 +6698,21 @@ namespace ts { } function tagNamesAreEquivalent(lhs: EntityName, rhs: EntityName): boolean { - if(lhs.kind !== rhs.kind) { + if (lhs.kind !== rhs.kind) { return false; } - if(lhs.kind === SyntaxKind.Identifier) { + + if (lhs.kind === SyntaxKind.Identifier) { return (lhs).text === (rhs).text; } + return (lhs).right.text === (rhs).right.text && tagNamesAreEquivalent((lhs).left, (rhs).left); } function checkJsxElement(node: JsxElement) { // Check that the closing tag matches - if(!tagNamesAreEquivalent(node.openingElement.tagName, node.closingElement.tagName)) { + if (!tagNamesAreEquivalent(node.openingElement.tagName, node.closingElement.tagName)) { error(node.closingElement, Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, getTextOfNode(node.openingElement.tagName)); } @@ -6718,21 +6720,20 @@ namespace ts { checkJsxOpeningLikeElement(node.openingElement); // Check children - let children = node.children; - for (var i = 0, n = children.length; i < n; i++) { - switch (children[i].kind) { + for(let child of node.children) { + switch (child.kind) { case SyntaxKind.JsxExpression: - checkJsxExpression(children[i]); + checkJsxExpression(child); break; case SyntaxKind.JsxElement: - checkJsxElement(children[i]); + checkJsxElement(child); break; case SyntaxKind.JsxSelfClosingElement: - checkJsxSelfClosingElement(children[i]); + checkJsxSelfClosingElement(child); break; default: // No checks for JSX Text - Debug.assert(children[i].kind === SyntaxKind.JsxText); + Debug.assert(child.kind === SyntaxKind.JsxText); } } @@ -6742,7 +6743,7 @@ namespace ts { /** * Returns true iff the JSX element name would be a valid JS identifier, ignoring restrictions about keywords not being identifiers */ - function isIdentifierLike(name: string) { + function isUnhyphenatedJsxName(name: string) { // - is the only character supported in JSX attribute names that isn't valid in JavaScript identifiers return name.indexOf('-') < 0; } @@ -6764,7 +6765,7 @@ namespace ts { let correspondingPropType: Type = undefined; // Look up the corresponding property for this attribute - if (elementAttributesType === emptyObjectType && isIdentifierLike(node.name.text)) { + if (elementAttributesType === emptyObjectType && isUnhyphenatedJsxName(node.name.text)) { // If there is no 'props' property, you may not have non-"data-" attributes error(node.parent, Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, getJsxElementPropertiesName()); } @@ -6772,7 +6773,7 @@ namespace ts { let correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text); correspondingPropType = correspondingPropSymbol && getTypeOfSymbol(correspondingPropSymbol); // If there's no corresponding property with this name, error - if (!correspondingPropType && isIdentifierLike(node.name.text)) { + if (!correspondingPropType && isUnhyphenatedJsxName(node.name.text)) { error(node.name, Diagnostics.Property_0_does_not_exist_on_type_1, node.name.text, typeToString(elementAttributesType)); return unknownType; } diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 68bede620d4..8ae8e7c36ce 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1157,7 +1157,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } } - function emitJsxElement(openingNode: JsxOpeningElement|JsxSelfClosingElement, children?: JsxChild[]) { + function emitJsxElement(openingNode: JsxOpeningLikeElement, children?: JsxChild[]) { // Call React.createElement(tag, ... emitLeadingComments(openingNode); write('React.createElement('); @@ -1177,10 +1177,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { write('React.__spread('); let haveOpenedObjectLiteral = false; - for (var i = 0; i < attrs.length; i++) { + for (let i = 0; i < attrs.length; i++) { if (attrs[i].kind === SyntaxKind.JsxSpreadAttribute) { // If this is the first argument, we need to emit a {} as the first argument - if(i === 0) { + if (i === 0) { write('{}, '); } @@ -1188,7 +1188,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { write('}'); haveOpenedObjectLiteral = false; } - if (i > 0) write(', '); + if (i > 0) { + write(', '); + } emit((attrs[i]).expression); } else { @@ -1198,7 +1200,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } else { haveOpenedObjectLiteral = true; - if (i > 0) write(', '); + if (i > 0) { + write(', '); + } write('{'); } emitJsxAttribute(attrs[i]); @@ -1212,7 +1216,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { // One object literal with all the attributes in them write('{'); for (var i = 0; i < attrs.length; i++) { - if (i > 0) write(', '); + if (i > 0) { + write(', '); + } emitJsxAttribute(attrs[i]); } write('}'); @@ -1223,10 +1229,14 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { if (children) { for (var i = 0; i < children.length; i++) { // Don't emit empty expressions - if (children[i].kind === SyntaxKind.JsxExpression && !((children[i]).expression)) continue; + if (children[i].kind === SyntaxKind.JsxExpression && !((children[i]).expression)) { + continue; + } // Don't emit empty strings - if (children[i].kind === SyntaxKind.JsxText && !shouldEmitJsxText(children[i])) continue; + if (children[i].kind === SyntaxKind.JsxText && !shouldEmitJsxText(children[i])) { + continue; + } write(', '); emit(children[i]); @@ -1261,8 +1271,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } function emitAttributes(attribs: NodeArray) { - for (var i = 0, n = attribs.length; i < n; i++) { - if (i > 0) write(' '); + for (let i = 0, n = attribs.length; i < n; i++) { + if (i > 0) { + write(' '); + } if (attribs[i].kind === SyntaxKind.JsxSpreadAttribute) { emitJsxSpreadAttribute(attribs[i]); @@ -5869,11 +5881,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } } - function emitJsxElement(node: JsxElement|JsxSelfClosingElement) { + function emitJsxElement(node: JsxElement | JsxSelfClosingElement) { switch (compilerOptions.jsx) { case JsxEmit.React: jsxEmitReact(node); break; + case JsxEmit.Preserve: // Fall back to preserve if None was specified (we'll error earlier) default: jsxEmitPreserve(node); @@ -5892,8 +5905,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { let firstNonWhitespace = 0; let lastNonWhitespace = -1; - for (var i = 0; i < text.length; i++) { - var c = text.charCodeAt(i); + // JSX trims whitespace at the end and beginning of lines, except that the + // start/end of a tag is considered a start/end of a line only if that line is + // on the same line as the closing tag. See examples in tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx + for (let i = 0; i < text.length; i++) { + let c = text.charCodeAt(i); if (c === CharacterCodes.lineFeed || c === CharacterCodes.carriageReturn) { if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) { lines.push(text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1)); @@ -5915,11 +5931,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } function shouldEmitJsxText(node: JsxText) { - if (compilerOptions.jsx === JsxEmit.React) { - return trimReactWhitespace(node).length > 0; - } - else { - return true; + switch (compilerOptions.jsx) { + case JsxEmit.React: + return trimReactWhitespace(node).length > 0; + case JsxEmit.Preserve: + default: + return true; } } @@ -5939,7 +5956,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } function emitJsxExpression(node: JsxExpression) { - if (node.expression && node.expression.kind !== SyntaxKind.OmittedExpression) { + if (node.expression) { switch (compilerOptions.jsx) { case JsxEmit.Preserve: default: diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 6da63a4f18e..1317e180f76 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2858,11 +2858,12 @@ namespace ts { } return false; }); + if (isArrowFunctionInJsx) { return Tristate.Unknown; - } else { - return Tristate.False; } + + return Tristate.False; } // This *could* be a parenthesized arrow function. diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 0ea7db33fe1..bd54d24cf73 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -1468,12 +1468,15 @@ module Harness { if (isDTS(emittedFile.fileName)) { // .d.ts file, add to declFiles emit this.declFilesCode.push(emittedFile); - } else if (isJS(emittedFile.fileName) || isJSX(emittedFile.fileName)) { + } + else if (isJS(emittedFile.fileName) || isJSX(emittedFile.fileName)) { // .js file, add to files this.files.push(emittedFile); - } else if (isJSMap(emittedFile.fileName)) { + } + else if (isJSMap(emittedFile.fileName)) { this.sourceMaps.push(emittedFile); - } else { + } + else { throw new Error('Unrecognized file extension for file ' + emittedFile.fileName); } }); diff --git a/src/services/services.ts b/src/services/services.ts index cc35eca49dd..7b9de36e33c 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -2909,16 +2909,20 @@ namespace ts { let isRightOfDot = false; let isRightOfOpenTag = false; - if (contextToken && contextToken.kind === SyntaxKind.DotToken && contextToken.parent.kind === SyntaxKind.PropertyAccessExpression) { - node = (contextToken.parent).expression; - isRightOfDot = true; - } - else if (contextToken && contextToken.kind === SyntaxKind.DotToken && contextToken.parent.kind === SyntaxKind.QualifiedName) { - node = (contextToken.parent).left; - isRightOfDot = true; - } else if (contextToken && contextToken.kind === SyntaxKind.LessThanToken && sourceFile.languageVariant === LanguageVariant.JSX) { - isRightOfOpenTag = true; - location = contextToken; + if(contextToken) { + let kind = contextToken.kind; + if (kind === SyntaxKind.DotToken && contextToken.parent.kind === SyntaxKind.PropertyAccessExpression) { + node = (contextToken.parent).expression; + isRightOfDot = true; + } + else if (kind === SyntaxKind.DotToken && contextToken.parent.kind === SyntaxKind.QualifiedName) { + node = (contextToken.parent).left; + isRightOfDot = true; + } + else if (kind === SyntaxKind.LessThanToken && sourceFile.languageVariant === LanguageVariant.JSX) { + isRightOfOpenTag = true; + location = contextToken; + } } let semanticStart = new Date().getTime(); @@ -2930,11 +2934,11 @@ namespace ts { getTypeScriptMemberSymbols(); } else if (isRightOfOpenTag) { - // TODO include all in-scope value identifiers let tagSymbols = typeChecker.getJsxIntrinsicTagNames();; if (tryGetGlobalSymbols()) { symbols = tagSymbols.concat(symbols.filter(s => !!(s.flags & SymbolFlags.Value))); - } else { + } + else { symbols = tagSymbols; } isMemberCompletion = true; @@ -3006,7 +3010,7 @@ namespace ts { function tryGetGlobalSymbols(): boolean { let containingObjectLiteral = getContainingObjectLiteralApplicableForCompletion(contextToken); - let jsxElement: JsxElement, jsxSelfClosingElement: JsxSelfClosingElement; + if (containingObjectLiteral) { // Object literal expression, look up possible property names from contextual type isMemberCompletion = true; From db316b94d81d7987edeecb570aef4202f17295ea Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 14:41:35 -0700 Subject: [PATCH 167/309] p -> parameter --- src/compiler/emitter.ts | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 3fbe640254f..9d436870297 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -3135,33 +3135,33 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { function emitDefaultValueAssignments(node: FunctionLikeDeclaration) { if (languageVersion < ScriptTarget.ES6) { let tempIndex = 0; - forEach(node.parameters, p => { + forEach(node.parameters, parameter => { // A rest parameter cannot have a binding pattern or an initializer, // so let's just ignore it. - if (p.dotDotDotToken) { + if (parameter.dotDotDotToken) { return; } - if (isBindingPattern(p.name)) { + if (isBindingPattern(parameter.name)) { writeLine(); write("var "); - emitDestructuring(p, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex]); + emitDestructuring(parameter, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex]); write(";"); tempIndex++; } - else if (p.initializer) { + else if (parameter.initializer) { writeLine(); - emitStart(p); + emitStart(parameter); write("if ("); - emitNodeWithoutSourceMap(p.name); + emitNodeWithoutSourceMap(parameter.name); write(" === void 0)"); - emitEnd(p); + emitEnd(parameter); write(" { "); - emitStart(p); - emitNodeWithoutSourceMap(p.name); + emitStart(parameter); + emitNodeWithoutSourceMap(parameter.name); write(" = "); - emitNodeWithoutSourceMap(p.initializer); - emitEnd(p); + emitNodeWithoutSourceMap(parameter.initializer); + emitEnd(parameter); write("; }"); } }); From c1d2f60d3afb7cfd98369111195fd93ca9a1f3c3 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 15:07:49 -0700 Subject: [PATCH 168/309] Added tests. --- .../es6/destructuring/emptyArrayBindingPatternParameter01.ts | 5 +++++ .../es6/destructuring/emptyArrayBindingPatternParameter02.ts | 5 +++++ .../es6/destructuring/emptyArrayBindingPatternParameter03.ts | 5 +++++ .../destructuring/emptyObjectBindingPatternParameter01.ts | 5 +++++ .../destructuring/emptyObjectBindingPatternParameter02.ts | 5 +++++ .../destructuring/emptyObjectBindingPatternParameter03.ts | 5 +++++ 6 files changed, 30 insertions(+) create mode 100644 tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts create mode 100644 tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts create mode 100644 tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts create mode 100644 tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts create mode 100644 tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts create mode 100644 tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts diff --git a/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts new file mode 100644 index 00000000000..0dea1fe795c --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts @@ -0,0 +1,5 @@ + + +function f([]) { + var x, y, z; +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts new file mode 100644 index 00000000000..aa945ed3bca --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts @@ -0,0 +1,5 @@ + + +function f(a, []) { + var x, y, z; +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts new file mode 100644 index 00000000000..aa945ed3bca --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts @@ -0,0 +1,5 @@ + + +function f(a, []) { + var x, y, z; +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts new file mode 100644 index 00000000000..aa6e4f265be --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts @@ -0,0 +1,5 @@ + + +function f({}) { + var x, y, z; +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts new file mode 100644 index 00000000000..671d69beb2b --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts @@ -0,0 +1,5 @@ + + +function f(a, {}) { + var x, y, z; +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts new file mode 100644 index 00000000000..4639b0b2042 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts @@ -0,0 +1,5 @@ + + +function f({}, a) { + var x, y, z; +} \ No newline at end of file From 82f7f7d8e20f455d7686ebbc9badf479cead39b6 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 15:22:12 -0700 Subject: [PATCH 169/309] Accepted baselines. --- .../reference/emptyArrayBindingPatternParameter01.js | 12 ++++++++++++ .../emptyArrayBindingPatternParameter01.symbols | 11 +++++++++++ .../emptyArrayBindingPatternParameter01.types | 11 +++++++++++ .../reference/emptyArrayBindingPatternParameter02.js | 12 ++++++++++++ .../emptyArrayBindingPatternParameter02.symbols | 12 ++++++++++++ .../emptyArrayBindingPatternParameter02.types | 12 ++++++++++++ .../reference/emptyArrayBindingPatternParameter03.js | 12 ++++++++++++ .../emptyArrayBindingPatternParameter03.symbols | 12 ++++++++++++ .../emptyArrayBindingPatternParameter03.types | 12 ++++++++++++ .../emptyObjectBindingPatternParameter01.js | 12 ++++++++++++ .../emptyObjectBindingPatternParameter01.symbols | 11 +++++++++++ .../emptyObjectBindingPatternParameter01.types | 11 +++++++++++ .../emptyObjectBindingPatternParameter02.js | 12 ++++++++++++ .../emptyObjectBindingPatternParameter02.symbols | 12 ++++++++++++ .../emptyObjectBindingPatternParameter02.types | 12 ++++++++++++ .../emptyObjectBindingPatternParameter03.js | 12 ++++++++++++ .../emptyObjectBindingPatternParameter03.symbols | 12 ++++++++++++ .../emptyObjectBindingPatternParameter03.types | 12 ++++++++++++ 18 files changed, 212 insertions(+) create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter01.js create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter01.types create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter02.js create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter02.types create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter03.js create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter03.types create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter01.js create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter01.types create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter02.js create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter02.types create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter03.js create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter03.types diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.js b/tests/baselines/reference/emptyArrayBindingPatternParameter01.js new file mode 100644 index 00000000000..b074024ed94 --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.js @@ -0,0 +1,12 @@ +//// [emptyArrayBindingPatternParameter01.ts] + + +function f([]) { + var x, y, z; +} + +//// [emptyArrayBindingPatternParameter01.js] +function f(_a) { + var ; + var x, y, z; +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols new file mode 100644 index 00000000000..3207ca97dec --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts === + + +function f([]) { +>f : Symbol(f, Decl(emptyArrayBindingPatternParameter01.ts, 0, 0)) + + var x, y, z; +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter01.ts, 3, 4)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter01.ts, 3, 7)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter01.ts, 3, 10)) +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.types b/tests/baselines/reference/emptyArrayBindingPatternParameter01.types new file mode 100644 index 00000000000..e93394b7371 --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts === + + +function f([]) { +>f : ([]: any[]) => void + + var x, y, z; +>x : any +>y : any +>z : any +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js new file mode 100644 index 00000000000..aed9e567ee7 --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js @@ -0,0 +1,12 @@ +//// [emptyArrayBindingPatternParameter02.ts] + + +function f(a, []) { + var x, y, z; +} + +//// [emptyArrayBindingPatternParameter02.js] +function f(a, _a) { + var ; + var x, y, z; +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols new file mode 100644 index 00000000000..e189bc41def --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts === + + +function f(a, []) { +>f : Symbol(f, Decl(emptyArrayBindingPatternParameter02.ts, 0, 0)) +>a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 2, 11)) + + var x, y, z; +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 3, 4)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 3, 7)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 3, 10)) +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.types b/tests/baselines/reference/emptyArrayBindingPatternParameter02.types new file mode 100644 index 00000000000..12657203f90 --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts === + + +function f(a, []) { +>f : (a: any, []: any[]) => void +>a : any + + var x, y, z; +>x : any +>y : any +>z : any +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js new file mode 100644 index 00000000000..9fb9cc6202e --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js @@ -0,0 +1,12 @@ +//// [emptyArrayBindingPatternParameter03.ts] + + +function f(a, []) { + var x, y, z; +} + +//// [emptyArrayBindingPatternParameter03.js] +function f(a, _a) { + var ; + var x, y, z; +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols new file mode 100644 index 00000000000..a236a642807 --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts === + + +function f(a, []) { +>f : Symbol(f, Decl(emptyArrayBindingPatternParameter03.ts, 0, 0)) +>a : Symbol(a, Decl(emptyArrayBindingPatternParameter03.ts, 2, 11)) + + var x, y, z; +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter03.ts, 3, 4)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter03.ts, 3, 7)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter03.ts, 3, 10)) +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.types b/tests/baselines/reference/emptyArrayBindingPatternParameter03.types new file mode 100644 index 00000000000..d1cc85c462a --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts === + + +function f(a, []) { +>f : (a: any, []: any[]) => void +>a : any + + var x, y, z; +>x : any +>y : any +>z : any +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js new file mode 100644 index 00000000000..9dd0e018561 --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js @@ -0,0 +1,12 @@ +//// [emptyObjectBindingPatternParameter01.ts] + + +function f({}) { + var x, y, z; +} + +//// [emptyObjectBindingPatternParameter01.js] +function f(_a) { + var ; + var x, y, z; +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols new file mode 100644 index 00000000000..701482c1355 --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts === + + +function f({}) { +>f : Symbol(f, Decl(emptyObjectBindingPatternParameter01.ts, 0, 0)) + + var x, y, z; +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter01.ts, 3, 4)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter01.ts, 3, 7)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter01.ts, 3, 10)) +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.types b/tests/baselines/reference/emptyObjectBindingPatternParameter01.types new file mode 100644 index 00000000000..90b351e00dc --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts === + + +function f({}) { +>f : ({}: {}) => void + + var x, y, z; +>x : any +>y : any +>z : any +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js new file mode 100644 index 00000000000..d1ad19ffb30 --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js @@ -0,0 +1,12 @@ +//// [emptyObjectBindingPatternParameter02.ts] + + +function f(a, {}) { + var x, y, z; +} + +//// [emptyObjectBindingPatternParameter02.js] +function f(a, _a) { + var ; + var x, y, z; +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols new file mode 100644 index 00000000000..7e58c6bae2e --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts === + + +function f(a, {}) { +>f : Symbol(f, Decl(emptyObjectBindingPatternParameter02.ts, 0, 0)) +>a : Symbol(a, Decl(emptyObjectBindingPatternParameter02.ts, 2, 11)) + + var x, y, z; +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter02.ts, 3, 4)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter02.ts, 3, 7)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter02.ts, 3, 10)) +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.types b/tests/baselines/reference/emptyObjectBindingPatternParameter02.types new file mode 100644 index 00000000000..67969e069be --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts === + + +function f(a, {}) { +>f : (a: any, {}: {}) => void +>a : any + + var x, y, z; +>x : any +>y : any +>z : any +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js new file mode 100644 index 00000000000..efbdd5b04ea --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js @@ -0,0 +1,12 @@ +//// [emptyObjectBindingPatternParameter03.ts] + + +function f({}, a) { + var x, y, z; +} + +//// [emptyObjectBindingPatternParameter03.js] +function f(_a, a) { + var ; + var x, y, z; +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols new file mode 100644 index 00000000000..c5ad54768b0 --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts === + + +function f({}, a) { +>f : Symbol(f, Decl(emptyObjectBindingPatternParameter03.ts, 0, 0)) +>a : Symbol(a, Decl(emptyObjectBindingPatternParameter03.ts, 2, 14)) + + var x, y, z; +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter03.ts, 3, 4)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter03.ts, 3, 7)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter03.ts, 3, 10)) +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.types b/tests/baselines/reference/emptyObjectBindingPatternParameter03.types new file mode 100644 index 00000000000..60557d65f8c --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts === + + +function f({}, a) { +>f : ({}: {}, a: any) => void +>a : any + + var x, y, z; +>x : any +>y : any +>z : any +} From 5bc10b9828e65c0dcf1e89c1fabce0bee5a28220 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 22 Jun 2015 15:22:47 -0700 Subject: [PATCH 170/309] It's no longer safe to store JSX elem. attr. type in nodelinks.resolvedType --- src/compiler/checker.ts | 25 ++++---- src/compiler/parser.ts | 1 - src/compiler/types.ts | 1 + .../baselines/reference/tsxInArrowFunction.js | 34 ++++++++++ .../reference/tsxInArrowFunction.symbols | 46 +++++++++++++ .../reference/tsxInArrowFunction.types | 64 +++++++++++++++++++ 6 files changed, 158 insertions(+), 13 deletions(-) create mode 100644 tests/baselines/reference/tsxInArrowFunction.js create mode 100644 tests/baselines/reference/tsxInArrowFunction.symbols create mode 100644 tests/baselines/reference/tsxInArrowFunction.types diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 99544f466aa..0378835aa0a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6980,57 +6980,57 @@ namespace ts { */ function getJsxElementAttributesType(node: JsxOpeningLikeElement): Type { let links = getNodeLinks(node); - if (!links.resolvedType) { + if (!links.resolvedJsxType) { let sym = getJsxElementTagSymbol(node); if (links.jsxFlags & JsxFlags.ClassElement) { let elemInstanceType = getJsxElementInstanceType(node); if (isTypeAny(elemInstanceType)) { - return links.resolvedType = anyType; + return links.resolvedJsxType = anyType; } var propsName = getJsxElementPropertiesName(); if (propsName === undefined) { // There is no type ElementAttributesProperty, return 'any' - return links.resolvedType = anyType; + return links.resolvedJsxType = anyType; } else if (propsName === '') { // If there is no e.g. 'props' member in ElementAttributesProperty, use the element class type instead - return links.resolvedType = elemInstanceType; + return links.resolvedJsxType = elemInstanceType; } else { var attributesType = getTypeOfPropertyOfType(elemInstanceType, propsName); if (!attributesType) { // There is no property named 'props' on this instance type - return links.resolvedType = emptyObjectType; + return links.resolvedJsxType = emptyObjectType; } else if (isTypeAny(attributesType) || (attributesType === unknownType)) { - return links.resolvedType = attributesType; + return links.resolvedJsxType = attributesType; } else if (!(attributesType.flags & TypeFlags.ObjectType)) { error(node.tagName, Diagnostics.JSX_element_attributes_type_0_must_be_an_object_type, typeToString(attributesType)); - return links.resolvedType = anyType; + return links.resolvedJsxType = anyType; } else { - return links.resolvedType = attributesType; + return links.resolvedJsxType = attributesType; } } } else if (links.jsxFlags & JsxFlags.IntrinsicNamedElement) { - return links.resolvedType = getTypeOfSymbol(sym); + return links.resolvedJsxType = getTypeOfSymbol(sym); } else if (links.jsxFlags & JsxFlags.IntrinsicIndexedElement) { - return links.resolvedType = getIndexTypeOfSymbol(sym, IndexKind.String); + return links.resolvedJsxType = getIndexTypeOfSymbol(sym, IndexKind.String); } else { // Resolution failed - return links.resolvedType = anyType; + return links.resolvedJsxType = anyType; } } - return links.resolvedType; + return links.resolvedJsxType; } /** @@ -7100,6 +7100,7 @@ namespace ts { if (!(targetProperties[i].flags & SymbolFlags.Optional) && nameTable[targetProperties[i].name] === undefined) { + console.log('oops?'); error(node, Diagnostics.Property_0_is_missing_in_type_1, targetProperties[i].name, typeToString(targetAttributesType)); } } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 1317e180f76..ca3e868d331 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -3255,7 +3255,6 @@ namespace ts { let node = createNode(SyntaxKind.JsxElement, opening.pos); node.openingElement = opening; - debugger; node.children = parseJsxChildren(node.openingElement.tagName); node.closingElement = parseJsxClosingElement(); return finishNode(node); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 3a34137a2b4..7f45138bf7d 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1687,6 +1687,7 @@ namespace ts { hasReportedStatementInAmbientContext?: boolean; // Cache boolean if we report statements in ambient context importOnRightSide?: Symbol; // for import declarations - import that appear on the right side jsxFlags?: JsxFlags; // flags for knowning what kind of element/attributes we're dealing with + resolvedJsxType?: Type; // resolved element attributes type of a JSX openinglike element } export const enum TypeFlags { diff --git a/tests/baselines/reference/tsxInArrowFunction.js b/tests/baselines/reference/tsxInArrowFunction.js new file mode 100644 index 00000000000..ba4a0dd1d14 --- /dev/null +++ b/tests/baselines/reference/tsxInArrowFunction.js @@ -0,0 +1,34 @@ +//// [tsxInArrowFunction.tsx] + +declare namespace JSX { + interface Element { } + interface IntrinsicElements { + div: { + text?: string; + } + } +} + + +// didn't work +
{() =>
}
; + +// didn't work +
{x =>
}
; + +// worked +
{() => (
)}
; + +// worked (!) +
{() =>
}
; + + +//// [tsxInArrowFunction.jsx] +// didn't work +
{function () { return
; }}
; +// didn't work +
{function (x) { return
; }}
; +// worked +
{function () { return (
); }}
; +// worked (!) +
{function () { return
; }}
; diff --git a/tests/baselines/reference/tsxInArrowFunction.symbols b/tests/baselines/reference/tsxInArrowFunction.symbols new file mode 100644 index 00000000000..814f2577bf0 --- /dev/null +++ b/tests/baselines/reference/tsxInArrowFunction.symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/jsx/tsxInArrowFunction.tsx === + +declare namespace JSX { +>JSX : Symbol(JSX, Decl(tsxInArrowFunction.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxInArrowFunction.tsx, 1, 23)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxInArrowFunction.tsx, 2, 25)) + + div: { +>div : Symbol(div, Decl(tsxInArrowFunction.tsx, 3, 33)) + + text?: string; +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14)) + } + } +} + + +// didn't work +
{() =>
}
; +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14)) + +// didn't work +
{x =>
}
; +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>x : Symbol(x, Decl(tsxInArrowFunction.tsx, 15, 6)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14)) + +// worked +
{() => (
)}
; +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14)) + +// worked (!) +
{() =>
}
; +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxInArrowFunction.tsx, 3, 33)) +>text : Symbol(text, Decl(tsxInArrowFunction.tsx, 4, 14)) + diff --git a/tests/baselines/reference/tsxInArrowFunction.types b/tests/baselines/reference/tsxInArrowFunction.types new file mode 100644 index 00000000000..e4b2aeb50fe --- /dev/null +++ b/tests/baselines/reference/tsxInArrowFunction.types @@ -0,0 +1,64 @@ +=== tests/cases/conformance/jsx/tsxInArrowFunction.tsx === + +declare namespace JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + div: { +>div : { text?: string; } + + text?: string; +>text : string + } + } +} + + +// didn't work +
{() =>
}
; +>
{() =>
}
: JSX.Element +>div : any +>() =>
: () => JSX.Element +>
: JSX.Element +>div : any +>text : any +>div : any + +// didn't work +
{x =>
}
; +>
{x =>
}
: JSX.Element +>div : any +>x =>
: (x: any) => JSX.Element +>x : any +>
: JSX.Element +>div : any +>text : any +>div : any + +// worked +
{() => (
)}
; +>
{() => (
)}
: JSX.Element +>div : any +>() => (
) : () => JSX.Element +>(
) : JSX.Element +>
: JSX.Element +>div : any +>text : any +>div : any + +// worked (!) +
{() =>
}
; +>
{() =>
}
: JSX.Element +>div : any +>() =>
: () => JSX.Element +>
: JSX.Element +>div : any +>text : any +>div : any +>div : any + From 5c0b913b271cf94d8a62f9bd56adf9c7df09b78c Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 22 Jun 2015 15:47:12 -0700 Subject: [PATCH 171/309] changed error messages and fixed comments --- src/compiler/checker.ts | 37 +++++++++++-------- .../diagnosticInformationMap.generated.ts | 10 ++--- src/compiler/diagnosticMessages.json | 10 ++--- 3 files changed, 31 insertions(+), 26 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 34928296570..5b1479bbf31 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6693,18 +6693,21 @@ namespace ts { // - In a static member function or static member accessor // where this references the constructor function object of a derived class, // a super property access is permitted and must specify a public static member function of the base class. - if (getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { // prop is a property access. + if (getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) { + // `prop` refers to a *property* declared in the super class + // rather than a *method*, so it does not satisfy the above criteria. + error(errorNode, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); return false; } - - // In a super call, the member function can be accessed if the method is not abstract. + + // In a super call, the methods cannot be accessed if the method is abstract. // Note that a member cannot be private and abstract -- this is checked elsewhere. if (flags & NodeFlags.Abstract) { // Get the declaring the class instance type for the error message. declaringClass = getDeclaredTypeOfSymbol(prop.parent); - error(errorNode, Diagnostics.Abstract_member_function_0_on_type_1_cannot_be_called_via_super_expression, symbolToString(prop), typeToString(declaringClass)); + error(errorNode, Diagnostics.Abstract_method_0_1_cannot_be_called_via_super_expression, symbolToString(prop), typeToString(declaringClass)); return false; } } @@ -9142,7 +9145,7 @@ namespace ts { error(signatureDeclarationNode, Diagnostics.Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature); } - function getEffectiveDeclarationFlags(n: Node, flagsToCheck: NodeFlags) { + function getEffectiveDeclarationFlags(n: Node, flagsToCheck: NodeFlags) : NodeFlags { let flags = getCombinedNodeFlags(n); if (n.parent.kind !== SyntaxKind.InterfaceDeclaration && isInAmbientContext(n)) { if (!(flags & NodeFlags.Ambient)) { @@ -9189,7 +9192,7 @@ namespace ts { error(o.name, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected); } else if (deviation & NodeFlags.Abstract) { - error(o.name, Diagnostics.All_overload_signatures_must_match_with_respect_to_modifier_0, "abstract"); + error(o.name, Diagnostics.Overload_signatures_must_all_be_abstract_or_not_abstract, "abstract"); } }); } @@ -9260,7 +9263,7 @@ namespace ts { // Report different errors regarding non-consecutive blocks of declarations depending on whether // the node in question is abstract. if (node.flags & NodeFlags.Abstract) { - error(errorNode, Diagnostics.All_declarations_of_an_abstract_member_function_must_be_consecutive); + error(errorNode, Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive); } else { error(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); @@ -9312,9 +9315,10 @@ namespace ts { bodyDeclaration = node; } - // abstract functions cannot have an implementation - if (currentNodeFlags & NodeFlags.Abstract) { - error(node, Diagnostics.Abstract_member_functions_cannot_have_an_implementation) + // abstract functions cannot have an implementation. + // Extra checks are to avoid reporting multiple errors relating to the "abstractness" of the node. + if (currentNodeFlags & NodeFlags.Abstract && node.kind === SyntaxKind.MethodDeclaration && !isConstructor) { + error(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name)) } } else { @@ -9561,7 +9565,7 @@ namespace ts { case SyntaxKind.MethodDeclaration: checkParameterTypeAnnotationsAsExpressions(node); - // Otherwise fall through + // Fall through case SyntaxKind.SetAccessor: case SyntaxKind.GetAccessor: @@ -10725,11 +10729,12 @@ namespace ts { } forEach(node.members, checkSourceElement); - - // Classes containing abstract members must be marked abstract - if (!(node.flags & NodeFlags.Abstract) && forEach(node.members, (element: ClassElement) => element.flags & NodeFlags.Abstract)) { + + // Classes containing abstract methods must be marked abstract + if (!(node.flags & NodeFlags.Abstract) && forEach(node.members, element => element.flags & NodeFlags.Abstract)) { error(node, Diagnostics.Classes_containing_abstract_functions_must_be_marked_abstract); } + if (produceDiagnostics) { checkIndexConstraints(type); checkTypeForDuplicateIndexSignatures(node); @@ -12074,7 +12079,7 @@ namespace ts { (node.parent).moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } - // Otherwise fall through + // Fall through case SyntaxKind.NumericLiteral: // index access @@ -12880,7 +12885,7 @@ namespace ts { } if (node.kind !== SyntaxKind.ClassDeclaration) { if (node.kind !== SyntaxKind.MethodDeclaration) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_can_only_appear_on_a_class_or_member_function_declaration, "abstract"); + return grammarErrorOnNode(modifier, Diagnostics.abstract_modifier_can_only_appear_on_a_class_or_method_declaration); } if (!(node.parent.kind === SyntaxKind.ClassDeclaration && node.parent.flags & NodeFlags.Abstract)) { return grammarErrorOnNode(modifier, Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class); diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 343b4e22738..572c83849e5 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -191,10 +191,10 @@ namespace ts { An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, - _0_modifier_can_only_appear_on_a_class_or_member_function_declaration: { code: 1236, category: DiagnosticCategory.Error, key: "'{0}' modifier can only appear on a class or member function declaration." }, + abstract_modifier_can_only_appear_on_a_class_or_method_declaration: { code: 1236, category: DiagnosticCategory.Error, key: "'abstract' modifier can only appear on a class or method declaration." }, _0_modifier_cannot_be_used_with_1_modifier: { code: 1237, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with '{1}' modifier." }, Abstract_methods_can_only_appear_within_an_abstract_class: { code: 1238, category: DiagnosticCategory.Error, key: "Abstract methods can only appear within an abstract class." }, - Abstract_member_functions_cannot_have_an_implementation: { code: 1240, category: DiagnosticCategory.Error, key: "Abstract member functions cannot have an implementation." }, + Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: { code: 1240, category: DiagnosticCategory.Error, key: "Method '{0}' cannot have an implementation because it is marked abstract." }, 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." }, @@ -394,11 +394,11 @@ namespace ts { Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." }, Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, - All_overload_signatures_must_match_with_respect_to_modifier_0: { code: 2512, category: DiagnosticCategory.Error, key: "All overload signatures must match with respect to modifier '{0}'." }, - Abstract_member_function_0_on_type_1_cannot_be_called_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract member function '{0}' on type '{1}' cannot be called via super expression." }, + Overload_signatures_must_all_be_abstract_or_not_abstract: { code: 2512, category: DiagnosticCategory.Error, key: "Overload signatures must all be `abstract` or not `abstract." }, + Abstract_method_0_1_cannot_be_called_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}.{1}' cannot be called via super expression." }, Classes_containing_abstract_functions_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract functions must be marked abstract." }, Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'." }, - All_declarations_of_an_abstract_member_function_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract member function must be consecutive." }, + All_declarations_of_an_abstract_method_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract method must be consecutive." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 8df76ec8961..425aa5e87ac 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -751,7 +751,7 @@ "category": "Error", "code": 1235 }, - "'{0}' modifier can only appear on a class or member function declaration.": { + "'abstract' modifier can only appear on a class or method declaration.": { "category": "Error", "code": 1236 }, @@ -763,7 +763,7 @@ "category": "Error", "code": 1238 }, - "Abstract member functions cannot have an implementation.": { + "Method '{0}' cannot have an implementation because it is marked abstract.": { "category": "Error", "code": 1240 }, @@ -1563,11 +1563,11 @@ "category": "Error", "code": 2511 }, - "All overload signatures must match with respect to modifier '{0}'.": { + "Overload signatures must all be `abstract` or not `abstract.": { "category": "Error", "code": 2512 }, - "Abstract member function '{0}' on type '{1}' cannot be called via super expression.": { + "Abstract method '{0}.{1}' cannot be called via super expression.": { "category": "Error", "code": 2513 }, @@ -1579,7 +1579,7 @@ "category": "Error", "code": 2515 }, - "All declarations of an abstract member function must be consecutive.": { + "All declarations of an abstract method must be consecutive.": { "category": "Error", "code": 2516 }, From 0daa9eb0d4fd9120ef43ae594abb162ab987ae09 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 22 Jun 2015 15:55:04 -0700 Subject: [PATCH 172/309] updated baselines for new error messages --- .../classAbstractConstructor.errors.txt | 9 +++------ .../classAbstractDeclarations.d.errors.txt | 9 +++------ ...ssAbstractMethodWithImplementation.errors.txt | 4 ++-- .../reference/classAbstractOverloads.errors.txt | 16 ++++++++-------- .../reference/classAbstractProperties.errors.txt | 16 ++++++++-------- .../reference/classAbstractSuperCalls.errors.txt | 4 ++-- 6 files changed, 26 insertions(+), 32 deletions(-) diff --git a/tests/baselines/reference/classAbstractConstructor.errors.txt b/tests/baselines/reference/classAbstractConstructor.errors.txt index b8d91cefb0f..fbea6ef807f 100644 --- a/tests/baselines/reference/classAbstractConstructor.errors.txt +++ b/tests/baselines/reference/classAbstractConstructor.errors.txt @@ -1,12 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts(2,5): error TS1240: Abstract member functions cannot have an implementation. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts (2 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts (1 errors) ==== abstract class A { abstract constructor() {} ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. - ~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS1240: Abstract member functions cannot have an implementation. +!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt index 068a1273bb8..501a54e5539 100644 --- a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt +++ b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt @@ -1,18 +1,15 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1240: Abstract member functions cannot have an implementation. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,28): error TS1184: An implementation cannot be declared in ambient contexts. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(11,15): error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(13,15): error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(17,15): error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts (6 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts (5 errors) ==== declare abstract class A { abstract constructor() {} ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. - ~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS1240: Abstract member functions cannot have an implementation. +!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. ~ !!! error TS1184: An implementation cannot be declared in ambient contexts. } diff --git a/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt b/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt index 5e1196f0e7c..2649c83f4e7 100644 --- a/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt +++ b/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts(2,5): error TS1240: Abstract member functions cannot have an implementation. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts(2,5): error TS1240: Method 'foo' cannot have an implementation because it is marked abstract. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts (1 errors) ==== abstract class A { abstract foo() {} ~~~~~~~~~~~~~~~~~ -!!! error TS1240: Abstract member functions cannot have an implementation. +!!! error TS1240: Method 'foo' cannot have an implementation because it is marked abstract. } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractOverloads.errors.txt b/tests/baselines/reference/classAbstractOverloads.errors.txt index 88dd33c2bed..74463ca7fc0 100644 --- a/tests/baselines/reference/classAbstractOverloads.errors.txt +++ b/tests/baselines/reference/classAbstractOverloads.errors.txt @@ -1,8 +1,8 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(7,5): error TS2512: All overload signatures must match with respect to modifier 'abstract'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(10,14): error TS2512: All overload signatures must match with respect to modifier 'abstract'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(12,14): error TS2512: All overload signatures must match with respect to modifier 'abstract'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(7,5): error TS2512: Overload signatures must all be `abstract` or not `abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(10,14): error TS2512: Overload signatures must all be `abstract` or not `abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(12,14): error TS2512: Overload signatures must all be `abstract` or not `abstract. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(15,5): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(20,14): error TS2516: All declarations of an abstract member function must be consecutive. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(20,14): error TS2516: All declarations of an abstract method must be consecutive. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts (5 errors) ==== @@ -14,16 +14,16 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst abstract bar(); bar(); ~~~ -!!! error TS2512: All overload signatures must match with respect to modifier 'abstract'. +!!! error TS2512: Overload signatures must all be `abstract` or not `abstract. abstract bar(); abstract baz(); ~~~ -!!! error TS2512: All overload signatures must match with respect to modifier 'abstract'. +!!! error TS2512: Overload signatures must all be `abstract` or not `abstract. baz(); abstract baz(); ~~~ -!!! error TS2512: All overload signatures must match with respect to modifier 'abstract'. +!!! error TS2512: Overload signatures must all be `abstract` or not `abstract. baz() {} qux(); @@ -35,7 +35,7 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst abstract foo() : number; abstract foo(); ~~~ -!!! error TS2516: All declarations of an abstract member function must be consecutive. +!!! error TS2516: All declarations of an abstract method must be consecutive. x : number; abstract foo(); abstract foo(); diff --git a/tests/baselines/reference/classAbstractProperties.errors.txt b/tests/baselines/reference/classAbstractProperties.errors.txt index 0f40d091fd8..30e7ca1153d 100644 --- a/tests/baselines/reference/classAbstractProperties.errors.txt +++ b/tests/baselines/reference/classAbstractProperties.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(3,12): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(4,15): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(5,13): error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(3,12): error TS1236: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(4,15): error TS1236: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(5,13): error TS1236: 'abstract' modifier can only appear on a class or method declaration. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(10,13): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. @@ -9,16 +9,16 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst abstract class A { abstract x : number; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. public abstract y : number; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. protected abstract z : number; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. private abstract w : number; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or member function declaration. +!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. abstract foo_x() : number; public abstract foo_y() : number; diff --git a/tests/baselines/reference/classAbstractSuperCalls.errors.txt b/tests/baselines/reference/classAbstractSuperCalls.errors.txt index b63b768cbfe..ea81b2b60af 100644 --- a/tests/baselines/reference/classAbstractSuperCalls.errors.txt +++ b/tests/baselines/reference/classAbstractSuperCalls.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,26): error TS2513: Abstract member function 'foo' on type 'B' cannot be called via super expression. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,26): error TS2513: Abstract method 'foo.B' cannot be called via super expression. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts (1 errors) ==== @@ -17,7 +17,7 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst foo() { return 2; } qux() { return super.foo(); } // error, super is abstract ~~~ -!!! error TS2513: Abstract member function 'foo' on type 'B' cannot be called via super expression. +!!! error TS2513: Abstract method 'foo.B' cannot be called via super expression. norf() { return super.bar(); } } From a8d205a2fc6ce63fba37b36fa8482f050c1d500a Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 22 Jun 2015 16:06:17 -0700 Subject: [PATCH 173/309] new tests --- .../classAbstractCrashedOnce.ts | 10 ++++ .../classAbstractImportInstantiation.ts | 9 ++++ ...ass.ts => classAbstractInstantiations1.ts} | 8 --- .../classAbstractInstantiations2.ts | 51 +++++++++++++++++++ .../classAbstractManyKeywords.ts | 4 ++ .../classAbstractMultiLineDecl.ts | 12 +++++ 6 files changed, 86 insertions(+), 8 deletions(-) create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractCrashedOnce.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractImportInstantiation.ts rename tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/{classInstantiatingAbstractClass.ts => classAbstractInstantiations1.ts} (60%) create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractCrashedOnce.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractCrashedOnce.ts new file mode 100644 index 00000000000..747b8dafe6e --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractCrashedOnce.ts @@ -0,0 +1,10 @@ +abstract class foo { + protected abstract test(); +} + +class bar extends foo { + test() { + this. + } +} +var x = new bar(); \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractImportInstantiation.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractImportInstantiation.ts new file mode 100644 index 00000000000..165a3d7a2e6 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractImportInstantiation.ts @@ -0,0 +1,9 @@ +module M { + export abstract class A {} + + new A; +} + +import myA = M.A; + +new myA; diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts similarity index 60% rename from tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts index d60a39a3f2c..c9ca4afb18d 100644 --- a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts @@ -16,11 +16,3 @@ var c : C; a = new B; b = new B; c = new B; - -module M { - export abstract class A {} -} - -import myA = M.A; - -var aa = new myA; diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts new file mode 100644 index 00000000000..6cca7ed947f --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts @@ -0,0 +1,51 @@ +class A { + // ... +} + +abstract class B { + foo(): number { return bar(); } + abstract bar() : number; +} + +new B; // error + +var BB: typeof B = B; +var AA: typeof A = BB; // error, AA is not of abstract type. +new AA; + +function constructB(Factory : typeof B) { + new Factory; // error -- Factory is of type typeof C +} + +var BB = B; +new BB; // error -- BB is of type typeof C + +var x : any = C; +new x; // okay -- undefined behavior at runtime + +class C extends B { } // error -- not declared abstract + +abstract class D extends B { } // okay + +class E extends B { // okay -- implements abstract method + bar() { return 1; } +} + +abstract class F extends B { + abstract foo() : number; + bar() { return 2; } +} + +abstract class G { + abstract qux(x : number) : string; + abstract qux() : number; + y : number; + abstract quz(x : number, y : string) : boolean; // error -- declarations must be adjacent + + abstract nom() boolean; + nom(x : number) boolean; // error -- use of modifier abstract must match on all overloads. +} + +class H { // error -- not declared abstract + abstract baz() : number; +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts new file mode 100644 index 00000000000..2a6fd46a08d --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts @@ -0,0 +1,4 @@ +export default abstract class A {} +export abstract class B {} +default abstract class C {} +import abstract class D {} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts new file mode 100644 index 00000000000..374a3c089ef --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts @@ -0,0 +1,12 @@ +abstract class A {} + +abstract +class B {} + +abstract + +class C {} + +new A; +new B; +new C; \ No newline at end of file From 676f4a17ee9100bcef215f27079d7a3fd544c043 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 22 Jun 2015 16:18:35 -0700 Subject: [PATCH 174/309] added baselines for new tests --- .../classAbstractCrashedOnce.errors.txt | 16 +++ .../reference/classAbstractCrashedOnce.js | 35 +++++ ...lassAbstractImportInstantiation.errors.txt | 19 +++ .../classAbstractImportInstantiation.js | 25 ++++ .../classAbstractInstantiations1.errors.txt | 28 ++++ ...ass.js => classAbstractInstantiations1.js} | 23 +--- .../classAbstractInstantiations2.errors.txt | 90 +++++++++++++ .../reference/classAbstractInstantiations2.js | 123 ++++++++++++++++++ .../classAbstractManyKeywords.errors.txt | 19 +++ .../reference/classAbstractManyKeywords.js | 28 ++++ .../classAbstractMultiLineDecl.errors.txt | 24 ++++ .../reference/classAbstractMultiLineDecl.js | 33 +++++ ...classInstantiatingAbstractClass.errors.txt | 39 ------ 13 files changed, 442 insertions(+), 60 deletions(-) create mode 100644 tests/baselines/reference/classAbstractCrashedOnce.errors.txt create mode 100644 tests/baselines/reference/classAbstractCrashedOnce.js create mode 100644 tests/baselines/reference/classAbstractImportInstantiation.errors.txt create mode 100644 tests/baselines/reference/classAbstractImportInstantiation.js create mode 100644 tests/baselines/reference/classAbstractInstantiations1.errors.txt rename tests/baselines/reference/{classInstantiatingAbstractClass.js => classAbstractInstantiations1.js} (68%) create mode 100644 tests/baselines/reference/classAbstractInstantiations2.errors.txt create mode 100644 tests/baselines/reference/classAbstractInstantiations2.js create mode 100644 tests/baselines/reference/classAbstractManyKeywords.errors.txt create mode 100644 tests/baselines/reference/classAbstractManyKeywords.js create mode 100644 tests/baselines/reference/classAbstractMultiLineDecl.errors.txt create mode 100644 tests/baselines/reference/classAbstractMultiLineDecl.js delete mode 100644 tests/baselines/reference/classInstantiatingAbstractClass.errors.txt diff --git a/tests/baselines/reference/classAbstractCrashedOnce.errors.txt b/tests/baselines/reference/classAbstractCrashedOnce.errors.txt new file mode 100644 index 00000000000..c2e38a6cf44 --- /dev/null +++ b/tests/baselines/reference/classAbstractCrashedOnce.errors.txt @@ -0,0 +1,16 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractCrashedOnce.ts(8,5): error TS1003: Identifier expected. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractCrashedOnce.ts (1 errors) ==== + abstract class foo { + protected abstract test(); + } + + class bar extends foo { + test() { + this. + } + ~ +!!! error TS1003: Identifier expected. + } + var x = new bar(); \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractCrashedOnce.js b/tests/baselines/reference/classAbstractCrashedOnce.js new file mode 100644 index 00000000000..f4268a4a13c --- /dev/null +++ b/tests/baselines/reference/classAbstractCrashedOnce.js @@ -0,0 +1,35 @@ +//// [classAbstractCrashedOnce.ts] +abstract class foo { + protected abstract test(); +} + +class bar extends foo { + test() { + this. + } +} +var x = new bar(); + +//// [classAbstractCrashedOnce.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var foo = (function () { + function foo() { + } + return foo; +})(); +var bar = (function (_super) { + __extends(bar, _super); + function bar() { + _super.apply(this, arguments); + } + bar.prototype.test = function () { + this. + ; + }; + return bar; +})(foo); +var x = new bar(); diff --git a/tests/baselines/reference/classAbstractImportInstantiation.errors.txt b/tests/baselines/reference/classAbstractImportInstantiation.errors.txt new file mode 100644 index 00000000000..76110afa4ff --- /dev/null +++ b/tests/baselines/reference/classAbstractImportInstantiation.errors.txt @@ -0,0 +1,19 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractImportInstantiation.ts(4,5): error TS2511: Cannot create an instance of the abstract class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractImportInstantiation.ts(9,1): error TS2511: Cannot create an instance of the abstract class 'A'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractImportInstantiation.ts (2 errors) ==== + module M { + export abstract class A {} + + new A; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + } + + import myA = M.A; + + new myA; + ~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractImportInstantiation.js b/tests/baselines/reference/classAbstractImportInstantiation.js new file mode 100644 index 00000000000..bb25181f20d --- /dev/null +++ b/tests/baselines/reference/classAbstractImportInstantiation.js @@ -0,0 +1,25 @@ +//// [classAbstractImportInstantiation.ts] +module M { + export abstract class A {} + + new A; +} + +import myA = M.A; + +new myA; + + +//// [classAbstractImportInstantiation.js] +var M; +(function (M) { + var A = (function () { + function A() { + } + return A; + })(); + M.A = A; + new A; +})(M || (M = {})); +var myA = M.A; +new myA; diff --git a/tests/baselines/reference/classAbstractInstantiations1.errors.txt b/tests/baselines/reference/classAbstractInstantiations1.errors.txt new file mode 100644 index 00000000000..0221ce07f95 --- /dev/null +++ b/tests/baselines/reference/classAbstractInstantiations1.errors.txt @@ -0,0 +1,28 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(8,1): error TS2511: Cannot create an instance of the abstract class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'C'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts (2 errors) ==== + + abstract class A {} + + class B extends A {} + + abstract class C extends B {} + + new A; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + new B; + new C; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'C'. + + var a : A; + var b : B; + var c : C; + + a = new B; + b = new B; + c = new B; + \ No newline at end of file diff --git a/tests/baselines/reference/classInstantiatingAbstractClass.js b/tests/baselines/reference/classAbstractInstantiations1.js similarity index 68% rename from tests/baselines/reference/classInstantiatingAbstractClass.js rename to tests/baselines/reference/classAbstractInstantiations1.js index 6a2c3f31e37..39e67542926 100644 --- a/tests/baselines/reference/classInstantiatingAbstractClass.js +++ b/tests/baselines/reference/classAbstractInstantiations1.js @@ -1,4 +1,4 @@ -//// [classInstantiatingAbstractClass.ts] +//// [classAbstractInstantiations1.ts] abstract class A {} @@ -17,17 +17,9 @@ var c : C; a = new B; b = new B; c = new B; - -module M { - export abstract class A {} -} - -import myA = M.A; - -var aa = new myA; -//// [classInstantiatingAbstractClass.js] +//// [classAbstractInstantiations1.js] var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } @@ -61,14 +53,3 @@ var c; a = new B; b = new B; c = new B; -var M; -(function (M) { - var A = (function () { - function A() { - } - return A; - })(); - M.A = A; -})(M || (M = {})); -var myA = M.A; -var aa = new myA; diff --git a/tests/baselines/reference/classAbstractInstantiations2.errors.txt b/tests/baselines/reference/classAbstractInstantiations2.errors.txt new file mode 100644 index 00000000000..c3cb4a4cae4 --- /dev/null +++ b/tests/baselines/reference/classAbstractInstantiations2.errors.txt @@ -0,0 +1,90 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(6,28): error TS2304: Cannot find name 'bar'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(17,5): error TS2511: Cannot create an instance of the abstract class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(21,1): error TS2511: Cannot create an instance of the abstract class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(26,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'B.bar'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(45,14): error TS2516: All declarations of an abstract method must be consecutive. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(45,20): error TS1144: '{' or ';' expected. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(45,20): error TS2300: Duplicate identifier 'boolean'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,5): error TS2512: Overload signatures must all be `abstract` or not `abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,21): error TS1144: '{' or ';' expected. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,21): error TS2300: Duplicate identifier 'boolean'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(49,7): error TS2514: Classes containing abstract functions must be marked abstract. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts (12 errors) ==== + class A { + // ... + } + + abstract class B { + foo(): number { return bar(); } + ~~~ +!!! error TS2304: Cannot find name 'bar'. + abstract bar() : number; + } + + new B; // error + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'B'. + + var BB: typeof B = B; + var AA: typeof A = BB; // error, AA is not of abstract type. + new AA; + + function constructB(Factory : typeof B) { + new Factory; // error -- Factory is of type typeof C + ~~~~~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'B'. + } + + var BB = B; + new BB; // error -- BB is of type typeof C + ~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'B'. + + var x : any = C; + new x; // okay -- undefined behavior at runtime + + class C extends B { } // error -- not declared abstract + ~ +!!! error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'B.bar'. + + abstract class D extends B { } // okay + + class E extends B { // okay -- implements abstract method + bar() { return 1; } + } + + abstract class F extends B { + abstract foo() : number; + bar() { return 2; } + } + + abstract class G { + abstract qux(x : number) : string; + abstract qux() : number; + y : number; + abstract quz(x : number, y : string) : boolean; // error -- declarations must be adjacent + + abstract nom() boolean; + ~~~ +!!! error TS2516: All declarations of an abstract method must be consecutive. + ~~~~~~~ +!!! error TS1144: '{' or ';' expected. + ~~~~~~~ +!!! error TS2300: Duplicate identifier 'boolean'. + nom(x : number) boolean; // error -- use of modifier abstract must match on all overloads. + ~~~ +!!! error TS2512: Overload signatures must all be `abstract` or not `abstract. + ~~~~~~~ +!!! error TS1144: '{' or ';' expected. + ~~~~~~~ +!!! error TS2300: Duplicate identifier 'boolean'. + } + + class H { // error -- not declared abstract + ~ +!!! error TS2514: Classes containing abstract functions must be marked abstract. + abstract baz() : number; + } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractInstantiations2.js b/tests/baselines/reference/classAbstractInstantiations2.js new file mode 100644 index 00000000000..055bdfedbc3 --- /dev/null +++ b/tests/baselines/reference/classAbstractInstantiations2.js @@ -0,0 +1,123 @@ +//// [classAbstractInstantiations2.ts] +class A { + // ... +} + +abstract class B { + foo(): number { return bar(); } + abstract bar() : number; +} + +new B; // error + +var BB: typeof B = B; +var AA: typeof A = BB; // error, AA is not of abstract type. +new AA; + +function constructB(Factory : typeof B) { + new Factory; // error -- Factory is of type typeof C +} + +var BB = B; +new BB; // error -- BB is of type typeof C + +var x : any = C; +new x; // okay -- undefined behavior at runtime + +class C extends B { } // error -- not declared abstract + +abstract class D extends B { } // okay + +class E extends B { // okay -- implements abstract method + bar() { return 1; } +} + +abstract class F extends B { + abstract foo() : number; + bar() { return 2; } +} + +abstract class G { + abstract qux(x : number) : string; + abstract qux() : number; + y : number; + abstract quz(x : number, y : string) : boolean; // error -- declarations must be adjacent + + abstract nom() boolean; + nom(x : number) boolean; // error -- use of modifier abstract must match on all overloads. +} + +class H { // error -- not declared abstract + abstract baz() : number; +} + +//// [classAbstractInstantiations2.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var A = (function () { + function A() { + } + return A; +})(); +var B = (function () { + function B() { + } + B.prototype.foo = function () { return bar(); }; + return B; +})(); +new B; // error +var BB = B; +var AA = BB; // error, AA is not of abstract type. +new AA; +function constructB(Factory) { + new Factory; // error -- Factory is of type typeof C +} +var BB = B; +new BB; // error -- BB is of type typeof C +var x = C; +new x; // okay -- undefined behavior at runtime +var C = (function (_super) { + __extends(C, _super); + function C() { + _super.apply(this, arguments); + } + return C; +})(B); // error -- not declared abstract +var D = (function (_super) { + __extends(D, _super); + function D() { + _super.apply(this, arguments); + } + return D; +})(B); // okay +var E = (function (_super) { + __extends(E, _super); + function E() { + _super.apply(this, arguments); + } + E.prototype.bar = function () { return 1; }; + return E; +})(B); +var F = (function (_super) { + __extends(F, _super); + function F() { + _super.apply(this, arguments); + } + F.prototype.bar = function () { return 2; }; + return F; +})(B); +var G = (function () { + function G() { + } + G.prototype.nom = ; + G.prototype.nom = ; + return G; +})(); +var H = (function () { + function H() { + } + return H; +})(); diff --git a/tests/baselines/reference/classAbstractManyKeywords.errors.txt b/tests/baselines/reference/classAbstractManyKeywords.errors.txt new file mode 100644 index 00000000000..b200404eaf0 --- /dev/null +++ b/tests/baselines/reference/classAbstractManyKeywords.errors.txt @@ -0,0 +1,19 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts(1,1): error TS1148: Cannot compile modules unless the '--module' flag is provided. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts(1,25): error TS1005: ';' expected. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts(3,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts(4,17): error TS1005: '=' expected. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractManyKeywords.ts (4 errors) ==== + export default abstract class A {} + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1148: Cannot compile modules unless the '--module' flag is provided. + ~~~~~ +!!! error TS1005: ';' expected. + export abstract class B {} + default abstract class C {} + ~~~~~~~ +!!! error TS1128: Declaration or statement expected. + import abstract class D {} + ~~~~~ +!!! error TS1005: '=' expected. \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractManyKeywords.js b/tests/baselines/reference/classAbstractManyKeywords.js new file mode 100644 index 00000000000..79191c029e1 --- /dev/null +++ b/tests/baselines/reference/classAbstractManyKeywords.js @@ -0,0 +1,28 @@ +//// [classAbstractManyKeywords.ts] +export default abstract class A {} +export abstract class B {} +default abstract class C {} +import abstract class D {} + +//// [classAbstractManyKeywords.js] +var A = (function () { + function A() { + } + return A; +})(); +var B = (function () { + function B() { + } + return B; +})(); +exports.B = B; +var C = (function () { + function C() { + } + return C; +})(); +var D = (function () { + function D() { + } + return D; +})(); diff --git a/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt b/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt new file mode 100644 index 00000000000..5af440ed4df --- /dev/null +++ b/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(11,1): error TS2511: Cannot create an instance of the abstract class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(12,1): error TS2511: Cannot create an instance of the abstract class 'C'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts (3 errors) ==== + abstract class A {} + + abstract + class B {} + + abstract + + class C {} + + new A; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + new B; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'B'. + new C; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'C'. \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractMultiLineDecl.js b/tests/baselines/reference/classAbstractMultiLineDecl.js new file mode 100644 index 00000000000..3a92e2aa1e5 --- /dev/null +++ b/tests/baselines/reference/classAbstractMultiLineDecl.js @@ -0,0 +1,33 @@ +//// [classAbstractMultiLineDecl.ts] +abstract class A {} + +abstract +class B {} + +abstract + +class C {} + +new A; +new B; +new C; + +//// [classAbstractMultiLineDecl.js] +var A = (function () { + function A() { + } + return A; +})(); +var B = (function () { + function B() { + } + return B; +})(); +var C = (function () { + function C() { + } + return C; +})(); +new A; +new B; +new C; diff --git a/tests/baselines/reference/classInstantiatingAbstractClass.errors.txt b/tests/baselines/reference/classInstantiatingAbstractClass.errors.txt deleted file mode 100644 index a9da2f38c37..00000000000 --- a/tests/baselines/reference/classInstantiatingAbstractClass.errors.txt +++ /dev/null @@ -1,39 +0,0 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts(8,1): error TS2511: Cannot create an instance of the abstract class 'A'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'C'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts(26,10): error TS2511: Cannot create an instance of the abstract class 'A'. - - -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classInstantiatingAbstractClass.ts (3 errors) ==== - - abstract class A {} - - class B extends A {} - - abstract class C extends B {} - - new A; - ~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'A'. - new B; - new C; - ~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'C'. - - var a : A; - var b : B; - var c : C; - - a = new B; - b = new B; - c = new B; - - module M { - export abstract class A {} - } - - import myA = M.A; - - var aa = new myA; - ~~~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'A'. - \ No newline at end of file From 0f871b9812f27a84e24fa45d56d8a94ce0287440 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 16:44:00 -0700 Subject: [PATCH 175/309] Check for number of binding elements in parameter patterns. --- src/compiler/emitter.ts | 17 +++++++++++------ src/compiler/utilities.ts | 2 +- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 9d436870297..5da2abe3699 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -3142,12 +3142,17 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return; } - if (isBindingPattern(parameter.name)) { - writeLine(); - write("var "); - emitDestructuring(parameter, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex]); - write(";"); - tempIndex++; + let paramName = parameter.name; + if (isBindingPattern(paramName)) { + // In cases where a binding patternm is simply '[]' or '{}', + // we don't want to emit anything. + if (paramName.elements.length > 0) { + writeLine(); + write("var "); + emitDestructuring(parameter, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex]); + write(";"); + tempIndex++; + } } else if (parameter.initializer) { writeLine(); diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index ee75454ad93..72478a2fa26 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1067,7 +1067,7 @@ namespace ts { return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken; } - export function isBindingPattern(node: Node) { + export function isBindingPattern(node: Node): node is BindingPattern { return !!node && (node.kind === SyntaxKind.ArrayBindingPattern || node.kind === SyntaxKind.ObjectBindingPattern); } From b986514f4bec42a86ddae76bab436d0c2a2e604b Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 16:45:12 -0700 Subject: [PATCH 176/309] Accepted baselines. --- .../reference/declarationEmitDestructuring4.js | 16 ++++------------ .../emptyArrayBindingPatternParameter01.js | 1 - .../emptyArrayBindingPatternParameter02.js | 1 - .../emptyArrayBindingPatternParameter03.js | 1 - .../emptyObjectBindingPatternParameter01.js | 1 - .../emptyObjectBindingPatternParameter02.js | 1 - .../emptyObjectBindingPatternParameter03.js | 1 - 7 files changed, 4 insertions(+), 18 deletions(-) diff --git a/tests/baselines/reference/declarationEmitDestructuring4.js b/tests/baselines/reference/declarationEmitDestructuring4.js index f5d9df09175..1f43c255170 100644 --- a/tests/baselines/reference/declarationEmitDestructuring4.js +++ b/tests/baselines/reference/declarationEmitDestructuring4.js @@ -15,21 +15,13 @@ function baz4({} = { x: 10 }) { } // For an array binding pattern with empty elements, // we will not make any modification and will emit // the similar binding pattern users' have written -function baz(_a) { - var ; -} -function baz1(_a) { - var _b = _a === void 0 ? [1, 2, 3] : _a; -} +function baz(_a) { } +function baz1(_a) { } function baz2(_a) { var _b = (_a === void 0 ? [[1, 2, 3]] : _a)[0]; } -function baz3(_a) { - var ; -} -function baz4(_a) { - var _b = _a === void 0 ? { x: 10 } : _a; -} +function baz3(_a) { } +function baz4(_a) { } //// [declarationEmitDestructuring4.d.ts] diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter01.js b/tests/baselines/reference/emptyArrayBindingPatternParameter01.js index b074024ed94..05b59b7d5f2 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter01.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter01.js @@ -7,6 +7,5 @@ function f([]) { //// [emptyArrayBindingPatternParameter01.js] function f(_a) { - var ; var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js index aed9e567ee7..bc4053a0fe0 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js @@ -7,6 +7,5 @@ function f(a, []) { //// [emptyArrayBindingPatternParameter02.js] function f(a, _a) { - var ; var x, y, z; } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js index 9fb9cc6202e..5431994234f 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js @@ -7,6 +7,5 @@ function f(a, []) { //// [emptyArrayBindingPatternParameter03.js] function f(a, _a) { - var ; var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js index 9dd0e018561..a954627d2cb 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js @@ -7,6 +7,5 @@ function f({}) { //// [emptyObjectBindingPatternParameter01.js] function f(_a) { - var ; var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js index d1ad19ffb30..119a84e95aa 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js @@ -7,6 +7,5 @@ function f(a, {}) { //// [emptyObjectBindingPatternParameter02.js] function f(a, _a) { - var ; var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js index efbdd5b04ea..3fb84c0eae8 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js @@ -7,6 +7,5 @@ function f({}, a) { //// [emptyObjectBindingPatternParameter03.js] function f(_a, a) { - var ; var x, y, z; } From 51246fe8939fbb55c3d04133ddc9820ffd237f0c Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 17:31:52 -0700 Subject: [PATCH 177/309] Tabs -> Spaces --- .../es6/destructuring/emptyArrayBindingPatternParameter02.ts | 2 +- .../es6/destructuring/emptyArrayBindingPatternParameter03.ts | 2 +- .../es6/destructuring/emptyObjectBindingPatternParameter01.ts | 2 +- .../es6/destructuring/emptyObjectBindingPatternParameter02.ts | 2 +- .../es6/destructuring/emptyObjectBindingPatternParameter03.ts | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts index aa945ed3bca..39663a4bed7 100644 --- a/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts +++ b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts @@ -1,5 +1,5 @@ function f(a, []) { - var x, y, z; + var x, y, z; } \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts index aa945ed3bca..39663a4bed7 100644 --- a/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts +++ b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter03.ts @@ -1,5 +1,5 @@ function f(a, []) { - var x, y, z; + var x, y, z; } \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts index aa6e4f265be..01aa5b54230 100644 --- a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts +++ b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter01.ts @@ -1,5 +1,5 @@ function f({}) { - var x, y, z; + var x, y, z; } \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts index 671d69beb2b..f34503c1152 100644 --- a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts +++ b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter02.ts @@ -1,5 +1,5 @@ function f(a, {}) { - var x, y, z; + var x, y, z; } \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts index 4639b0b2042..a940c659703 100644 --- a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts +++ b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter03.ts @@ -1,5 +1,5 @@ function f({}, a) { - var x, y, z; + var x, y, z; } \ No newline at end of file From 1dd5a9955770e68fa00909674a8f4931f39cc2b9 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 17:33:29 -0700 Subject: [PATCH 178/309] Accepted baselines. --- .../reference/emptyArrayBindingPatternParameter02.js | 2 +- .../reference/emptyArrayBindingPatternParameter02.symbols | 8 ++++---- .../reference/emptyArrayBindingPatternParameter02.types | 2 +- .../reference/emptyArrayBindingPatternParameter03.js | 2 +- .../reference/emptyArrayBindingPatternParameter03.symbols | 8 ++++---- .../reference/emptyArrayBindingPatternParameter03.types | 2 +- .../reference/emptyObjectBindingPatternParameter01.js | 2 +- .../emptyObjectBindingPatternParameter01.symbols | 8 ++++---- .../reference/emptyObjectBindingPatternParameter01.types | 2 +- .../reference/emptyObjectBindingPatternParameter02.js | 2 +- .../emptyObjectBindingPatternParameter02.symbols | 8 ++++---- .../reference/emptyObjectBindingPatternParameter02.types | 2 +- .../reference/emptyObjectBindingPatternParameter03.js | 2 +- .../emptyObjectBindingPatternParameter03.symbols | 8 ++++---- .../reference/emptyObjectBindingPatternParameter03.types | 2 +- 15 files changed, 30 insertions(+), 30 deletions(-) diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js index bc4053a0fe0..dbd86e843a8 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.js @@ -2,7 +2,7 @@ function f(a, []) { - var x, y, z; + var x, y, z; } //// [emptyArrayBindingPatternParameter02.js] diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols index e189bc41def..48cdcfaf93d 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols @@ -5,8 +5,8 @@ function f(a, []) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter02.ts, 0, 0)) >a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 2, 11)) - var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 3, 4)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 3, 7)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 3, 10)) + var x, y, z; +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 3, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 3, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 3, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter02.types b/tests/baselines/reference/emptyArrayBindingPatternParameter02.types index 12657203f90..a58fe6b91d3 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter02.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter02.types @@ -5,7 +5,7 @@ function f(a, []) { >f : (a: any, []: any[]) => void >a : any - var x, y, z; + var x, y, z; >x : any >y : any >z : any diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js index 5431994234f..e2c3f7196e6 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.js @@ -2,7 +2,7 @@ function f(a, []) { - var x, y, z; + var x, y, z; } //// [emptyArrayBindingPatternParameter03.js] diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols index a236a642807..d3ec078df78 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.symbols @@ -5,8 +5,8 @@ function f(a, []) { >f : Symbol(f, Decl(emptyArrayBindingPatternParameter03.ts, 0, 0)) >a : Symbol(a, Decl(emptyArrayBindingPatternParameter03.ts, 2, 11)) - var x, y, z; ->x : Symbol(x, Decl(emptyArrayBindingPatternParameter03.ts, 3, 4)) ->y : Symbol(y, Decl(emptyArrayBindingPatternParameter03.ts, 3, 7)) ->z : Symbol(z, Decl(emptyArrayBindingPatternParameter03.ts, 3, 10)) + var x, y, z; +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter03.ts, 3, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter03.ts, 3, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter03.ts, 3, 13)) } diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter03.types b/tests/baselines/reference/emptyArrayBindingPatternParameter03.types index d1cc85c462a..43f0af63ace 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter03.types +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter03.types @@ -5,7 +5,7 @@ function f(a, []) { >f : (a: any, []: any[]) => void >a : any - var x, y, z; + var x, y, z; >x : any >y : any >z : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js index a954627d2cb..28cc30d2a0b 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.js @@ -2,7 +2,7 @@ function f({}) { - var x, y, z; + var x, y, z; } //// [emptyObjectBindingPatternParameter01.js] diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols index 701482c1355..98829df994f 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.symbols @@ -4,8 +4,8 @@ function f({}) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter01.ts, 0, 0)) - var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter01.ts, 3, 4)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter01.ts, 3, 7)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter01.ts, 3, 10)) + var x, y, z; +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter01.ts, 3, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter01.ts, 3, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter01.ts, 3, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter01.types b/tests/baselines/reference/emptyObjectBindingPatternParameter01.types index 90b351e00dc..c46569ea770 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter01.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter01.types @@ -4,7 +4,7 @@ function f({}) { >f : ({}: {}) => void - var x, y, z; + var x, y, z; >x : any >y : any >z : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js index 119a84e95aa..8488428ea51 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.js @@ -2,7 +2,7 @@ function f(a, {}) { - var x, y, z; + var x, y, z; } //// [emptyObjectBindingPatternParameter02.js] diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols index 7e58c6bae2e..fb0fa946b6f 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.symbols @@ -5,8 +5,8 @@ function f(a, {}) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter02.ts, 0, 0)) >a : Symbol(a, Decl(emptyObjectBindingPatternParameter02.ts, 2, 11)) - var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter02.ts, 3, 4)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter02.ts, 3, 7)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter02.ts, 3, 10)) + var x, y, z; +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter02.ts, 3, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter02.ts, 3, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter02.ts, 3, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter02.types b/tests/baselines/reference/emptyObjectBindingPatternParameter02.types index 67969e069be..0a77fac8588 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter02.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter02.types @@ -5,7 +5,7 @@ function f(a, {}) { >f : (a: any, {}: {}) => void >a : any - var x, y, z; + var x, y, z; >x : any >y : any >z : any diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js index 3fb84c0eae8..0279744e386 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.js @@ -2,7 +2,7 @@ function f({}, a) { - var x, y, z; + var x, y, z; } //// [emptyObjectBindingPatternParameter03.js] diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols index c5ad54768b0..4e658e21ccf 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.symbols @@ -5,8 +5,8 @@ function f({}, a) { >f : Symbol(f, Decl(emptyObjectBindingPatternParameter03.ts, 0, 0)) >a : Symbol(a, Decl(emptyObjectBindingPatternParameter03.ts, 2, 14)) - var x, y, z; ->x : Symbol(x, Decl(emptyObjectBindingPatternParameter03.ts, 3, 4)) ->y : Symbol(y, Decl(emptyObjectBindingPatternParameter03.ts, 3, 7)) ->z : Symbol(z, Decl(emptyObjectBindingPatternParameter03.ts, 3, 10)) + var x, y, z; +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter03.ts, 3, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter03.ts, 3, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter03.ts, 3, 13)) } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter03.types b/tests/baselines/reference/emptyObjectBindingPatternParameter03.types index 60557d65f8c..873c748dd9b 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter03.types +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter03.types @@ -5,7 +5,7 @@ function f({}, a) { >f : ({}: {}, a: any) => void >a : any - var x, y, z; + var x, y, z; >x : any >y : any >z : any From ebf486f7111df0e4c34b5f4f34ec85f656ec56da Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 17:40:13 -0700 Subject: [PATCH 179/309] Added tests where parameters have initializers. --- .../es6/destructuring/emptyArrayBindingPatternParameter04.ts | 5 +++++ .../destructuring/emptyObjectBindingPatternParameter04.ts | 5 +++++ 2 files changed, 10 insertions(+) create mode 100644 tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts create mode 100644 tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts diff --git a/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts new file mode 100644 index 00000000000..313d4fe6708 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts @@ -0,0 +1,5 @@ + + +function f([] = [1,2,3,4]) { + var x, y, z; +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts new file mode 100644 index 00000000000..da05e5cb428 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts @@ -0,0 +1,5 @@ + + +function f({} = {a: 1, b: "2", c: true}) { + var x, y, z; +} \ No newline at end of file From b159944f0a5eb662988f6f6cabcfc787b72ff294 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 22 Jun 2015 17:50:15 -0700 Subject: [PATCH 180/309] Accepted baselines. --- .../emptyArrayBindingPatternParameter04.js | 11 +++++++++++ ...emptyArrayBindingPatternParameter04.symbols | 11 +++++++++++ .../emptyArrayBindingPatternParameter04.types | 16 ++++++++++++++++ .../emptyObjectBindingPatternParameter04.js | 11 +++++++++++ ...mptyObjectBindingPatternParameter04.symbols | 14 ++++++++++++++ .../emptyObjectBindingPatternParameter04.types | 18 ++++++++++++++++++ 6 files changed, 81 insertions(+) create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter04.js create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols create mode 100644 tests/baselines/reference/emptyArrayBindingPatternParameter04.types create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter04.js create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter04.types diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.js b/tests/baselines/reference/emptyArrayBindingPatternParameter04.js new file mode 100644 index 00000000000..3f52b95ab62 --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.js @@ -0,0 +1,11 @@ +//// [emptyArrayBindingPatternParameter04.ts] + + +function f([] = [1,2,3,4]) { + var x, y, z; +} + +//// [emptyArrayBindingPatternParameter04.js] +function f(_a) { + var x, y, z; +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols b/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols new file mode 100644 index 00000000000..bb76a2c5925 --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts === + + +function f([] = [1,2,3,4]) { +>f : Symbol(f, Decl(emptyArrayBindingPatternParameter04.ts, 0, 0)) + + var x, y, z; +>x : Symbol(x, Decl(emptyArrayBindingPatternParameter04.ts, 3, 7)) +>y : Symbol(y, Decl(emptyArrayBindingPatternParameter04.ts, 3, 10)) +>z : Symbol(z, Decl(emptyArrayBindingPatternParameter04.ts, 3, 13)) +} diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.types b/tests/baselines/reference/emptyArrayBindingPatternParameter04.types new file mode 100644 index 00000000000..6f00a994f7b --- /dev/null +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter04.ts === + + +function f([] = [1,2,3,4]) { +>f : ([]?: number[]) => void +>[1,2,3,4] : number[] +>1 : number +>2 : number +>3 : number +>4 : number + + var x, y, z; +>x : any +>y : any +>z : any +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.js b/tests/baselines/reference/emptyObjectBindingPatternParameter04.js new file mode 100644 index 00000000000..6545ea9ad34 --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.js @@ -0,0 +1,11 @@ +//// [emptyObjectBindingPatternParameter04.ts] + + +function f({} = {a: 1, b: "2", c: true}) { + var x, y, z; +} + +//// [emptyObjectBindingPatternParameter04.js] +function f(_a) { + var x, y, z; +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols b/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols new file mode 100644 index 00000000000..9922d4cd074 --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols @@ -0,0 +1,14 @@ +=== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts === + + +function f({} = {a: 1, b: "2", c: true}) { +>f : Symbol(f, Decl(emptyObjectBindingPatternParameter04.ts, 0, 0)) +>a : Symbol(a, Decl(emptyObjectBindingPatternParameter04.ts, 2, 17)) +>b : Symbol(b, Decl(emptyObjectBindingPatternParameter04.ts, 2, 22)) +>c : Symbol(c, Decl(emptyObjectBindingPatternParameter04.ts, 2, 30)) + + var x, y, z; +>x : Symbol(x, Decl(emptyObjectBindingPatternParameter04.ts, 3, 7)) +>y : Symbol(y, Decl(emptyObjectBindingPatternParameter04.ts, 3, 10)) +>z : Symbol(z, Decl(emptyObjectBindingPatternParameter04.ts, 3, 13)) +} diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.types b/tests/baselines/reference/emptyObjectBindingPatternParameter04.types new file mode 100644 index 00000000000..5ee32d422a9 --- /dev/null +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/es6/destructuring/emptyObjectBindingPatternParameter04.ts === + + +function f({} = {a: 1, b: "2", c: true}) { +>f : ({}?: { a: number; b: string; c: boolean; }) => void +>{a: 1, b: "2", c: true} : { a: number; b: string; c: boolean; } +>a : number +>1 : number +>b : string +>"2" : string +>c : boolean +>true : boolean + + var x, y, z; +>x : any +>y : any +>z : any +} From 4490ff70b8d8a23b3f7bc71c48a971d9cb9e3fe8 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Tue, 23 Jun 2015 09:05:49 -0700 Subject: [PATCH 181/309] Add Jake task to update the Sublime plugin --- Jakefile.js | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Jakefile.js b/Jakefile.js index afe0ffd3ce5..c5f30cf9f6c 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -690,3 +690,9 @@ task('tsc-instrumented', [loggedIOJsPath, instrumenterJsPath, tscFile], function }); ex.run(); }, { async: true }); + +desc("Updates the sublime plugin's tsserver"); +task("update-sublime", [serverFile], function() { + jake.cpR(serverFile, "../TypeScript-Sublime-Plugin/tsserver/"); + jake.cpR(serverFile + ".map", "../TypeScript-Sublime-Plugin/tsserver/"); +}); From 9451aa66ee554f065b16a98adc71fa5ae84630e7 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 23 Jun 2015 10:12:32 -0700 Subject: [PATCH 182/309] Fixed order of arguments in error message --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 5b1479bbf31..48903c2443f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6707,7 +6707,7 @@ namespace ts { // Get the declaring the class instance type for the error message. declaringClass = getDeclaredTypeOfSymbol(prop.parent); - error(errorNode, Diagnostics.Abstract_method_0_1_cannot_be_called_via_super_expression, symbolToString(prop), typeToString(declaringClass)); + error(errorNode, Diagnostics.Abstract_method_0_1_cannot_be_called_via_super_expression, typeToString(declaringClass), symbolToString(prop)); return false; } } From 1068890fcd54747594cac2fcfccef39fc55c63ba Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 23 Jun 2015 10:33:41 -0700 Subject: [PATCH 183/309] Moved tests to classAbstractKeyword folder --- tests/cases/compiler/abstractClass1.ts | 36 ------------------- .../compiler/abstractClassIdentifierName.ts | 4 --- .../classAbstractAsIdentifier.ts | 5 +++ .../classAbstractInAModule.ts | 7 ++++ .../classAbstractSuperCalls.ts | 2 +- ...s => classAbstractUsingAbstractMethod1.ts} | 0 .../classAbstractUsingAbstractMethods2.ts} | 0 .../classAbstractWithInterface.ts | 1 + 8 files changed, 14 insertions(+), 41 deletions(-) delete mode 100644 tests/cases/compiler/abstractClass1.ts delete mode 100644 tests/cases/compiler/abstractClassIdentifierName.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAsIdentifier.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInAModule.ts rename tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/{classAbstractUsingAbstractMethod.ts => classAbstractUsingAbstractMethod1.ts} (100%) rename tests/cases/conformance/classes/classDeclarations/{classWithAbstractMethods.ts => classAbstractKeyword/classAbstractUsingAbstractMethods2.ts} (100%) create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts diff --git a/tests/cases/compiler/abstractClass1.ts b/tests/cases/compiler/abstractClass1.ts deleted file mode 100644 index 1590ee907f0..00000000000 --- a/tests/cases/compiler/abstractClass1.ts +++ /dev/null @@ -1,36 +0,0 @@ -// @declaration: true - -abstract class Foo { - constructor(f: any) { } - public static bar(): void { } - - public empty() { } -} - -class Bar extends Foo { - constructor(f: any) { - super(f); - } -} - -var a = new Foo(1); // Error -var b = new Foo(); // Error because of invalid constructor arguments - -module baz { - export abstract class Qux { - } - export class Quz extends Qux { - } -} - -new baz.Qux(); - -// Valid -var c = new Bar(1); -c.empty(); - -// Calling a static method on a abstract class is valid -Foo.bar(); - -var Copy = Foo; -new Copy(); diff --git a/tests/cases/compiler/abstractClassIdentifierName.ts b/tests/cases/compiler/abstractClassIdentifierName.ts deleted file mode 100644 index 09d07f16fb8..00000000000 --- a/tests/cases/compiler/abstractClassIdentifierName.ts +++ /dev/null @@ -1,4 +0,0 @@ -class abstract { - - abstract(): void { } -} diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAsIdentifier.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAsIdentifier.ts new file mode 100644 index 00000000000..4c251a03c36 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAsIdentifier.ts @@ -0,0 +1,5 @@ +class abstract { + foo() { return 1; } +} + +new abstract; \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInAModule.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInAModule.ts new file mode 100644 index 00000000000..f31dd41436e --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInAModule.ts @@ -0,0 +1,7 @@ +module M { + export abstract class A {} + export class B extends A {} +} + +new M.A; +new M.B; \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts index 90fdc5cc389..e93a670b55f 100644 --- a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts @@ -11,7 +11,7 @@ abstract class B extends A { class C extends B { foo() { return 2; } - qux() { return super.foo(); } // error, super is abstract + qux() { return super.foo() || super.foo; } // 2 errors, foo is abstract norf() { return super.bar(); } } diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod1.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod1.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts new file mode 100644 index 00000000000..17b89868943 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts @@ -0,0 +1 @@ +abstract interface I {} \ No newline at end of file From 74d248e1222cda621c05d53b393b04e33ed9cb9b Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 23 Jun 2015 10:42:49 -0700 Subject: [PATCH 184/309] Changed error message --- src/compiler/checker.ts | 2 +- src/compiler/diagnosticInformationMap.generated.ts | 2 +- src/compiler/diagnosticMessages.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 48903c2443f..2bfa45db992 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6707,7 +6707,7 @@ namespace ts { // Get the declaring the class instance type for the error message. declaringClass = getDeclaredTypeOfSymbol(prop.parent); - error(errorNode, Diagnostics.Abstract_method_0_1_cannot_be_called_via_super_expression, typeToString(declaringClass), symbolToString(prop)); + error(errorNode, Diagnostics.Abstract_method_0_1_cannot_be_accessed_via_super_expression, typeToString(declaringClass), symbolToString(prop)); return false; } } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 572c83849e5..e4977e56a78 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -395,7 +395,7 @@ namespace ts { Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, Overload_signatures_must_all_be_abstract_or_not_abstract: { code: 2512, category: DiagnosticCategory.Error, key: "Overload signatures must all be `abstract` or not `abstract." }, - Abstract_method_0_1_cannot_be_called_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}.{1}' cannot be called via super expression." }, + Abstract_method_0_1_cannot_be_accessed_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}.{1}' cannot be accessed via super expression." }, Classes_containing_abstract_functions_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract functions must be marked abstract." }, Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'." }, All_declarations_of_an_abstract_method_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract method must be consecutive." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 425aa5e87ac..731d4fed59a 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1567,7 +1567,7 @@ "category": "Error", "code": 2512 }, - "Abstract method '{0}.{1}' cannot be called via super expression.": { + "Abstract method '{0}.{1}' cannot be accessed via super expression.": { "category": "Error", "code": 2513 }, From 3eea71786b912b1ed20edfd6986d80cb4e733159 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 23 Jun 2015 11:08:20 -0700 Subject: [PATCH 185/309] Fixed some error messages. --- src/compiler/checker.ts | 24 ++++++++++++------- .../diagnosticInformationMap.generated.ts | 4 ++-- src/compiler/diagnosticMessages.json | 4 ++-- .../classAbstractInstantiations2.ts | 6 ++--- 4 files changed, 22 insertions(+), 16 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 2bfa45db992..e4d30141d38 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6701,10 +6701,12 @@ namespace ts { return false; } - // In a super call, the methods cannot be accessed if the method is abstract. - // Note that a member cannot be private and abstract -- this is checked elsewhere. if (flags & NodeFlags.Abstract) { - // Get the declaring the class instance type for the error message. + // A method cannot be accessed in a super call if the method is abstract. + // This error could mask a private property access error. But, a member + // cannot simultaneously be private and abstract, so this will trigger an + // additional error elsewhere. + declaringClass = getDeclaredTypeOfSymbol(prop.parent); error(errorNode, Diagnostics.Abstract_method_0_1_cannot_be_accessed_via_super_expression, typeToString(declaringClass), symbolToString(prop)); @@ -9145,7 +9147,7 @@ namespace ts { error(signatureDeclarationNode, Diagnostics.Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature); } - function getEffectiveDeclarationFlags(n: Node, flagsToCheck: NodeFlags) : NodeFlags { + function getEffectiveDeclarationFlags(n: Node, flagsToCheck: NodeFlags): NodeFlags { let flags = getCombinedNodeFlags(n); if (n.parent.kind !== SyntaxKind.InterfaceDeclaration && isInAmbientContext(n)) { if (!(flags & NodeFlags.Ambient)) { @@ -9192,7 +9194,7 @@ namespace ts { error(o.name, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected); } else if (deviation & NodeFlags.Abstract) { - error(o.name, Diagnostics.Overload_signatures_must_all_be_abstract_or_not_abstract, "abstract"); + error(o.name, Diagnostics.Overload_signatures_must_all_be_abstract_or_not_abstract); } }); } @@ -10732,7 +10734,7 @@ namespace ts { // Classes containing abstract methods must be marked abstract if (!(node.flags & NodeFlags.Abstract) && forEach(node.members, element => element.flags & NodeFlags.Abstract)) { - error(node, Diagnostics.Classes_containing_abstract_functions_must_be_marked_abstract); + error(node, Diagnostics.Classes_containing_abstract_methods_must_be_marked_abstract); } if (produceDiagnostics) { @@ -10785,8 +10787,8 @@ namespace ts { // It is an error to inherit an abstract member without implementing it or being declared abstract. if ((baseDeclarationFlags & NodeFlags.Abstract) && !(derivedClassDecl.flags & NodeFlags.Abstract)) { - error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2, - typeToString(type), typeToString(baseType), symbolToString(baseProperty)); + error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, + typeToString(type), symbolToString(baseProperty), typeToString(baseType)); } } else { @@ -12821,7 +12823,11 @@ namespace ts { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } else if (flags & NodeFlags.Abstract) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract"); + if (modifier.kind === SyntaxKind.PrivateKeyword) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract")} + else { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract"); + } } flags |= modifierToFlag(modifier.kind); break; diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index e4977e56a78..364a703d415 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -396,8 +396,8 @@ namespace ts { Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, Overload_signatures_must_all_be_abstract_or_not_abstract: { code: 2512, category: DiagnosticCategory.Error, key: "Overload signatures must all be `abstract` or not `abstract." }, Abstract_method_0_1_cannot_be_accessed_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}.{1}' cannot be accessed via super expression." }, - Classes_containing_abstract_functions_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract functions must be marked abstract." }, - Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'." }, + Classes_containing_abstract_methods_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract methods must be marked abstract." }, + Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'." }, All_declarations_of_an_abstract_method_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract method must be consecutive." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 731d4fed59a..ac191e635ee 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1571,11 +1571,11 @@ "category": "Error", "code": 2513 }, - "Classes containing abstract functions must be marked abstract.": { + "Classes containing abstract methods must be marked abstract.": { "category": "Error", "code": 2514 }, - "Non-abstract class '{0}' does not implement inherited abstract member '{1}.{2}'.": { + "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'.": { "category": "Error", "code": 2515 }, diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts index 6cca7ed947f..ef965dfe94b 100644 --- a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts @@ -3,7 +3,7 @@ class A { } abstract class B { - foo(): number { return bar(); } + foo(): number { return this.bar(); } abstract bar() : number; } @@ -42,8 +42,8 @@ abstract class G { y : number; abstract quz(x : number, y : string) : boolean; // error -- declarations must be adjacent - abstract nom() boolean; - nom(x : number) boolean; // error -- use of modifier abstract must match on all overloads. + abstract nom(): boolean; + nom(x : number): boolean; // error -- use of modifier abstract must match on all overloads. } class H { // error -- not declared abstract From 1f6637b495812b6e83cc64b142bd53e22a9c7753 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 23 Jun 2015 11:19:15 -0700 Subject: [PATCH 186/309] Added check to test --- .../classAbstractKeyword/classAbstractProperties.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts index 3349e878e03..e6dc355adb9 100644 --- a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts @@ -4,6 +4,8 @@ abstract class A { protected abstract z : number; private abstract w : number; + abstract m: () => void; + abstract foo_x() : number; public abstract foo_y() : number; protected abstract foo_z() : number; From 771e4871266dee0363c65268fa1750feba54a33c Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 23 Jun 2015 11:23:45 -0700 Subject: [PATCH 187/309] Re-fixed error message. --- src/compiler/checker.ts | 2 +- src/compiler/diagnosticInformationMap.generated.ts | 2 +- src/compiler/diagnosticMessages.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e4d30141d38..8554f4a0091 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6709,7 +6709,7 @@ namespace ts { declaringClass = getDeclaredTypeOfSymbol(prop.parent); - error(errorNode, Diagnostics.Abstract_method_0_1_cannot_be_accessed_via_super_expression, typeToString(declaringClass), symbolToString(prop)); + error(errorNode, Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(declaringClass)); return false; } } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 364a703d415..853ee81359c 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -395,7 +395,7 @@ namespace ts { Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, Overload_signatures_must_all_be_abstract_or_not_abstract: { code: 2512, category: DiagnosticCategory.Error, key: "Overload signatures must all be `abstract` or not `abstract." }, - Abstract_method_0_1_cannot_be_accessed_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}.{1}' cannot be accessed via super expression." }, + Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}' in class '{1}' cannot be accessed via super expression." }, Classes_containing_abstract_methods_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract methods must be marked abstract." }, Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'." }, All_declarations_of_an_abstract_method_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract method must be consecutive." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index ac191e635ee..3605bae6900 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1567,7 +1567,7 @@ "category": "Error", "code": 2512 }, - "Abstract method '{0}.{1}' cannot be accessed via super expression.": { + "Abstract method '{0}' in class '{1}' cannot be accessed via super expression.": { "category": "Error", "code": 2513 }, From 8e2b204ace1901aaced26cde1bb2084d8db11b6d Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Tue, 23 Jun 2015 11:25:33 -0700 Subject: [PATCH 188/309] do not try to classify missing nodes --- src/services/services.ts | 4 ++++ .../fourslash/syntacticClassificationWithErrors.ts | 14 ++++++++++++++ 2 files changed, 18 insertions(+) create mode 100644 tests/cases/fourslash/syntacticClassificationWithErrors.ts diff --git a/src/services/services.ts b/src/services/services.ts index 70022cfe0bf..18510b9a178 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -6300,6 +6300,10 @@ namespace ts { } function classifyToken(token: Node): void { + if (nodeIsMissing(token)) { + return; + } + let tokenStart = classifyLeadingTriviaAndGetTokenStart(token); let tokenWidth = token.end - tokenStart; diff --git a/tests/cases/fourslash/syntacticClassificationWithErrors.ts b/tests/cases/fourslash/syntacticClassificationWithErrors.ts new file mode 100644 index 00000000000..b4572d3e620 --- /dev/null +++ b/tests/cases/fourslash/syntacticClassificationWithErrors.ts @@ -0,0 +1,14 @@ +/// + +////class A { +//// a: +////} +////c = + +let c = classification +verify.syntacticClassificationsAre( + c.keyword("class"), c.className("A"), c.punctuation("{"), + c.text("a"), c.punctuation(":"), + c.punctuation("}"), + c.text("c"), c.operator("=") + ); \ No newline at end of file From 36b1dbaf95fda4b8f1dabacaeece4cf5f21ced47 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 23 Jun 2015 11:30:30 -0700 Subject: [PATCH 189/309] accepted baselines --- .../reference/abstractClass1.errors.txt | 57 ---------- tests/baselines/reference/abstractClass1.js | 106 ------------------ .../reference/abstractClassIdentifierName.js | 14 --- .../abstractClassIdentifierName.symbols | 8 -- .../abstractClassIdentifierName.types | 8 -- .../reference/classAbstractAsIdentifier.js | 15 +++ .../classAbstractAsIdentifier.symbols | 11 ++ .../reference/classAbstractAsIdentifier.types | 13 +++ .../classAbstractDeclarations.d.errors.txt | 12 +- .../classAbstractInAModule.errors.txt | 13 +++ .../reference/classAbstractInAModule.js | 34 ++++++ .../classAbstractInheritance.errors.txt | 12 +- .../classAbstractInstantiations2.errors.txt | 40 +++---- .../reference/classAbstractInstantiations2.js | 10 +- ...classAbstractMixedWithModifiers.errors.txt | 4 +- .../classAbstractProperties.errors.txt | 9 +- .../reference/classAbstractProperties.js | 2 + .../classAbstractSuperCalls.errors.txt | 11 +- .../reference/classAbstractSuperCalls.js | 4 +- ...ssAbstractUsingAbstractMethod1.errors.txt} | 4 +- ...s => classAbstractUsingAbstractMethod1.js} | 4 +- ...ssAbstractUsingAbstractMethods2.errors.txt | 42 +++++++ ... => classAbstractUsingAbstractMethods2.js} | 4 +- .../classAbstractWithInterface.errors.txt | 7 ++ .../reference/classAbstractWithInterface.js | 4 + .../classWithAbstractMethods.errors.txt | 42 ------- 26 files changed, 195 insertions(+), 295 deletions(-) delete mode 100644 tests/baselines/reference/abstractClass1.errors.txt delete mode 100644 tests/baselines/reference/abstractClass1.js delete mode 100644 tests/baselines/reference/abstractClassIdentifierName.js delete mode 100644 tests/baselines/reference/abstractClassIdentifierName.symbols delete mode 100644 tests/baselines/reference/abstractClassIdentifierName.types create mode 100644 tests/baselines/reference/classAbstractAsIdentifier.js create mode 100644 tests/baselines/reference/classAbstractAsIdentifier.symbols create mode 100644 tests/baselines/reference/classAbstractAsIdentifier.types create mode 100644 tests/baselines/reference/classAbstractInAModule.errors.txt create mode 100644 tests/baselines/reference/classAbstractInAModule.js rename tests/baselines/reference/{classAbstractUsingAbstractMethod.errors.txt => classAbstractUsingAbstractMethod1.errors.txt} (72%) rename tests/baselines/reference/{classAbstractUsingAbstractMethod.js => classAbstractUsingAbstractMethod1.js} (89%) create mode 100644 tests/baselines/reference/classAbstractUsingAbstractMethods2.errors.txt rename tests/baselines/reference/{classWithAbstractMethods.js => classAbstractUsingAbstractMethods2.js} (91%) create mode 100644 tests/baselines/reference/classAbstractWithInterface.errors.txt create mode 100644 tests/baselines/reference/classAbstractWithInterface.js delete mode 100644 tests/baselines/reference/classWithAbstractMethods.errors.txt diff --git a/tests/baselines/reference/abstractClass1.errors.txt b/tests/baselines/reference/abstractClass1.errors.txt deleted file mode 100644 index 5e658fec641..00000000000 --- a/tests/baselines/reference/abstractClass1.errors.txt +++ /dev/null @@ -1,57 +0,0 @@ -tests/cases/compiler/abstractClass1.ts(15,9): error TS2511: Cannot create an instance of the abstract class 'Foo'. -tests/cases/compiler/abstractClass1.ts(16,9): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/abstractClass1.ts(16,9): error TS2511: Cannot create an instance of the abstract class 'Foo'. -tests/cases/compiler/abstractClass1.ts(25,1): error TS2511: Cannot create an instance of the abstract class 'Qux'. -tests/cases/compiler/abstractClass1.ts(35,1): error TS2346: Supplied parameters do not match any signature of call target. -tests/cases/compiler/abstractClass1.ts(35,1): error TS2511: Cannot create an instance of the abstract class 'Foo'. - - -==== tests/cases/compiler/abstractClass1.ts (6 errors) ==== - - abstract class Foo { - constructor(f: any) { } - public static bar(): void { } - - public empty() { } - } - - class Bar extends Foo { - constructor(f: any) { - super(f); - } - } - - var a = new Foo(1); // Error - ~~~~~~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'Foo'. - var b = new Foo(); // Error because of invalid constructor arguments - ~~~~~~~~~ -!!! error TS2346: Supplied parameters do not match any signature of call target. - ~~~~~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'Foo'. - - module baz { - export abstract class Qux { - } - export class Quz extends Qux { - } - } - - new baz.Qux(); - ~~~~~~~~~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'Qux'. - - // Valid - var c = new Bar(1); - c.empty(); - - // Calling a static method on a abstract class is valid - Foo.bar(); - - var Copy = Foo; - new Copy(); - ~~~~~~~~~~ -!!! error TS2346: Supplied parameters do not match any signature of call target. - ~~~~~~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'Foo'. - \ No newline at end of file diff --git a/tests/baselines/reference/abstractClass1.js b/tests/baselines/reference/abstractClass1.js deleted file mode 100644 index 06868a485f5..00000000000 --- a/tests/baselines/reference/abstractClass1.js +++ /dev/null @@ -1,106 +0,0 @@ -//// [abstractClass1.ts] - -abstract class Foo { - constructor(f: any) { } - public static bar(): void { } - - public empty() { } -} - -class Bar extends Foo { - constructor(f: any) { - super(f); - } -} - -var a = new Foo(1); // Error -var b = new Foo(); // Error because of invalid constructor arguments - -module baz { - export abstract class Qux { - } - export class Quz extends Qux { - } -} - -new baz.Qux(); - -// Valid -var c = new Bar(1); -c.empty(); - -// Calling a static method on a abstract class is valid -Foo.bar(); - -var Copy = Foo; -new Copy(); - - -//// [abstractClass1.js] -var __extends = (this && this.__extends) || function (d, b) { - for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; - function __() { this.constructor = d; } - d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); -}; -var Foo = (function () { - function Foo(f) { - } - Foo.bar = function () { }; - Foo.prototype.empty = function () { }; - return Foo; -})(); -var Bar = (function (_super) { - __extends(Bar, _super); - function Bar(f) { - _super.call(this, f); - } - return Bar; -})(Foo); -var a = new Foo(1); // Error -var b = new Foo(); // Error because of invalid constructor arguments -var baz; -(function (baz) { - var Qux = (function () { - function Qux() { - } - return Qux; - })(); - baz.Qux = Qux; - var Quz = (function (_super) { - __extends(Quz, _super); - function Quz() { - _super.apply(this, arguments); - } - return Quz; - })(Qux); - baz.Quz = Quz; -})(baz || (baz = {})); -new baz.Qux(); -// Valid -var c = new Bar(1); -c.empty(); -// Calling a static method on a abstract class is valid -Foo.bar(); -var Copy = Foo; -new Copy(); - - -//// [abstractClass1.d.ts] -declare abstract class Foo { - constructor(f: any); - static bar(): void; - empty(): void; -} -declare class Bar extends Foo { - constructor(f: any); -} -declare var a: Foo; -declare var b: any; -declare module baz { - abstract class Qux { - } - class Quz extends Qux { - } -} -declare var c: Bar; -declare var Copy: typeof Foo; diff --git a/tests/baselines/reference/abstractClassIdentifierName.js b/tests/baselines/reference/abstractClassIdentifierName.js deleted file mode 100644 index 0e53e44671a..00000000000 --- a/tests/baselines/reference/abstractClassIdentifierName.js +++ /dev/null @@ -1,14 +0,0 @@ -//// [abstractClassIdentifierName.ts] -class abstract { - - abstract(): void { } -} - - -//// [abstractClassIdentifierName.js] -var abstract = (function () { - function abstract() { - } - abstract.prototype.abstract = function () { }; - return abstract; -})(); diff --git a/tests/baselines/reference/abstractClassIdentifierName.symbols b/tests/baselines/reference/abstractClassIdentifierName.symbols deleted file mode 100644 index 12d878620d8..00000000000 --- a/tests/baselines/reference/abstractClassIdentifierName.symbols +++ /dev/null @@ -1,8 +0,0 @@ -=== tests/cases/compiler/abstractClassIdentifierName.ts === -class abstract { ->abstract : Symbol(abstract, Decl(abstractClassIdentifierName.ts, 0, 0)) - - abstract(): void { } ->abstract : Symbol(abstract, Decl(abstractClassIdentifierName.ts, 0, 16)) -} - diff --git a/tests/baselines/reference/abstractClassIdentifierName.types b/tests/baselines/reference/abstractClassIdentifierName.types deleted file mode 100644 index e31abf49a6f..00000000000 --- a/tests/baselines/reference/abstractClassIdentifierName.types +++ /dev/null @@ -1,8 +0,0 @@ -=== tests/cases/compiler/abstractClassIdentifierName.ts === -class abstract { ->abstract : abstract - - abstract(): void { } ->abstract : () => void -} - diff --git a/tests/baselines/reference/classAbstractAsIdentifier.js b/tests/baselines/reference/classAbstractAsIdentifier.js new file mode 100644 index 00000000000..6adadd346b5 --- /dev/null +++ b/tests/baselines/reference/classAbstractAsIdentifier.js @@ -0,0 +1,15 @@ +//// [classAbstractAsIdentifier.ts] +class abstract { + foo() { return 1; } +} + +new abstract; + +//// [classAbstractAsIdentifier.js] +var abstract = (function () { + function abstract() { + } + abstract.prototype.foo = function () { return 1; }; + return abstract; +})(); +new abstract; diff --git a/tests/baselines/reference/classAbstractAsIdentifier.symbols b/tests/baselines/reference/classAbstractAsIdentifier.symbols new file mode 100644 index 00000000000..f2ce2ebcab5 --- /dev/null +++ b/tests/baselines/reference/classAbstractAsIdentifier.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAsIdentifier.ts === +class abstract { +>abstract : Symbol(abstract, Decl(classAbstractAsIdentifier.ts, 0, 0)) + + foo() { return 1; } +>foo : Symbol(foo, Decl(classAbstractAsIdentifier.ts, 0, 16)) +} + +new abstract; +>abstract : Symbol(abstract, Decl(classAbstractAsIdentifier.ts, 0, 0)) + diff --git a/tests/baselines/reference/classAbstractAsIdentifier.types b/tests/baselines/reference/classAbstractAsIdentifier.types new file mode 100644 index 00000000000..e2894af804d --- /dev/null +++ b/tests/baselines/reference/classAbstractAsIdentifier.types @@ -0,0 +1,13 @@ +=== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractAsIdentifier.ts === +class abstract { +>abstract : abstract + + foo() { return 1; } +>foo : () => number +>1 : number +} + +new abstract; +>new abstract : abstract +>abstract : typeof abstract + diff --git a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt index 501a54e5539..33beb6d296b 100644 --- a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt +++ b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt @@ -1,8 +1,8 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,28): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(11,15): error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(13,15): error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(17,15): error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(11,15): error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'foo' from class 'AA'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(13,15): error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'foo' from class 'BB'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(17,15): error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'foo' from class 'CC'. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts (5 errors) ==== @@ -22,17 +22,17 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst declare class CC extends AA {} ~~ -!!! error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. +!!! error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'foo' from class 'AA'. declare class DD extends BB {} ~~ -!!! error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. +!!! error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'foo' from class 'BB'. declare abstract class EE extends BB {} declare class FF extends CC {} ~~ -!!! error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. +!!! error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'foo' from class 'CC'. declare abstract class GG extends CC {} diff --git a/tests/baselines/reference/classAbstractInAModule.errors.txt b/tests/baselines/reference/classAbstractInAModule.errors.txt new file mode 100644 index 00000000000..426da866087 --- /dev/null +++ b/tests/baselines/reference/classAbstractInAModule.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInAModule.ts(6,1): error TS2511: Cannot create an instance of the abstract class 'A'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInAModule.ts (1 errors) ==== + module M { + export abstract class A {} + export class B extends A {} + } + + new M.A; + ~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + new M.B; \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractInAModule.js b/tests/baselines/reference/classAbstractInAModule.js new file mode 100644 index 00000000000..e7ecd66b5bd --- /dev/null +++ b/tests/baselines/reference/classAbstractInAModule.js @@ -0,0 +1,34 @@ +//// [classAbstractInAModule.ts] +module M { + export abstract class A {} + export class B extends A {} +} + +new M.A; +new M.B; + +//// [classAbstractInAModule.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var M; +(function (M) { + var A = (function () { + function A() { + } + return A; + })(); + M.A = A; + var B = (function (_super) { + __extends(B, _super); + function B() { + _super.apply(this, arguments); + } + return B; + })(A); + M.B = B; +})(M || (M = {})); +new M.A; +new M.B; diff --git a/tests/baselines/reference/classAbstractInheritance.errors.txt b/tests/baselines/reference/classAbstractInheritance.errors.txt index a663a466757..3e106204415 100644 --- a/tests/baselines/reference/classAbstractInheritance.errors.txt +++ b/tests/baselines/reference/classAbstractInheritance.errors.txt @@ -1,6 +1,6 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(13,7): error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(15,7): error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(19,7): error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(13,7): error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'foo' from class 'AA'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(15,7): error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'foo' from class 'BB'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts(19,7): error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'foo' from class 'CC'. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInheritance.ts (3 errors) ==== @@ -18,16 +18,16 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst class CC extends AA {} ~~ -!!! error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'AA.foo'. +!!! error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'foo' from class 'AA'. class DD extends BB {} ~~ -!!! error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'BB.foo'. +!!! error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'foo' from class 'BB'. abstract class EE extends BB {} class FF extends CC {} ~~ -!!! error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'CC.foo'. +!!! error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'foo' from class 'CC'. abstract class GG extends CC {} \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractInstantiations2.errors.txt b/tests/baselines/reference/classAbstractInstantiations2.errors.txt index c3cb4a4cae4..8252887e98d 100644 --- a/tests/baselines/reference/classAbstractInstantiations2.errors.txt +++ b/tests/baselines/reference/classAbstractInstantiations2.errors.txt @@ -1,26 +1,20 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(6,28): error TS2304: Cannot find name 'bar'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'B'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(17,5): error TS2511: Cannot create an instance of the abstract class 'B'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(21,1): error TS2511: Cannot create an instance of the abstract class 'B'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(26,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'B.bar'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(45,14): error TS2516: All declarations of an abstract method must be consecutive. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(45,20): error TS1144: '{' or ';' expected. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(45,20): error TS2300: Duplicate identifier 'boolean'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(26,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'B'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,5): error TS2391: Function implementation is missing or not immediately following the declaration. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,5): error TS2512: Overload signatures must all be `abstract` or not `abstract. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,21): error TS1144: '{' or ';' expected. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,21): error TS2300: Duplicate identifier 'boolean'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(49,7): error TS2514: Classes containing abstract functions must be marked abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(49,7): error TS2514: Classes containing abstract methods must be marked abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(50,5): error TS1238: Abstract methods can only appear within an abstract class. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts (12 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts (8 errors) ==== class A { // ... } abstract class B { - foo(): number { return bar(); } - ~~~ -!!! error TS2304: Cannot find name 'bar'. + foo(): number { return this.bar(); } abstract bar() : number; } @@ -48,7 +42,7 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst class C extends B { } // error -- not declared abstract ~ -!!! error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'B.bar'. +!!! error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'B'. abstract class D extends B { } // okay @@ -67,24 +61,18 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst y : number; abstract quz(x : number, y : string) : boolean; // error -- declarations must be adjacent - abstract nom() boolean; - ~~~ -!!! error TS2516: All declarations of an abstract method must be consecutive. - ~~~~~~~ -!!! error TS1144: '{' or ';' expected. - ~~~~~~~ -!!! error TS2300: Duplicate identifier 'boolean'. - nom(x : number) boolean; // error -- use of modifier abstract must match on all overloads. + abstract nom(): boolean; + nom(x : number): boolean; // error -- use of modifier abstract must match on all overloads. + ~~~ +!!! error TS2391: Function implementation is missing or not immediately following the declaration. ~~~ !!! error TS2512: Overload signatures must all be `abstract` or not `abstract. - ~~~~~~~ -!!! error TS1144: '{' or ';' expected. - ~~~~~~~ -!!! error TS2300: Duplicate identifier 'boolean'. } class H { // error -- not declared abstract ~ -!!! error TS2514: Classes containing abstract functions must be marked abstract. +!!! error TS2514: Classes containing abstract methods must be marked abstract. abstract baz() : number; + ~~~~~~~~ +!!! error TS1238: Abstract methods can only appear within an abstract class. } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractInstantiations2.js b/tests/baselines/reference/classAbstractInstantiations2.js index 055bdfedbc3..5b868b3f795 100644 --- a/tests/baselines/reference/classAbstractInstantiations2.js +++ b/tests/baselines/reference/classAbstractInstantiations2.js @@ -4,7 +4,7 @@ class A { } abstract class B { - foo(): number { return bar(); } + foo(): number { return this.bar(); } abstract bar() : number; } @@ -43,8 +43,8 @@ abstract class G { y : number; abstract quz(x : number, y : string) : boolean; // error -- declarations must be adjacent - abstract nom() boolean; - nom(x : number) boolean; // error -- use of modifier abstract must match on all overloads. + abstract nom(): boolean; + nom(x : number): boolean; // error -- use of modifier abstract must match on all overloads. } class H { // error -- not declared abstract @@ -65,7 +65,7 @@ var A = (function () { var B = (function () { function B() { } - B.prototype.foo = function () { return bar(); }; + B.prototype.foo = function () { return this.bar(); }; return B; })(); new B; // error @@ -112,8 +112,6 @@ var F = (function (_super) { var G = (function () { function G() { } - G.prototype.nom = ; - G.prototype.nom = ; return G; })(); var H = (function () { diff --git a/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt b/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt index 488fbdeb36e..4b0870e6bc5 100644 --- a/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt +++ b/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt @@ -1,7 +1,7 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(6,13): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(8,14): error TS1029: 'public' modifier must precede 'abstract' modifier. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(9,14): error TS1029: 'protected' modifier must precede 'abstract' modifier. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(10,14): error TS1029: 'private' modifier must precede 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(10,14): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(12,14): error TS1237: 'static' modifier cannot be used with 'abstract' modifier. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(14,12): error TS1237: 'static' modifier cannot be used with 'abstract' modifier. @@ -24,7 +24,7 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst !!! error TS1029: 'protected' modifier must precede 'abstract' modifier. abstract private foo_dd(); ~~~~~~~ -!!! error TS1029: 'private' modifier must precede 'abstract' modifier. +!!! error TS1237: 'private' modifier cannot be used with 'abstract' modifier. abstract static foo_d(); ~~~~~~ diff --git a/tests/baselines/reference/classAbstractProperties.errors.txt b/tests/baselines/reference/classAbstractProperties.errors.txt index 30e7ca1153d..d3ee6308bc5 100644 --- a/tests/baselines/reference/classAbstractProperties.errors.txt +++ b/tests/baselines/reference/classAbstractProperties.errors.txt @@ -2,10 +2,11 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(3,12): error TS1236: 'abstract' modifier can only appear on a class or method declaration. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(4,15): error TS1236: 'abstract' modifier can only appear on a class or method declaration. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(5,13): error TS1236: 'abstract' modifier can only appear on a class or method declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(10,13): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(7,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(12,13): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts (5 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts (6 errors) ==== abstract class A { abstract x : number; ~~~~~~~~ @@ -20,6 +21,10 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst ~~~~~~~~ !!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. + abstract m: () => void; + ~~~~~~~~ +!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. + abstract foo_x() : number; public abstract foo_y() : number; protected abstract foo_z() : number; diff --git a/tests/baselines/reference/classAbstractProperties.js b/tests/baselines/reference/classAbstractProperties.js index a410715e4f7..0cbebcf0de0 100644 --- a/tests/baselines/reference/classAbstractProperties.js +++ b/tests/baselines/reference/classAbstractProperties.js @@ -5,6 +5,8 @@ abstract class A { protected abstract z : number; private abstract w : number; + abstract m: () => void; + abstract foo_x() : number; public abstract foo_y() : number; protected abstract foo_z() : number; diff --git a/tests/baselines/reference/classAbstractSuperCalls.errors.txt b/tests/baselines/reference/classAbstractSuperCalls.errors.txt index ea81b2b60af..a9dbf0f7ba8 100644 --- a/tests/baselines/reference/classAbstractSuperCalls.errors.txt +++ b/tests/baselines/reference/classAbstractSuperCalls.errors.txt @@ -1,7 +1,8 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,26): error TS2513: Abstract method 'foo.B' cannot be called via super expression. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,26): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts(14,41): error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts (1 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSuperCalls.ts (2 errors) ==== class A { foo() { return 1; } @@ -15,9 +16,11 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst class C extends B { foo() { return 2; } - qux() { return super.foo(); } // error, super is abstract + qux() { return super.foo() || super.foo; } // 2 errors, foo is abstract ~~~ -!!! error TS2513: Abstract method 'foo.B' cannot be called via super expression. +!!! error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. + ~~~ +!!! error TS2513: Abstract method 'foo' in class 'B' cannot be accessed via super expression. norf() { return super.bar(); } } diff --git a/tests/baselines/reference/classAbstractSuperCalls.js b/tests/baselines/reference/classAbstractSuperCalls.js index 152fd03f463..deccaa50ccf 100644 --- a/tests/baselines/reference/classAbstractSuperCalls.js +++ b/tests/baselines/reference/classAbstractSuperCalls.js @@ -12,7 +12,7 @@ abstract class B extends A { class C extends B { foo() { return 2; } - qux() { return super.foo(); } // error, super is abstract + qux() { return super.foo() || super.foo; } // 2 errors, foo is abstract norf() { return super.bar(); } } @@ -54,7 +54,7 @@ var C = (function (_super) { _super.apply(this, arguments); } C.prototype.foo = function () { return 2; }; - C.prototype.qux = function () { return _super.prototype.foo.call(this); }; // error, super is abstract + C.prototype.qux = function () { return _super.prototype.foo.call(this) || _super.prototype.foo; }; // 2 errors, foo is abstract C.prototype.norf = function () { return _super.prototype.bar.call(this); }; return C; })(B); diff --git a/tests/baselines/reference/classAbstractUsingAbstractMethod.errors.txt b/tests/baselines/reference/classAbstractUsingAbstractMethod1.errors.txt similarity index 72% rename from tests/baselines/reference/classAbstractUsingAbstractMethod.errors.txt rename to tests/baselines/reference/classAbstractUsingAbstractMethod1.errors.txt index 3ae5084e2db..df3682a36af 100644 --- a/tests/baselines/reference/classAbstractUsingAbstractMethod.errors.txt +++ b/tests/baselines/reference/classAbstractUsingAbstractMethod1.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts(16,5): error TS2511: Cannot create an instance of the abstract class 'C'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod1.ts(16,5): error TS2511: Cannot create an instance of the abstract class 'C'. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod.ts (1 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethod1.ts (1 errors) ==== abstract class A { abstract foo() : number; } diff --git a/tests/baselines/reference/classAbstractUsingAbstractMethod.js b/tests/baselines/reference/classAbstractUsingAbstractMethod1.js similarity index 89% rename from tests/baselines/reference/classAbstractUsingAbstractMethod.js rename to tests/baselines/reference/classAbstractUsingAbstractMethod1.js index 74bc80b2630..18d22803a7d 100644 --- a/tests/baselines/reference/classAbstractUsingAbstractMethod.js +++ b/tests/baselines/reference/classAbstractUsingAbstractMethod1.js @@ -1,4 +1,4 @@ -//// [classAbstractUsingAbstractMethod.ts] +//// [classAbstractUsingAbstractMethod1.ts] abstract class A { abstract foo() : number; } @@ -17,7 +17,7 @@ a.foo(); a = new C; // error, cannot instantiate abstract class. a.foo(); -//// [classAbstractUsingAbstractMethod.js] +//// [classAbstractUsingAbstractMethod1.js] var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } diff --git a/tests/baselines/reference/classAbstractUsingAbstractMethods2.errors.txt b/tests/baselines/reference/classAbstractUsingAbstractMethods2.errors.txt new file mode 100644 index 00000000000..8a0e5735a25 --- /dev/null +++ b/tests/baselines/reference/classAbstractUsingAbstractMethods2.errors.txt @@ -0,0 +1,42 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(1,7): error TS2514: Classes containing abstract methods must be marked abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(2,5): error TS1238: Abstract methods can only appear within an abstract class. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(5,7): error TS2515: Non-abstract class 'B' does not implement inherited abstract member 'foo' from class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(21,7): error TS2515: Non-abstract class 'BB' does not implement inherited abstract member 'foo' from class 'AA'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts (4 errors) ==== + class A { + ~ +!!! error TS2514: Classes containing abstract methods must be marked abstract. + abstract foo(); + ~~~~~~~~ +!!! error TS1238: Abstract methods can only appear within an abstract class. + } + + class B extends A {} + ~ +!!! error TS2515: Non-abstract class 'B' does not implement inherited abstract member 'foo' from class 'A'. + + abstract class C extends A {} + + class D extends A { + foo() {} + } + + abstract class E extends A { + foo() {} + } + + abstract class AA { + abstract foo(); + } + + class BB extends AA {} + ~~ +!!! error TS2515: Non-abstract class 'BB' does not implement inherited abstract member 'foo' from class 'AA'. + + abstract class CC extends AA {} + + class DD extends AA { + foo() {} + } \ No newline at end of file diff --git a/tests/baselines/reference/classWithAbstractMethods.js b/tests/baselines/reference/classAbstractUsingAbstractMethods2.js similarity index 91% rename from tests/baselines/reference/classWithAbstractMethods.js rename to tests/baselines/reference/classAbstractUsingAbstractMethods2.js index 91ccc5f9306..d5797232929 100644 --- a/tests/baselines/reference/classWithAbstractMethods.js +++ b/tests/baselines/reference/classAbstractUsingAbstractMethods2.js @@ -1,4 +1,4 @@ -//// [classWithAbstractMethods.ts] +//// [classAbstractUsingAbstractMethods2.ts] class A { abstract foo(); } @@ -27,7 +27,7 @@ class DD extends AA { foo() {} } -//// [classWithAbstractMethods.js] +//// [classAbstractUsingAbstractMethods2.js] var __extends = (this && this.__extends) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; function __() { this.constructor = d; } diff --git a/tests/baselines/reference/classAbstractWithInterface.errors.txt b/tests/baselines/reference/classAbstractWithInterface.errors.txt new file mode 100644 index 00000000000..7dc4dcd87c4 --- /dev/null +++ b/tests/baselines/reference/classAbstractWithInterface.errors.txt @@ -0,0 +1,7 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts(1,1): error TS1236: 'abstract' modifier can only appear on a class or method declaration. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts (1 errors) ==== + abstract interface I {} + ~~~~~~~~ +!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractWithInterface.js b/tests/baselines/reference/classAbstractWithInterface.js new file mode 100644 index 00000000000..317e393a2f5 --- /dev/null +++ b/tests/baselines/reference/classAbstractWithInterface.js @@ -0,0 +1,4 @@ +//// [classAbstractWithInterface.ts] +abstract interface I {} + +//// [classAbstractWithInterface.js] diff --git a/tests/baselines/reference/classWithAbstractMethods.errors.txt b/tests/baselines/reference/classWithAbstractMethods.errors.txt deleted file mode 100644 index d66303289ab..00000000000 --- a/tests/baselines/reference/classWithAbstractMethods.errors.txt +++ /dev/null @@ -1,42 +0,0 @@ -tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts(1,7): error TS2514: Classes containing abstract functions must be marked abstract. -tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts(2,5): error TS1238: Abstract methods can only appear within an abstract class. -tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts(5,7): error TS2515: Non-abstract class 'B' does not implement inherited abstract member 'A.foo'. -tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts(21,7): error TS2515: Non-abstract class 'BB' does not implement inherited abstract member 'AA.foo'. - - -==== tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts (4 errors) ==== - class A { - ~ -!!! error TS2514: Classes containing abstract functions must be marked abstract. - abstract foo(); - ~~~~~~~~ -!!! error TS1238: Abstract methods can only appear within an abstract class. - } - - class B extends A {} - ~ -!!! error TS2515: Non-abstract class 'B' does not implement inherited abstract member 'A.foo'. - - abstract class C extends A {} - - class D extends A { - foo() {} - } - - abstract class E extends A { - foo() {} - } - - abstract class AA { - abstract foo(); - } - - class BB extends AA {} - ~~ -!!! error TS2515: Non-abstract class 'BB' does not implement inherited abstract member 'AA.foo'. - - abstract class CC extends AA {} - - class DD extends AA { - foo() {} - } \ No newline at end of file From 30657d4d55666eb5275d550893740dbfa306f606 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Tue, 23 Jun 2015 12:39:15 -0700 Subject: [PATCH 190/309] Update LKG --- bin/tsserver.js | 3 +++ bin/typescript.js | 3 +++ bin/typescriptServices.js | 3 +++ 3 files changed, 9 insertions(+) diff --git a/bin/tsserver.js b/bin/tsserver.js index 6f4c99b36a6..2d937e57fad 100644 --- a/bin/tsserver.js +++ b/bin/tsserver.js @@ -36217,6 +36217,9 @@ var ts; } } function classifyToken(token) { + if (ts.nodeIsMissing(token)) { + return; + } var tokenStart = classifyLeadingTriviaAndGetTokenStart(token); var tokenWidth = token.end - tokenStart; ts.Debug.assert(tokenWidth >= 0); diff --git a/bin/typescript.js b/bin/typescript.js index 2e3a784b298..6989f225452 100644 --- a/bin/typescript.js +++ b/bin/typescript.js @@ -42395,6 +42395,9 @@ var ts; } } function classifyToken(token) { + if (ts.nodeIsMissing(token)) { + return; + } var tokenStart = classifyLeadingTriviaAndGetTokenStart(token); var tokenWidth = token.end - tokenStart; ts.Debug.assert(tokenWidth >= 0); diff --git a/bin/typescriptServices.js b/bin/typescriptServices.js index 2e3a784b298..6989f225452 100644 --- a/bin/typescriptServices.js +++ b/bin/typescriptServices.js @@ -42395,6 +42395,9 @@ var ts; } } function classifyToken(token) { + if (ts.nodeIsMissing(token)) { + return; + } var tokenStart = classifyLeadingTriviaAndGetTokenStart(token); var tokenWidth = token.end - tokenStart; ts.Debug.assert(tokenWidth >= 0); From b332727c7c2cddcd96a65d51d23fd9840e6a2d05 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 23 Jun 2015 13:30:10 -0700 Subject: [PATCH 191/309] updated comment in test and baseline --- .../reference/classAbstractInstantiations2.errors.txt | 4 ++-- tests/baselines/reference/classAbstractInstantiations2.js | 8 ++++---- .../classAbstractKeyword/classAbstractInstantiations2.ts | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/tests/baselines/reference/classAbstractInstantiations2.errors.txt b/tests/baselines/reference/classAbstractInstantiations2.errors.txt index 8252887e98d..1f64759f86d 100644 --- a/tests/baselines/reference/classAbstractInstantiations2.errors.txt +++ b/tests/baselines/reference/classAbstractInstantiations2.errors.txt @@ -27,13 +27,13 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst new AA; function constructB(Factory : typeof B) { - new Factory; // error -- Factory is of type typeof C + new Factory; // error -- Factory is of type typeof B. ~~~~~~~~~~~ !!! error TS2511: Cannot create an instance of the abstract class 'B'. } var BB = B; - new BB; // error -- BB is of type typeof C + new BB; // error -- BB is of type typeof B. ~~~~~~ !!! error TS2511: Cannot create an instance of the abstract class 'B'. diff --git a/tests/baselines/reference/classAbstractInstantiations2.js b/tests/baselines/reference/classAbstractInstantiations2.js index 5b868b3f795..1f45f02da0b 100644 --- a/tests/baselines/reference/classAbstractInstantiations2.js +++ b/tests/baselines/reference/classAbstractInstantiations2.js @@ -15,11 +15,11 @@ var AA: typeof A = BB; // error, AA is not of abstract type. new AA; function constructB(Factory : typeof B) { - new Factory; // error -- Factory is of type typeof C + new Factory; // error -- Factory is of type typeof B. } var BB = B; -new BB; // error -- BB is of type typeof C +new BB; // error -- BB is of type typeof B. var x : any = C; new x; // okay -- undefined behavior at runtime @@ -73,10 +73,10 @@ var BB = B; var AA = BB; // error, AA is not of abstract type. new AA; function constructB(Factory) { - new Factory; // error -- Factory is of type typeof C + new Factory; // error -- Factory is of type typeof B. } var BB = B; -new BB; // error -- BB is of type typeof C +new BB; // error -- BB is of type typeof B. var x = C; new x; // okay -- undefined behavior at runtime var C = (function (_super) { diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts index ef965dfe94b..3b68b898b94 100644 --- a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts @@ -14,11 +14,11 @@ var AA: typeof A = BB; // error, AA is not of abstract type. new AA; function constructB(Factory : typeof B) { - new Factory; // error -- Factory is of type typeof C + new Factory; // error -- Factory is of type typeof B. } var BB = B; -new BB; // error -- BB is of type typeof C +new BB; // error -- BB is of type typeof B. var x : any = C; new x; // okay -- undefined behavior at runtime From ef697f6307d514cb378b161128f6d74ffb0079c6 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Tue, 23 Jun 2015 14:00:05 -0700 Subject: [PATCH 192/309] PR feedback --- src/compiler/checker.ts | 46 +++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 18 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 2c4e18699d7..3db99a12686 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6769,9 +6769,20 @@ module ts { let argCount = getEffectiveArgumentCount(node, args, signature); for (let i = 0; i < argCount; i++) { let arg = getEffectiveArgument(node, args, i); - if (!arg || arg.kind !== SyntaxKind.OmittedExpression) { + // If the effective argument is 'undefined', then it is an argument that is present but is synthetic. + if (arg === undefined || arg.kind !== SyntaxKind.OmittedExpression) { let paramType = getTypeAtPosition(signature, i); - let argType = getEffectiveArgumentType(node, i, arg, paramType, excludeArgument, inferenceMapper, /*reportErrors*/ false); + let argType = getEffectiveArgumentType(node, i, arg); + + // If the effective argument type is 'undefined', there is no synthetic type + // for the argument. In that case, we should check the argument. + if (argType === undefined) { + // For context sensitive arguments we pass the identityMapper, which is a signal to treat all + // context sensitive function expressions as wildcards + let mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; + argType = checkExpressionWithContextualType(arg, paramType, mapper); + } + inferTypes(context, argType, paramType); } } @@ -6830,10 +6841,19 @@ module ts { let argCount = getEffectiveArgumentCount(node, args, signature); for (let i = 0; i < argCount; i++) { let arg = getEffectiveArgument(node, args, i); - if (!arg || arg.kind !== SyntaxKind.OmittedExpression) { + // If the effective argument is 'undefined', then it is an argument that is present but is synthetic. + if (arg === undefined || arg.kind !== SyntaxKind.OmittedExpression) { // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) let paramType = getTypeAtPosition(signature, i); - let argType = getEffectiveArgumentType(node, i, arg, paramType, excludeArgument, /*inferenceMapper*/ undefined, reportErrors); + let argType = getEffectiveArgumentType(node, i, arg); + + // If the effective argument type is 'undefined', there is no synthetic type + // for the argument. In that case, we should check the argument. + if (argType === undefined) { + argType = arg.kind === SyntaxKind.StringLiteral && !reportErrors + ? getStringLiteralType(arg) + : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + } // Use argument expression as error location when reporting errors let errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; @@ -7126,7 +7146,7 @@ module ts { /** * Gets the effective argument type for an argument in a call expression. */ - function getEffectiveArgumentType(node: CallLikeExpression, argIndex: number, arg: Expression, paramType: Type, excludeArgument: boolean[], inferenceMapper: TypeMapper, reportErrors: boolean): Type { + function getEffectiveArgumentType(node: CallLikeExpression, argIndex: number, arg: Expression): Type { // Decorators provide special arguments, a tagged template expression provides // a special first argument, and string literals get string literal types // unless we're reporting errors @@ -7136,20 +7156,10 @@ module ts { else if (argIndex === 0 && node.kind === SyntaxKind.TaggedTemplateExpression) { return globalTemplateStringsArrayType; } - else if (!inferenceMapper && !reportErrors && arg.kind === SyntaxKind.StringLiteral) { - return getStringLiteralType(arg); - } - else { - let mapper: TypeMapper; - if (inferenceMapper) { - mapper = excludeArgument && excludeArgument[argIndex] !== undefined ? identityMapper : inferenceMapper; - } - else { - mapper = excludeArgument && excludeArgument[argIndex] ? identityMapper : undefined; - } - return checkExpressionWithContextualType(arg, paramType, mapper); - } + // This is not a synthetic argument, so we return 'undefined' + // to signal that the caller needs to check the argument. + return undefined; } /** From 60ed259a90d1b8b7a8a90da077fe12b8cb92f950 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 23 Jun 2015 15:05:33 -0700 Subject: [PATCH 193/309] Preserve initializer. --- src/compiler/emitter.ts | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 5da2abe3699..4e19bb79e5f 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -3142,30 +3142,41 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { return; } - let paramName = parameter.name; + let { name: paramName, initializer } = parameter; if (isBindingPattern(paramName)) { - // In cases where a binding patternm is simply '[]' or '{}', - // we don't want to emit anything. - if (paramName.elements.length > 0) { + // In cases where a binding pattern is simply '[]' or '{}', + // we usually don't want to emit a var declaration; however, in the presence + // of an initializer, we must emit that expression to preserve side effects. + let hasBindingElements = paramName.elements.length > 0; + if (hasBindingElements || initializer) { writeLine(); write("var "); - emitDestructuring(parameter, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex]); + + if (hasBindingElements) { + emitDestructuring(parameter, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex]); + } + else { + emit(tempParameters[tempIndex]); + write(" = "); + emit(initializer); + } + write(";"); tempIndex++; } } - else if (parameter.initializer) { + else if (initializer) { writeLine(); emitStart(parameter); write("if ("); - emitNodeWithoutSourceMap(parameter.name); + emitNodeWithoutSourceMap(paramName); write(" === void 0)"); emitEnd(parameter); write(" { "); emitStart(parameter); - emitNodeWithoutSourceMap(parameter.name); + emitNodeWithoutSourceMap(paramName); write(" = "); - emitNodeWithoutSourceMap(parameter.initializer); + emitNodeWithoutSourceMap(initializer); emitEnd(parameter); write("; }"); } From 740fd9c908380147212ecd9a2d77b238e13c7172 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 23 Jun 2015 15:05:56 -0700 Subject: [PATCH 194/309] Updated baselines. --- .../baselines/reference/declarationEmitDestructuring4.js | 8 ++++++-- .../reference/emptyArrayBindingPatternParameter04.js | 1 + .../reference/emptyObjectBindingPatternParameter04.js | 1 + 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/tests/baselines/reference/declarationEmitDestructuring4.js b/tests/baselines/reference/declarationEmitDestructuring4.js index 1f43c255170..16e6b49a4cf 100644 --- a/tests/baselines/reference/declarationEmitDestructuring4.js +++ b/tests/baselines/reference/declarationEmitDestructuring4.js @@ -16,12 +16,16 @@ function baz4({} = { x: 10 }) { } // we will not make any modification and will emit // the similar binding pattern users' have written function baz(_a) { } -function baz1(_a) { } +function baz1(_a) { + var _a = [1, 2, 3]; +} function baz2(_a) { var _b = (_a === void 0 ? [[1, 2, 3]] : _a)[0]; } function baz3(_a) { } -function baz4(_a) { } +function baz4(_a) { + var _a = { x: 10 }; +} //// [declarationEmitDestructuring4.d.ts] diff --git a/tests/baselines/reference/emptyArrayBindingPatternParameter04.js b/tests/baselines/reference/emptyArrayBindingPatternParameter04.js index 3f52b95ab62..e0715499ffe 100644 --- a/tests/baselines/reference/emptyArrayBindingPatternParameter04.js +++ b/tests/baselines/reference/emptyArrayBindingPatternParameter04.js @@ -7,5 +7,6 @@ function f([] = [1,2,3,4]) { //// [emptyArrayBindingPatternParameter04.js] function f(_a) { + var _a = [1, 2, 3, 4]; var x, y, z; } diff --git a/tests/baselines/reference/emptyObjectBindingPatternParameter04.js b/tests/baselines/reference/emptyObjectBindingPatternParameter04.js index 6545ea9ad34..fc3e41d0709 100644 --- a/tests/baselines/reference/emptyObjectBindingPatternParameter04.js +++ b/tests/baselines/reference/emptyObjectBindingPatternParameter04.js @@ -7,5 +7,6 @@ function f({} = {a: 1, b: "2", c: true}) { //// [emptyObjectBindingPatternParameter04.js] function f(_a) { + var _a = { a: 1, b: "2", c: true }; var x, y, z; } From d2fe1c0a61b7518f8b1b2f32ba46703a1c1db9e3 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 23 Jun 2015 15:13:11 -0700 Subject: [PATCH 195/309] Added tests. --- .../completionsInObjectBindingPattern01.ts | 13 +++++++++++++ .../completionsInObjectBindingPattern02.ts | 13 +++++++++++++ .../completionsInObjectBindingPattern03.ts | 13 +++++++++++++ 3 files changed, 39 insertions(+) create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern01.ts create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern02.ts create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern03.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern01.ts b/tests/cases/fourslash/completionsInObjectBindingPattern01.ts new file mode 100644 index 00000000000..128e95b8ed3 --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern01.ts @@ -0,0 +1,13 @@ +/// + +////interface I { +//// property1: number; +//// property2: string; +////} +//// +////var foo: I; +////var { /**/ } = foo; + +goTo.marker(); +verify.completionListContains("property1"); +verify.completionListContains("property2"); \ No newline at end of file diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern02.ts b/tests/cases/fourslash/completionsInObjectBindingPattern02.ts new file mode 100644 index 00000000000..776fcc955c2 --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern02.ts @@ -0,0 +1,13 @@ +/// + +////interface I { +//// property1: number; +//// property2: string; +////} +//// +////var foo: I; +////var { property1, /**/ } = foo; + +goTo.marker(); +verify.not.completionListContains("property1"); +verify.completionListContains("property2"); \ No newline at end of file diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern03.ts b/tests/cases/fourslash/completionsInObjectBindingPattern03.ts new file mode 100644 index 00000000000..72da68168bd --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern03.ts @@ -0,0 +1,13 @@ +/// + +////interface I { +//// property1: number; +//// property2: string; +////} +//// +////var foo: I; +////var { property1: /**/ } = foo; + +goTo.marker(); +verify.completionListAllowsNewIdentifier(); +verify.completionListIsEmpty(); \ No newline at end of file From 0b78d037467f26629f260d9eeb87baaa982bcdc9 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 23 Jun 2015 15:32:02 -0700 Subject: [PATCH 196/309] Clean up 'getContainingObjectLiteralApplicableForCompletion'. --- src/services/services.ts | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 18510b9a178..5af32f9972c 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -3187,15 +3187,14 @@ namespace ts { return false; } - function getContainingObjectLiteralApplicableForCompletion(previousToken: Node): ObjectLiteralExpression { - // The locations in an object literal expression that are applicable for completion are property name definition locations. - - if (previousToken) { - let parent = previousToken.parent; - - switch (previousToken.kind) { + function getContainingObjectLiteralApplicableForCompletion(contextToken: Node): ObjectLiteralExpression { + // The locations in an object literal expression that + // are applicable for completion are property name definition locations. + if (contextToken) { + switch (contextToken.kind) { case SyntaxKind.OpenBraceToken: // let x = { | case SyntaxKind.CommaToken: // let x = { a: 0, | + let parent = contextToken.parent; if (parent && parent.kind === SyntaxKind.ObjectLiteralExpression) { return parent; } From 30ec5f92767b2f996c38b15c906598860f36d420 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 23 Jun 2015 16:08:19 -0700 Subject: [PATCH 197/309] Add test case for when in the middle/at the end of the word. --- .../completionsInObjectBindingPattern04.ts | 13 +++++++++++++ .../completionsInObjectBindingPattern05.ts | 12 ++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern04.ts create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern05.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern04.ts b/tests/cases/fourslash/completionsInObjectBindingPattern04.ts new file mode 100644 index 00000000000..92b202a1b37 --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern04.ts @@ -0,0 +1,13 @@ +/// + +////interface I { +//// property1: number; +//// property2: string; +////} +//// +////var foo: I; +////var { prope/**/ } = foo; + +goTo.marker(); +verify.completionListContains("property1"); +verify.completionListContains("property2"); \ No newline at end of file diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern05.ts b/tests/cases/fourslash/completionsInObjectBindingPattern05.ts new file mode 100644 index 00000000000..d17e11810df --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern05.ts @@ -0,0 +1,12 @@ +/// + +////interface I { +//// property1: number; +//// property2: string; +////} +//// +////var foo: I; +////var { property1/**/ } = foo; + +goTo.marker(); +verify.completionListContains("property1"); \ No newline at end of file From 6accbdf0299e01e723fd07676f98bb8f71694e88 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 23 Jun 2015 16:37:22 -0700 Subject: [PATCH 198/309] Generalize logic for upcoming work on object binding completion. --- src/services/services.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 5af32f9972c..1aeac286748 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -2985,8 +2985,8 @@ namespace ts { } function tryGetGlobalSymbols(): boolean { - let containingObjectLiteral = getContainingObjectLiteralApplicableForCompletion(contextToken); - if (containingObjectLiteral) { + let containingObjectLiteral = getContainingObjectLiteralOrBindingPatternIfApplicableForCompletion(contextToken); + if (containingObjectLiteral && containingObjectLiteral.kind === SyntaxKind.ObjectLiteralExpression) { // Object literal expression, look up possible property names from contextual type isMemberCompletion = true; isNewIdentifierLocation = true; @@ -3187,7 +3187,7 @@ namespace ts { return false; } - function getContainingObjectLiteralApplicableForCompletion(contextToken: Node): ObjectLiteralExpression { + function getContainingObjectLiteralOrBindingPatternIfApplicableForCompletion(contextToken: Node): ObjectLiteralExpression | BindingPattern { // The locations in an object literal expression that // are applicable for completion are property name definition locations. if (contextToken) { @@ -3195,8 +3195,8 @@ namespace ts { case SyntaxKind.OpenBraceToken: // let x = { | case SyntaxKind.CommaToken: // let x = { a: 0, | let parent = contextToken.parent; - if (parent && parent.kind === SyntaxKind.ObjectLiteralExpression) { - return parent; + if (parent && (parent.kind === SyntaxKind.ObjectLiteralExpression || parent.kind === SyntaxKind.ObjectBindingPattern)) { + return parent; } break; } From 6928bfae12c80a263d4f040751378807d88a7741 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 23 Jun 2015 17:00:11 -0700 Subject: [PATCH 199/309] Adding extra test per CR --- .../reference/classExpressionES63.js | 31 +++++++++++++++++ .../reference/classExpressionES63.symbols | 26 +++++++++++++++ .../reference/classExpressionES63.types | 33 +++++++++++++++++++ .../classExpressions/classExpressionES63.ts | 6 ++++ 4 files changed, 96 insertions(+) create mode 100644 tests/baselines/reference/classExpressionES63.js create mode 100644 tests/baselines/reference/classExpressionES63.symbols create mode 100644 tests/baselines/reference/classExpressionES63.types create mode 100644 tests/cases/conformance/es6/classExpressions/classExpressionES63.ts diff --git a/tests/baselines/reference/classExpressionES63.js b/tests/baselines/reference/classExpressionES63.js new file mode 100644 index 00000000000..6d357af7c5a --- /dev/null +++ b/tests/baselines/reference/classExpressionES63.js @@ -0,0 +1,31 @@ +//// [classExpressionES63.ts] +let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; +let c = new C(); +c.a; +c.b; +c.c; + + +//// [classExpressionES63.js] +let C = class class_1 extends class class_2 extends class class_3 { + constructor() { + this.a = 1; + } +} + { + constructor(...args) { + super(...args); + this.b = 2; + } +} + { + constructor(...args) { + super(...args); + this.c = 3; + } +} +; +let c = new C(); +c.a; +c.b; +c.c; diff --git a/tests/baselines/reference/classExpressionES63.symbols b/tests/baselines/reference/classExpressionES63.symbols new file mode 100644 index 00000000000..4e52d5ee9dd --- /dev/null +++ b/tests/baselines/reference/classExpressionES63.symbols @@ -0,0 +1,26 @@ +=== tests/cases/conformance/es6/classExpressions/classExpressionES63.ts === +let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; +>C : Symbol(C, Decl(classExpressionES63.ts, 0, 3)) +>a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43)) +>b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53)) +>c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63)) + +let c = new C(); +>c : Symbol(c, Decl(classExpressionES63.ts, 1, 3)) +>C : Symbol(C, Decl(classExpressionES63.ts, 0, 3)) + +c.a; +>c.a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43)) +>c : Symbol(c, Decl(classExpressionES63.ts, 1, 3)) +>a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43)) + +c.b; +>c.b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53)) +>c : Symbol(c, Decl(classExpressionES63.ts, 1, 3)) +>b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53)) + +c.c; +>c.c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63)) +>c : Symbol(c, Decl(classExpressionES63.ts, 1, 3)) +>c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63)) + diff --git a/tests/baselines/reference/classExpressionES63.types b/tests/baselines/reference/classExpressionES63.types new file mode 100644 index 00000000000..5b07bf79692 --- /dev/null +++ b/tests/baselines/reference/classExpressionES63.types @@ -0,0 +1,33 @@ +=== tests/cases/conformance/es6/classExpressions/classExpressionES63.ts === +let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; +>C : typeof (Anonymous class) +>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof (Anonymous class) +>class extends class { a = 1 } { b = 2 } : (Anonymous class) +>class { a = 1 } : (Anonymous class) +>a : number +>1 : number +>b : number +>2 : number +>c : number +>3 : number + +let c = new C(); +>c : (Anonymous class) +>new C() : (Anonymous class) +>C : typeof (Anonymous class) + +c.a; +>c.a : number +>c : (Anonymous class) +>a : number + +c.b; +>c.b : number +>c : (Anonymous class) +>b : number + +c.c; +>c.c : number +>c : (Anonymous class) +>c : number + diff --git a/tests/cases/conformance/es6/classExpressions/classExpressionES63.ts b/tests/cases/conformance/es6/classExpressions/classExpressionES63.ts new file mode 100644 index 00000000000..cbbe0927c30 --- /dev/null +++ b/tests/cases/conformance/es6/classExpressions/classExpressionES63.ts @@ -0,0 +1,6 @@ +// @target: es6 +let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 }; +let c = new C(); +c.a; +c.b; +c.c; From 55f195d445ede31aea7b83da435480bcf0d7c7e8 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 23 Jun 2015 17:06:47 -0700 Subject: [PATCH 200/309] Another change suggested in CR --- src/compiler/checker.ts | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 4891bff8630..9d3dc53da78 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5949,9 +5949,8 @@ namespace ts { captureLexicalThis(node, container); } - let classNode = isClassLike(container.parent) ? container.parent : undefined; - if (classNode) { - let symbol = getSymbolOfNode(classNode); + if (isClassLike(container.parent)) { + let symbol = getSymbolOfNode(container.parent); return container.flags & NodeFlags.Static ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); } return anyType; From 2aceeea064e8c39bcce7bd1949e6924953fd03a4 Mon Sep 17 00:00:00 2001 From: Tingan Ho Date: Wed, 24 Jun 2015 10:37:23 +0800 Subject: [PATCH 201/309] Fixes goto definitions for type predicates --- src/compiler/checker.ts | 4 ++++ .../fourslash/goToDefinitionTypePredicate.ts | 16 ++++++++++++++++ 2 files changed, 20 insertions(+) create mode 100644 tests/cases/fourslash/goToDefinitionTypePredicate.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 71aa2ce1a07..29ff56172f5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11925,6 +11925,10 @@ namespace ts { return resolveEntityName(entityName, meaning); } + if (entityName.parent.kind === SyntaxKind.TypePredicate) { + return resolveEntityName(entityName, /* meanings */ SymbolFlags.Variable); + } + // Do we want to return undefined here? return undefined; } diff --git a/tests/cases/fourslash/goToDefinitionTypePredicate.ts b/tests/cases/fourslash/goToDefinitionTypePredicate.ts new file mode 100644 index 00000000000..40f1d1eb94c --- /dev/null +++ b/tests/cases/fourslash/goToDefinitionTypePredicate.ts @@ -0,0 +1,16 @@ +/// + +//// /*classDeclaration*/class A {} +//// function f(/*parameterDeclaration*/parameter: any): /*parameterName*/parameter is /*typeReference*/A { +//// return typeof parameter === "string"; +//// } + +goTo.marker('parameterName'); + +goTo.definition(); +verify.caretAtMarker('parameterDeclaration'); + +goTo.marker('typeReference'); + +goTo.definition(); +verify.caretAtMarker('classDeclaration'); \ No newline at end of file From 485e31905731bfdf7101ddd0761338bc1e763103 Mon Sep 17 00:00:00 2001 From: Tingan Ho Date: Wed, 24 Jun 2015 10:48:22 +0800 Subject: [PATCH 202/309] Accept baselines --- tests/baselines/reference/typeGuardFunction.symbols | 11 +++++++++++ .../reference/typeGuardFunctionGenerics.symbols | 7 +++++++ .../baselines/reference/typeGuardOfFormIsType.symbols | 3 +++ .../typeGuardOfFormIsTypeOnInterfaces.symbols | 3 +++ 4 files changed, 24 insertions(+) diff --git a/tests/baselines/reference/typeGuardFunction.symbols b/tests/baselines/reference/typeGuardFunction.symbols index c315e721085..13ad30de5c5 100644 --- a/tests/baselines/reference/typeGuardFunction.symbols +++ b/tests/baselines/reference/typeGuardFunction.symbols @@ -25,16 +25,19 @@ class C extends A { declare function isA(p1: any): p1 is A; >isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 13, 21)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 13, 21)) >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0)) declare function isB(p1: any): p1 is B; >isB : Symbol(isB, Decl(typeGuardFunction.ts, 13, 39)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 14, 21)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 14, 21)) >B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1)) declare function isC(p1: any): p1 is C; >isC : Symbol(isC, Decl(typeGuardFunction.ts, 14, 39)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 15, 21)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 15, 21)) >C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1)) declare function retC(): C; @@ -98,6 +101,7 @@ interface I1 { (p1: A): p1 is C; >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 41, 5)) >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 41, 5)) >C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1)) } @@ -107,6 +111,7 @@ declare function isC_multipleParams(p1, p2): p1 is C; >isC_multipleParams : Symbol(isC_multipleParams, Decl(typeGuardFunction.ts, 42, 1)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 46, 36)) >p2 : Symbol(p2, Decl(typeGuardFunction.ts, 46, 39)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 46, 36)) >C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1)) if (isC_multipleParams(a, 0)) { @@ -127,6 +132,7 @@ var obj: { >func1 : Symbol(func1, Decl(typeGuardFunction.ts, 52, 10)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 53, 10)) >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 53, 10)) >C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1)) } class D { @@ -136,6 +142,7 @@ class D { >method1 : Symbol(method1, Decl(typeGuardFunction.ts, 55, 9)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 56, 12)) >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 56, 12)) >C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1)) return true; @@ -147,6 +154,7 @@ let f1 = (p1: A): p1 is C => false; >f1 : Symbol(f1, Decl(typeGuardFunction.ts, 62, 3)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 62, 10)) >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 62, 10)) >C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1)) // Function type @@ -155,6 +163,7 @@ declare function f2(p1: (p1: A) => p1 is C); >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 65, 20)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 65, 25)) >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 65, 25)) >C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1)) // Function expressions @@ -162,6 +171,7 @@ f2(function(p1: A): p1 is C { >f2 : Symbol(f2, Decl(typeGuardFunction.ts, 62, 35)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 68, 12)) >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0)) +>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 68, 12)) >C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1)) return true; @@ -182,6 +192,7 @@ declare function acceptingTypeGuardFunction(p1: (item) => item is A); >acceptingTypeGuardFunction : Symbol(acceptingTypeGuardFunction, Decl(typeGuardFunction.ts, 74, 25)) >p1 : Symbol(p1, Decl(typeGuardFunction.ts, 77, 44)) >item : Symbol(item, Decl(typeGuardFunction.ts, 77, 49)) +>item : Symbol(item, Decl(typeGuardFunction.ts, 77, 49)) >A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0)) acceptingTypeGuardFunction(isA); diff --git a/tests/baselines/reference/typeGuardFunctionGenerics.symbols b/tests/baselines/reference/typeGuardFunctionGenerics.symbols index 0ad8fab2fdb..100d610070d 100644 --- a/tests/baselines/reference/typeGuardFunctionGenerics.symbols +++ b/tests/baselines/reference/typeGuardFunctionGenerics.symbols @@ -25,11 +25,13 @@ class C extends A { declare function isB(p1): p1 is B; >isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1)) >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 13, 21)) +>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 13, 21)) >B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1)) declare function isC(p1): p1 is C; >isC : Symbol(isC, Decl(typeGuardFunctionGenerics.ts, 13, 34)) >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 14, 21)) +>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 14, 21)) >C : Symbol(C, Decl(typeGuardFunctionGenerics.ts, 7, 1)) declare function retC(x): C; @@ -52,6 +54,7 @@ declare function funB(p1: (p1) => T, p2: any): p2 is T; >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 18, 30)) >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 18, 22)) >p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 18, 39)) +>p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 18, 39)) >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 18, 22)) declare function funC(p1: (p1) => p1 is T): T; @@ -59,6 +62,7 @@ declare function funC(p1: (p1) => p1 is T): T; >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22)) >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 19, 25)) >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 19, 30)) +>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 19, 30)) >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22)) >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22)) @@ -67,8 +71,10 @@ declare function funD(p1: (p1) => p1 is T, p2: any): p2 is T; >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22)) >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 20, 25)) >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 20, 30)) +>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 20, 30)) >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22)) >p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 20, 45)) +>p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 20, 45)) >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22)) declare function funE(p1: (p1) => p1 is T, p2: U): T; @@ -77,6 +83,7 @@ declare function funE(p1: (p1) => p1 is T, p2: U): T; >U : Symbol(U, Decl(typeGuardFunctionGenerics.ts, 21, 24)) >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 21, 28)) >p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 21, 33)) +>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 21, 33)) >T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 21, 22)) >p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 21, 48)) >U : Symbol(U, Decl(typeGuardFunctionGenerics.ts, 21, 24)) diff --git a/tests/baselines/reference/typeGuardOfFormIsType.symbols b/tests/baselines/reference/typeGuardOfFormIsType.symbols index a7bd0f4c165..e7e8965673d 100644 --- a/tests/baselines/reference/typeGuardOfFormIsType.symbols +++ b/tests/baselines/reference/typeGuardOfFormIsType.symbols @@ -31,6 +31,7 @@ var strOrNum: string | number; function isC1(x: any): x is C1 { >isC1 : Symbol(isC1, Decl(typeGuardOfFormIsType.ts, 12, 30)) >x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 14, 14)) +>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 14, 14)) >C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0)) return true; @@ -39,6 +40,7 @@ function isC1(x: any): x is C1 { function isC2(x: any): x is C2 { >isC2 : Symbol(isC2, Decl(typeGuardOfFormIsType.ts, 16, 1)) >x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 18, 14)) +>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 18, 14)) >C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1)) return true; @@ -47,6 +49,7 @@ function isC2(x: any): x is C2 { function isD1(x: any): x is D1 { >isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1)) >x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 22, 14)) +>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 22, 14)) >D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1)) return true; diff --git a/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.symbols b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.symbols index 37249ef7659..641d20d95cd 100644 --- a/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.symbols +++ b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.symbols @@ -50,6 +50,7 @@ var strOrNum: string | number; function isC1(x: any): x is C1 { >isC1 : Symbol(isC1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 30)) >x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 20, 14)) +>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 20, 14)) >C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0)) return true; @@ -58,6 +59,7 @@ function isC1(x: any): x is C1 { function isC2(x: any): x is C2 { >isC2 : Symbol(isC2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 22, 1)) >x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 24, 14)) +>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 24, 14)) >C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1)) return true; @@ -66,6 +68,7 @@ function isC2(x: any): x is C2 { function isD1(x: any): x is D1 { >isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1)) >x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 28, 14)) +>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 28, 14)) >D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1)) return true; From 1d0454534201239138df4eb721f268b4ccd617fe Mon Sep 17 00:00:00 2001 From: Tingan Ho Date: Wed, 24 Jun 2015 11:00:48 +0800 Subject: [PATCH 203/309] Changed symbolflag --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 29ff56172f5..a97a8428a0b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11926,7 +11926,7 @@ namespace ts { } if (entityName.parent.kind === SyntaxKind.TypePredicate) { - return resolveEntityName(entityName, /* meanings */ SymbolFlags.Variable); + return resolveEntityName(entityName, /* meanings */ SymbolFlags.FunctionScopedVariable); } // Do we want to return undefined here? From cb9f80f1aa378164b40d2c332abb3107b98fbf97 Mon Sep 17 00:00:00 2001 From: Tingan Ho Date: Wed, 24 Jun 2015 11:32:30 +0800 Subject: [PATCH 204/309] Remove space and s --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index a97a8428a0b..db04831f832 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11926,7 +11926,7 @@ namespace ts { } if (entityName.parent.kind === SyntaxKind.TypePredicate) { - return resolveEntityName(entityName, /* meanings */ SymbolFlags.FunctionScopedVariable); + return resolveEntityName(entityName, /*meaning*/ SymbolFlags.FunctionScopedVariable); } // Do we want to return undefined here? From da1bc6bac8d637dda683aee727b3154cb95023eb Mon Sep 17 00:00:00 2001 From: jbondc Date: Wed, 24 Jun 2015 10:56:23 -0400 Subject: [PATCH 205/309] Don't report an error for 1.toString(), just emit a space for JS compat. --- .../diagnosticInformationMap.generated.ts | 1 - src/compiler/diagnosticMessages.json | 4 ---- src/compiler/emitter.ts | 6 +++++- src/compiler/parser.ts | 17 ++++------------- src/compiler/types.ts | 1 - tests/cases/compiler/numLit.ts | 18 ++++++++++-------- 6 files changed, 19 insertions(+), 28 deletions(-) diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 46976813120..09b009711fe 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -569,6 +569,5 @@ namespace ts { decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." }, - Numeric_literal_0_cannot_be_followed_by_an_expression: { code: 9004, category: DiagnosticCategory.Error, key: "Numeric literal {0} cannot be followed by an expression." }, }; } \ No newline at end of file diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 4b705396fe5..fee46a84c1e 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2268,9 +2268,5 @@ "'class' expressions are not currently supported.": { "category": "Error", "code": 9003 - }, - "Numeric literal {0} cannot be followed by an expression.": { - "category": "Error", - "code": 9004 } } diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 3fbe640254f..363acf7b651 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1778,7 +1778,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { emit(node.expression); let indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, node.dotToken); - write("."); + if (!indentedBeforeDot && node.expression.kind === SyntaxKind.NumericLiteral) { + write(" ."); // JS compat with numeric literal + } else { + write("."); + } let indentedAfterDot = indentIfOnDifferentLines(node, node.dotToken, node.name); emit(node.name); decreaseIndentIf(indentedBeforeDot, indentedAfterDot); diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 55fdcd91d34..14c7d6da455 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -100,8 +100,6 @@ namespace ts { visitNode(cbNode, (node).type) || visitNode(cbNode, (node).equalsGreaterThanToken) || visitNode(cbNode, (node).body); - case SyntaxKind.NumericLiteral: - return visitNode(cbNode, (node).invalidDotExpression); case SyntaxKind.TypeReference: return visitNode(cbNode, (node).typeName) || visitNodes(cbNodes, (node).typeArguments); @@ -1847,20 +1845,13 @@ namespace ts { if (sourceText.charCodeAt(tokenPos) === CharacterCodes._0 && isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) { node.flags |= NodeFlags.OctalLiteral; } - else if (token === SyntaxKind.DotToken) { - // Issue #2632 Keep space for 3 .toString() - if (isWhiteSpace(sourceText.charCodeAt(node.end))) { - node.end++; - scanner.setTextPos(node.end + 1); - } - } else if (token === SyntaxKind.Identifier && sourceText.charCodeAt(node.end-1) === CharacterCodes.dot) { nextCharCode = sourceText.charCodeAt(node.end); if (!isWhiteSpace(nextCharCode) && !isLineBreak(nextCharCode)) { - // Eat up an invalid expression following '1.' e.g. 1.something() - node.invalidDotExpression = parseLeftHandSideExpressionOrHigher(); - parseErrorAtPosition(node.end, node.invalidDotExpression.end - node.end, Diagnostics.Numeric_literal_0_cannot_be_followed_by_an_expression, "'" + sourceText.substring(tokenPos, node.end) + "'"); - node.end = node.invalidDotExpression.end; + // If we see 23.Identifier, go back 1 char to scan .Identifier + node.end = node.end - 1; + scanner.setTextPos(node.end); + nextToken() } } } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 187cead4842..40135fe22e4 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -737,7 +737,6 @@ namespace ts { text: string; isUnterminated?: boolean; hasExtendedUnicodeEscape?: boolean; - invalidDotExpression?: LeftHandSideExpression; // 1.toString() we attach the node but never emit it } export interface TemplateExpression extends PrimaryExpression { diff --git a/tests/cases/compiler/numLit.ts b/tests/cases/compiler/numLit.ts index d9d42f9018c..abe3505703d 100644 --- a/tests/cases/compiler/numLit.ts +++ b/tests/cases/compiler/numLit.ts @@ -1,15 +1,17 @@ 1..toString(); 1.0.toString(); -1.toString(); // error: Numeric literal '1.' cannot be followed by an expression. +1.toString(); 1.+2.0 + 3. ; // Preserve whitespace where important for JS compatibility var i: number = 1; var test1 = i.toString(); -var test2 = 2.toString(); // error: Numeric literal '2.' cannot be followed by an expression. -var test3 = 3 .toString(); // preserve whitepace -var test4 = 3.['toString'](); -var test5 = 3 -.toString(); // preserve whitepace -var test6 = new Number(4).toString(); -var test7 = 3. + 3. \ No newline at end of file +var test2 = 2.toString(); // emitted as 2 .toString() +var test3 = 3 .toString(); +var test4 = 3 .toString(); +var test5 = 3 .toString(); +var test6 = 3.['toString'](); +var test7 = 3 +.toString(); +var test8 = new Number(4).toString(); +var test9 = 3. + 3. From 71dc7a5947c201c60f11e4f4e950e258354d3f2b Mon Sep 17 00:00:00 2001 From: jbondc Date: Wed, 24 Jun 2015 11:08:54 -0400 Subject: [PATCH 206/309] Accept baselines --- tests/baselines/reference/numLit.errors.txt | 24 ----------- tests/baselines/reference/numLit.js | 41 +++++++++++-------- .../reference/toStringOnPrimitives.js | 2 +- 3 files changed, 24 insertions(+), 43 deletions(-) delete mode 100644 tests/baselines/reference/numLit.errors.txt diff --git a/tests/baselines/reference/numLit.errors.txt b/tests/baselines/reference/numLit.errors.txt deleted file mode 100644 index 66f11141c15..00000000000 --- a/tests/baselines/reference/numLit.errors.txt +++ /dev/null @@ -1,24 +0,0 @@ -tests/cases/compiler/numLit.ts(3,3): error TS9004: Numeric literal '1.' cannot be followed by an expression. -tests/cases/compiler/numLit.ts(9,15): error TS9004: Numeric literal '2.' cannot be followed by an expression. - - -==== tests/cases/compiler/numLit.ts (2 errors) ==== - 1..toString(); - 1.0.toString(); - 1.toString(); // error: Numeric literal '1.' cannot be followed by an expression. - ~~~~~~~~~~ -!!! error TS9004: Numeric literal '1.' cannot be followed by an expression. - 1.+2.0 + 3. ; - - // Preserve whitespace where important for JS compatibility - var i: number = 1; - var test1 = i.toString(); - var test2 = 2.toString(); // error: Numeric literal '2.' cannot be followed by an expression. - ~~~~~~~~~~ -!!! error TS9004: Numeric literal '2.' cannot be followed by an expression. - var test3 = 3 .toString(); // preserve whitepace - var test4 = 3.['toString'](); - var test5 = 3 - .toString(); // preserve whitepace - var test6 = new Number(4).toString(); - var test7 = 3. + 3. \ No newline at end of file diff --git a/tests/baselines/reference/numLit.js b/tests/baselines/reference/numLit.js index a6e33a9a3c1..5620a9edcad 100644 --- a/tests/baselines/reference/numLit.js +++ b/tests/baselines/reference/numLit.js @@ -1,32 +1,37 @@ //// [numLit.ts] 1..toString(); 1.0.toString(); -1.toString(); // error: Numeric literal '1.' cannot be followed by an expression. +1.toString(); 1.+2.0 + 3. ; // Preserve whitespace where important for JS compatibility var i: number = 1; var test1 = i.toString(); -var test2 = 2.toString(); // error: Numeric literal '2.' cannot be followed by an expression. -var test3 = 3 .toString(); // preserve whitepace -var test4 = 3.['toString'](); -var test5 = 3 -.toString(); // preserve whitepace -var test6 = new Number(4).toString(); -var test7 = 3. + 3. +var test2 = 2.toString(); // emitted as 2 .toString() +var test3 = 3 .toString(); +var test4 = 3 .toString(); +var test5 = 3 .toString(); +var test6 = 3.['toString'](); +var test7 = 3 +.toString(); +var test8 = new Number(4).toString(); +var test9 = 3. + 3. + //// [numLit.js] -1..toString(); -1.0.toString(); -1.toString(); // error: Numeric literal '1.' cannot be followed by an expression. +1. .toString(); +1.0 .toString(); +1 .toString(); 1. + 2.0 + 3.; // Preserve whitespace where important for JS compatibility var i = 1; var test1 = i.toString(); -var test2 = 2.toString(); // error: Numeric literal '2.' cannot be followed by an expression. -var test3 = 3 .toString(); // preserve whitepace -var test4 = 3.['toString'](); -var test5 = 3 - .toString(); // preserve whitepace -var test6 = new Number(4).toString(); -var test7 = 3. + 3.; +var test2 = 2 .toString(); // emitted as 2 .toString() +var test3 = 3 .toString(); +var test4 = 3 .toString(); +var test5 = 3 .toString(); +var test6 = 3.['toString'](); +var test7 = 3 + .toString(); +var test8 = new Number(4).toString(); +var test9 = 3. + 3.; diff --git a/tests/baselines/reference/toStringOnPrimitives.js b/tests/baselines/reference/toStringOnPrimitives.js index bce8a997ba7..007bb5429b0 100644 --- a/tests/baselines/reference/toStringOnPrimitives.js +++ b/tests/baselines/reference/toStringOnPrimitives.js @@ -8,4 +8,4 @@ aBool.toString(); true.toString(); var aBool = false; aBool.toString(); -1..toString(); +1. .toString(); From 8ae53a43102ec9b1301ffd8cf8cae0ec18ae203d Mon Sep 17 00:00:00 2001 From: jbondc Date: Wed, 24 Jun 2015 11:21:48 -0400 Subject: [PATCH 207/309] Accept baselines (missing files). --- tests/baselines/reference/numLit.symbols | 65 ++++++++++++++++ tests/baselines/reference/numLit.types | 97 ++++++++++++++++++++++++ 2 files changed, 162 insertions(+) create mode 100644 tests/baselines/reference/numLit.symbols create mode 100644 tests/baselines/reference/numLit.types diff --git a/tests/baselines/reference/numLit.symbols b/tests/baselines/reference/numLit.symbols new file mode 100644 index 00000000000..1f4067d233f --- /dev/null +++ b/tests/baselines/reference/numLit.symbols @@ -0,0 +1,65 @@ +=== tests/cases/compiler/numLit.ts === +1..toString(); +>1..toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +1.0.toString(); +>1.0.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +1.toString(); +>1.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +1.+2.0 + 3. ; + +// Preserve whitespace where important for JS compatibility +var i: number = 1; +>i : Symbol(i, Decl(numLit.ts, 6, 3)) + +var test1 = i.toString(); +>test1 : Symbol(test1, Decl(numLit.ts, 7, 3)) +>i.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>i : Symbol(i, Decl(numLit.ts, 6, 3)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +var test2 = 2.toString(); // emitted as 2 .toString() +>test2 : Symbol(test2, Decl(numLit.ts, 8, 3)) +>2.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +var test3 = 3 .toString(); +>test3 : Symbol(test3, Decl(numLit.ts, 9, 3)) +>3 .toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +var test4 = 3 .toString(); +>test4 : Symbol(test4, Decl(numLit.ts, 10, 3)) +>3 .toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +var test5 = 3 .toString(); +>test5 : Symbol(test5, Decl(numLit.ts, 11, 3)) +>3 .toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +var test6 = 3.['toString'](); +>test6 : Symbol(test6, Decl(numLit.ts, 12, 3)) +>'toString' : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +var test7 = 3 +>test7 : Symbol(test7, Decl(numLit.ts, 13, 3)) +>3.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +.toString(); +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +var test8 = new Number(4).toString(); +>test8 : Symbol(test8, Decl(numLit.ts, 15, 3)) +>new Number(4).toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) + +var test9 = 3. + 3. +>test9 : Symbol(test9, Decl(numLit.ts, 16, 3)) + diff --git a/tests/baselines/reference/numLit.types b/tests/baselines/reference/numLit.types new file mode 100644 index 00000000000..ba72abb2825 --- /dev/null +++ b/tests/baselines/reference/numLit.types @@ -0,0 +1,97 @@ +=== tests/cases/compiler/numLit.ts === +1..toString(); +>1..toString() : string +>1..toString : (radix?: number) => string +>1. : number +>toString : (radix?: number) => string + +1.0.toString(); +>1.0.toString() : string +>1.0.toString : (radix?: number) => string +>1.0 : number +>toString : (radix?: number) => string + +1.toString(); +>1.toString() : string +>1.toString : (radix?: number) => string +>1 : number +>toString : (radix?: number) => string + +1.+2.0 + 3. ; +>1.+2.0 + 3. : number +>1.+2.0 : number +>1. : number +>2.0 : number +>3. : number + +// Preserve whitespace where important for JS compatibility +var i: number = 1; +>i : number +>1 : number + +var test1 = i.toString(); +>test1 : string +>i.toString() : string +>i.toString : (radix?: number) => string +>i : number +>toString : (radix?: number) => string + +var test2 = 2.toString(); // emitted as 2 .toString() +>test2 : string +>2.toString() : string +>2.toString : (radix?: number) => string +>2 : number +>toString : (radix?: number) => string + +var test3 = 3 .toString(); +>test3 : string +>3 .toString() : string +>3 .toString : (radix?: number) => string +>3 : number +>toString : (radix?: number) => string + +var test4 = 3 .toString(); +>test4 : string +>3 .toString() : string +>3 .toString : (radix?: number) => string +>3 : number +>toString : (radix?: number) => string + +var test5 = 3 .toString(); +>test5 : string +>3 .toString() : string +>3 .toString : (radix?: number) => string +>3 : number +>toString : (radix?: number) => string + +var test6 = 3.['toString'](); +>test6 : string +>3.['toString']() : string +>3.['toString'] : (radix?: number) => string +>3. : number +>'toString' : string + +var test7 = 3 +>test7 : string +>3.toString() : string +>3.toString : (radix?: number) => string +>3 : number + +.toString(); +>toString : (radix?: number) => string + +var test8 = new Number(4).toString(); +>test8 : string +>new Number(4).toString() : string +>new Number(4).toString : (radix?: number) => string +>new Number(4) : Number +>Number : NumberConstructor +>4 : number +>toString : (radix?: number) => string + +var test9 = 3. + 3. +>test9 : number +>3. + 3. : number +>3. : number +>3. : number + From c6498d79e57fa8ca018b3b7060b7d81c3c487a5e Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 11:28:56 -0400 Subject: [PATCH 208/309] Changed ordering of verifications. --- tests/cases/fourslash/completionsInObjectBindingPattern02.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern02.ts b/tests/cases/fourslash/completionsInObjectBindingPattern02.ts index 776fcc955c2..6d2b7a6b516 100644 --- a/tests/cases/fourslash/completionsInObjectBindingPattern02.ts +++ b/tests/cases/fourslash/completionsInObjectBindingPattern02.ts @@ -9,5 +9,5 @@ ////var { property1, /**/ } = foo; goTo.marker(); -verify.not.completionListContains("property1"); -verify.completionListContains("property2"); \ No newline at end of file +verify.completionListContains("property2"); +verify.not.completionListContains("property1"); \ No newline at end of file From 513d73ad4b48601511e5b6515db663a973d22dc4 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 11:30:10 -0400 Subject: [PATCH 209/309] Don't print in the middle of tests. --- src/harness/fourslash.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 5915698462c..ff5baddbb70 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -660,8 +660,7 @@ module FourSlash { } errorMsg += "]\n"; - Harness.IO.log(errorMsg); - this.raiseError("Member list is not empty at Caret"); + this.raiseError("Member list is not empty at Caret: " + errorMsg); } } From c114de1a836524f3a60e9569d5369b7631d6f5fc Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 11:31:36 -0400 Subject: [PATCH 210/309] Basic completion in object destructuring working. --- src/compiler/checker.ts | 6 +++++- src/services/services.ts | 31 ++++++++++++++++++++----------- 2 files changed, 25 insertions(+), 12 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index a18f2921a9a..00426d2aaf3 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11993,7 +11993,7 @@ namespace ts { return resolveExternalModuleName(node, node); } - // Intentional fall-through + // fall through case SyntaxKind.NumericLiteral: // index access if (node.parent.kind === SyntaxKind.ElementAccessExpression && (node.parent).argumentExpression === node) { @@ -12060,6 +12060,10 @@ namespace ts { return symbol && getTypeOfSymbol(symbol); } + if (isBindingPattern(node)) { + return getTypeForVariableLikeDeclaration(node.parent); + } + if (isInRightSideOfImportOrExportAssignment(node)) { let symbol = getSymbolInfo(node); let declaredType = symbol && getDeclaredTypeOfSymbol(symbol); diff --git a/src/services/services.ts b/src/services/services.ts index 1aeac286748..78ce084b3ff 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -2985,21 +2985,32 @@ namespace ts { } function tryGetGlobalSymbols(): boolean { - let containingObjectLiteral = getContainingObjectLiteralOrBindingPatternIfApplicableForCompletion(contextToken); - if (containingObjectLiteral && containingObjectLiteral.kind === SyntaxKind.ObjectLiteralExpression) { + let objectLikeContainer = getContainingObjectLiteralOrBindingPatternIfApplicableForCompletion(contextToken); + if (objectLikeContainer) { // Object literal expression, look up possible property names from contextual type isMemberCompletion = true; isNewIdentifierLocation = true; - let contextualType = typeChecker.getContextualType(containingObjectLiteral); - if (!contextualType) { + let typeForObject: Type; + let existingMembers: Declaration[]; + + if (objectLikeContainer.kind === SyntaxKind.ObjectLiteralExpression) { + typeForObject = typeChecker.getContextualType(objectLikeContainer); + existingMembers = (objectLikeContainer).properties; + } + else { + typeForObject = typeChecker.getTypeAtLocation(objectLikeContainer); + existingMembers = (objectLikeContainer).elements; + } + + if (!typeForObject) { return false; } - let contextualTypeMembers = typeChecker.getPropertiesOfType(contextualType); - if (contextualTypeMembers && contextualTypeMembers.length > 0) { + let typeMembers = typeChecker.getPropertiesOfType(typeForObject); + if (typeMembers && typeMembers.length > 0) { // Add filtered items to the completion list - symbols = filterContextualMembersList(contextualTypeMembers, containingObjectLiteral.properties); + symbols = filterContextualMembersList(typeMembers, existingMembers); } } else if (getAncestor(contextToken, SyntaxKind.ImportClause)) { @@ -3235,8 +3246,7 @@ namespace ts { containingNodeKind === SyntaxKind.ClassDeclaration || // class A Date: Wed, 24 Jun 2015 11:41:59 -0400 Subject: [PATCH 211/309] Got filtering working in object binding patterns. --- src/services/services.ts | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 78ce084b3ff..2283d02ccb9 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -3010,7 +3010,7 @@ namespace ts { let typeMembers = typeChecker.getPropertiesOfType(typeForObject); if (typeMembers && typeMembers.length > 0) { // Add filtered items to the completion list - symbols = filterContextualMembersList(typeMembers, existingMembers); + symbols = filterObjectMembersList(typeMembers, existingMembers); } } else if (getAncestor(contextToken, SyntaxKind.ImportClause)) { @@ -3356,26 +3356,28 @@ namespace ts { return filter(exports, e => !lookUp(exisingImports, e.name)); } - function filterContextualMembersList(contextualMemberSymbols: Symbol[], existingMembers: Declaration[]): Symbol[] { + function filterObjectMembersList(contextualMemberSymbols: Symbol[], existingMembers: Declaration[]): Symbol[] { if (!existingMembers || existingMembers.length === 0) { return contextualMemberSymbols; } let existingMemberNames: Map = {}; - forEach(existingMembers, m => { - if (m.kind !== SyntaxKind.PropertyAssignment && m.kind !== SyntaxKind.ShorthandPropertyAssignment) { - // Ignore omitted expressions for missing members in the object literal - return; + for (let m of existingMembers) { + if (m.kind !== SyntaxKind.PropertyAssignment && + m.kind !== SyntaxKind.ShorthandPropertyAssignment && + m.kind !== SyntaxKind.BindingElement) { + // Ignore omitted expressions for missing members + continue; } if (m.getStart() <= position && position <= m.getEnd()) { // If this is the current item we are editing right now, do not filter it out - return; + continue; } // TODO(jfreeman): Account for computed property name existingMemberNames[(m.name).text] = true; - }); + } let filteredMembers: Symbol[] = []; forEach(contextualMemberSymbols, s => { From f9ed47a1bb2f31aa7359e1a553620740e0f1cb53 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 12:28:54 -0400 Subject: [PATCH 212/309] Add the services sources as dependencies to tsserver. --- Jakefile.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Jakefile.js b/Jakefile.js index 07a2ade06a6..a0ec0d880fe 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -103,7 +103,7 @@ var serverSources = [ "server.ts" ].map(function (f) { return path.join(serverDirectory, f); -}); +}).concat(servicesSources); var languageServiceLibrarySources = [ "editorServices.ts", From d3c59f4cc2c062f377896f01c001757ea5c2a940 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 12:33:49 -0400 Subject: [PATCH 213/309] Added more tests. --- .../completionsInObjectBindingPattern06.ts | 12 ++++++++++++ .../completionsInObjectBindingPattern07.ts | 18 ++++++++++++++++++ .../completionsInObjectBindingPattern08.ts | 18 ++++++++++++++++++ .../completionsInObjectBindingPattern09.ts | 19 +++++++++++++++++++ 4 files changed, 67 insertions(+) create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern06.ts create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern07.ts create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern08.ts create mode 100644 tests/cases/fourslash/completionsInObjectBindingPattern09.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern06.ts b/tests/cases/fourslash/completionsInObjectBindingPattern06.ts new file mode 100644 index 00000000000..8060c2bde78 --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern06.ts @@ -0,0 +1,12 @@ +/// + +////interface I { +//// property1: number; +//// property2: string; +////} +//// +////var foo: I; +////var { property1, property2, /**/ } = foo; + +goTo.marker(); +verify.completionListIsEmpty(); \ No newline at end of file diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern07.ts b/tests/cases/fourslash/completionsInObjectBindingPattern07.ts new file mode 100644 index 00000000000..a3015346aa3 --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern07.ts @@ -0,0 +1,18 @@ +/// + +////interface I { +//// propertyOfI_1: number; +//// propertyOfI_2: string; +////} +////interface J { +//// property1: I; +//// property2: string; +////} +//// +////var foo: J; +////var { property1: { /**/ } } = foo; + +goTo.marker(); +verify.completionListContains("propertyOfI_1"); +verify.completionListContains("propertyOfI_2"); +verify.not.completionListContains("property2"); \ No newline at end of file diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern08.ts b/tests/cases/fourslash/completionsInObjectBindingPattern08.ts new file mode 100644 index 00000000000..6d6be330b83 --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern08.ts @@ -0,0 +1,18 @@ +/// + +////interface I { +//// propertyOfI_1: number; +//// propertyOfI_2: string; +////} +////interface J { +//// property1: I; +//// property2: string; +////} +//// +////var foo: J; +////var { property1: { propertyOfI_1, /**/ } } = foo; + +goTo.marker(); +verify.completionListContains("propertyOfI_2"); +verify.not.completionListContains("propertyOfI_1"); +verify.not.completionListContains("property2"); \ No newline at end of file diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern09.ts b/tests/cases/fourslash/completionsInObjectBindingPattern09.ts new file mode 100644 index 00000000000..2698e78667b --- /dev/null +++ b/tests/cases/fourslash/completionsInObjectBindingPattern09.ts @@ -0,0 +1,19 @@ +/// + +////interface I { +//// propertyOfI_1: number; +//// propertyOfI_2: string; +////} +////interface J { +//// property1: I; +//// property2: string; +////} +//// +////var foo: J; +////var { property1: { propertyOfI_1, }, /**/ } = foo; + +goTo.marker(); +verify.completionListContains("property2"); +verify.not.completionListContains("property1"); +verify.not.completionListContains("propertyOfI_2"); +verify.not.completionListContains("propertyOfI_1"); \ No newline at end of file From d892a55aa9cd14b86bd6578ed102540fbcf7c8eb Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 12:35:11 -0400 Subject: [PATCH 214/309] Use 'propertyName' when available in a BindingPattern. --- src/services/services.ts | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 2283d02ccb9..25949082e8d 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -3363,20 +3363,31 @@ namespace ts { let existingMemberNames: Map = {}; for (let m of existingMembers) { + // Ignore omitted expressions for missing members if (m.kind !== SyntaxKind.PropertyAssignment && m.kind !== SyntaxKind.ShorthandPropertyAssignment && m.kind !== SyntaxKind.BindingElement) { - // Ignore omitted expressions for missing members continue; } + // If this is the current item we are editing right now, do not filter it out if (m.getStart() <= position && position <= m.getEnd()) { - // If this is the current item we are editing right now, do not filter it out continue; } - // TODO(jfreeman): Account for computed property name - existingMemberNames[(m.name).text] = true; + let existingName: string; + + if (m.kind === SyntaxKind.BindingElement && (m).propertyName) { + existingName = (m).propertyName.text; + } + else { + // TODO(jfreeman): Account for computed property name + // NOTE: if one only performs this step when m.name is an identifier, + // things like '__proto__' are not filtered out. + existingName = (m.name).text; + } + + existingMemberNames[existingName] = true; } let filteredMembers: Symbol[] = []; From 713a70d794356a2fd5c6ba9d5a84cbde0d392803 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 12:39:10 -0400 Subject: [PATCH 215/309] Renamed tests. --- ...dingPattern01.ts => completionListInObjectBindingPattern01.ts} | 0 ...dingPattern02.ts => completionListInObjectBindingPattern02.ts} | 0 ...dingPattern03.ts => completionListInObjectBindingPattern03.ts} | 0 ...dingPattern04.ts => completionListInObjectBindingPattern04.ts} | 0 ...dingPattern05.ts => completionListInObjectBindingPattern05.ts} | 0 ...dingPattern06.ts => completionListInObjectBindingPattern06.ts} | 0 ...dingPattern07.ts => completionListInObjectBindingPattern07.ts} | 0 ...dingPattern08.ts => completionListInObjectBindingPattern08.ts} | 0 ...dingPattern09.ts => completionListInObjectBindingPattern09.ts} | 0 9 files changed, 0 insertions(+), 0 deletions(-) rename tests/cases/fourslash/{completionsInObjectBindingPattern01.ts => completionListInObjectBindingPattern01.ts} (100%) rename tests/cases/fourslash/{completionsInObjectBindingPattern02.ts => completionListInObjectBindingPattern02.ts} (100%) rename tests/cases/fourslash/{completionsInObjectBindingPattern03.ts => completionListInObjectBindingPattern03.ts} (100%) rename tests/cases/fourslash/{completionsInObjectBindingPattern04.ts => completionListInObjectBindingPattern04.ts} (100%) rename tests/cases/fourslash/{completionsInObjectBindingPattern05.ts => completionListInObjectBindingPattern05.ts} (100%) rename tests/cases/fourslash/{completionsInObjectBindingPattern06.ts => completionListInObjectBindingPattern06.ts} (100%) rename tests/cases/fourslash/{completionsInObjectBindingPattern07.ts => completionListInObjectBindingPattern07.ts} (100%) rename tests/cases/fourslash/{completionsInObjectBindingPattern08.ts => completionListInObjectBindingPattern08.ts} (100%) rename tests/cases/fourslash/{completionsInObjectBindingPattern09.ts => completionListInObjectBindingPattern09.ts} (100%) diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern01.ts b/tests/cases/fourslash/completionListInObjectBindingPattern01.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern01.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern01.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern02.ts b/tests/cases/fourslash/completionListInObjectBindingPattern02.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern02.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern02.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern03.ts b/tests/cases/fourslash/completionListInObjectBindingPattern03.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern03.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern03.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern04.ts b/tests/cases/fourslash/completionListInObjectBindingPattern04.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern04.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern04.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern05.ts b/tests/cases/fourslash/completionListInObjectBindingPattern05.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern05.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern05.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern06.ts b/tests/cases/fourslash/completionListInObjectBindingPattern06.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern06.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern06.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern07.ts b/tests/cases/fourslash/completionListInObjectBindingPattern07.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern07.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern07.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern08.ts b/tests/cases/fourslash/completionListInObjectBindingPattern08.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern08.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern08.ts diff --git a/tests/cases/fourslash/completionsInObjectBindingPattern09.ts b/tests/cases/fourslash/completionListInObjectBindingPattern09.ts similarity index 100% rename from tests/cases/fourslash/completionsInObjectBindingPattern09.ts rename to tests/cases/fourslash/completionListInObjectBindingPattern09.ts From 36a30c42b5d53aa1ee1911515e29aa6645e6b003 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Wed, 24 Jun 2015 11:53:53 -0700 Subject: [PATCH 216/309] Rename functions and variables, also a small refactoring. --- src/services/formatting/smartIndenter.ts | 44 ++++++++++++++++-------- 1 file changed, 29 insertions(+), 15 deletions(-) diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index b9636a8ddb8..db748f7f494 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -298,35 +298,49 @@ namespace ts.formatting { function getLineIndentationWhenExpressionIsInMultiLine(node: Node, sourceFile: SourceFile, options: EditorOptions): number { // actual indentation should not be used when: // - node is close parenthesis - this is the end of the expression - // - node is property access expression - if (node.kind !== SyntaxKind.CloseParenToken && - node.kind !== SyntaxKind.PropertyAccessExpression && - node.parent && ( + if (node.kind === SyntaxKind.CloseParenToken) { + return Value.Unknown; + } + + if (node.parent && ( node.parent.kind === SyntaxKind.CallExpression || - node.parent.kind === SyntaxKind.NewExpression)) { + node.parent.kind === SyntaxKind.NewExpression) && + (node.parent).expression !== node) { - let parentExpression = (node.parent).expression; - let startingExpression = getStartingExpression(parentExpression); + let fullCallOrNewExpression = (node.parent).expression; + let startingExpression = getStartingExpression(fullCallOrNewExpression); - if (parentExpression === startingExpression) { + if (fullCallOrNewExpression === startingExpression) { return Value.Unknown; } - let parentExpressionEnd = sourceFile.getLineAndCharacterOfPosition(parentExpression.end); + let fullCallOrNewExpressionEnd = sourceFile.getLineAndCharacterOfPosition(fullCallOrNewExpression.end); let startingExpressionEnd = sourceFile.getLineAndCharacterOfPosition(startingExpression.end); - if (parentExpressionEnd.line === startingExpressionEnd.line) { + if (fullCallOrNewExpressionEnd.line === startingExpressionEnd.line) { return Value.Unknown; } - return findColumnForFirstNonWhitespaceCharacterInLine(parentExpressionEnd, sourceFile, options); + return findColumnForFirstNonWhitespaceCharacterInLine(fullCallOrNewExpressionEnd, sourceFile, options); } + return Value.Unknown; - function getStartingExpression(expression: PropertyAccessExpression | CallExpression | ElementAccessExpression) { - while (expression.expression) - expression = expression.expression; - return expression; + function getStartingExpression(node: PropertyAccessExpression | CallExpression | ElementAccessExpression) { + while (true) { + switch (node.kind) { + case SyntaxKind.CallExpression: + case SyntaxKind.NewExpression: + case SyntaxKind.PropertyAccessExpression: + case SyntaxKind.ElementAccessExpression: + + node = node.expression; + break; + default: + return node; + } + } + return node; } } From 15c68421f1a9b9d8d38a37b7d8765172bdcc9cc0 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 24 Jun 2015 12:46:43 -0700 Subject: [PATCH 217/309] consolidated looping through class members into one loop --- src/compiler/checker.ts | 18 ++++++++++++++---- src/compiler/core.ts | 5 +++++ 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8554f4a0091..63ac250c2ff 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10730,11 +10730,21 @@ namespace ts { }); } - forEach(node.members, checkSourceElement); + // forEach(node.members, checkSourceElement); - // Classes containing abstract methods must be marked abstract - if (!(node.flags & NodeFlags.Abstract) && forEach(node.members, element => element.flags & NodeFlags.Abstract)) { - error(node, Diagnostics.Classes_containing_abstract_methods_must_be_marked_abstract); + if(node.flags & NodeFlags.Abstract) { + forEach(node.members, checkSourceElement); + } + else { + forEach(node.members, element => { + checkSourceElement(element); + + // Classes containing abstract methods must be marked abstract + if (element.flags & NodeFlags.Abstract) { + error(node, Diagnostics.Classes_containing_abstract_methods_must_be_marked_abstract); + } + return undefined; + }); } if (produceDiagnostics) { diff --git a/src/compiler/core.ts b/src/compiler/core.ts index ced477eeeec..39ccbdb4939 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -59,6 +59,11 @@ namespace ts { export interface StringSet extends Map { } + /** + * Iterates through 'array' by index and performs the callback on each element of array + * until the callback returns a truthy value, then returns that value. + * If no such value is found, the callback is applied to each element of array. + */ export function forEach(array: T[], callback: (element: T, index: number) => U): U { if (array) { for (let i = 0, len = array.length; i < len; i++) { From cc4511d9a15fb61af5ec26ee495e6047ee2af4f0 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Wed, 24 Jun 2015 12:48:35 -0700 Subject: [PATCH 218/309] Update LKG --- bin/lib.core.es6.d.ts | 4 + bin/lib.es6.d.ts | 4 + bin/tsc.js | 538 ++++++++++++++++++-------- bin/tsserver.js | 582 ++++++++++++++++++++-------- bin/typescript.d.ts | 2 +- bin/typescript.js | 734 +++++++++++++++++++++++++++--------- bin/typescriptServices.d.ts | 2 +- bin/typescriptServices.js | 734 +++++++++++++++++++++++++++--------- 8 files changed, 1940 insertions(+), 660 deletions(-) diff --git a/bin/lib.core.es6.d.ts b/bin/lib.core.es6.d.ts index 1ee111caa9b..50c7fcc9017 100644 --- a/bin/lib.core.es6.d.ts +++ b/bin/lib.core.es6.d.ts @@ -1880,6 +1880,7 @@ interface Map { } interface MapConstructor { + new (): Map; new (): Map; new (iterable: Iterable<[K, V]>): Map; prototype: Map; @@ -1896,6 +1897,7 @@ interface WeakMap { } interface WeakMapConstructor { + new (): WeakMap; new (): WeakMap; new (iterable: Iterable<[K, V]>): WeakMap; prototype: WeakMap; @@ -1917,6 +1919,7 @@ interface Set { } interface SetConstructor { + new (): Set; new (): Set; new (iterable: Iterable): Set; prototype: Set; @@ -1932,6 +1935,7 @@ interface WeakSet { } interface WeakSetConstructor { + new (): WeakSet; new (): WeakSet; new (iterable: Iterable): WeakSet; prototype: WeakSet; diff --git a/bin/lib.es6.d.ts b/bin/lib.es6.d.ts index e17cb3f35cf..931d60ec47a 100644 --- a/bin/lib.es6.d.ts +++ b/bin/lib.es6.d.ts @@ -1880,6 +1880,7 @@ interface Map { } interface MapConstructor { + new (): Map; new (): Map; new (iterable: Iterable<[K, V]>): Map; prototype: Map; @@ -1896,6 +1897,7 @@ interface WeakMap { } interface WeakMapConstructor { + new (): WeakMap; new (): WeakMap; new (iterable: Iterable<[K, V]>): WeakMap; prototype: WeakMap; @@ -1917,6 +1919,7 @@ interface Set { } interface SetConstructor { + new (): Set; new (): Set; new (iterable: Iterable): Set; prototype: Set; @@ -1932,6 +1935,7 @@ interface WeakSet { } interface WeakSetConstructor { + new (): WeakSet; new (): WeakSet; new (iterable: Iterable): WeakSet; prototype: WeakSet; diff --git a/bin/tsc.js b/bin/tsc.js index e5f449c4101..9e1d681e218 100644 --- a/bin/tsc.js +++ b/bin/tsc.js @@ -1166,6 +1166,12 @@ var ts; An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, + The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: { code: 1236, category: ts.DiagnosticCategory.Error, key: "The return type of a property decorator function must be either 'void' or 'any'." }, + The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: { code: 1237, category: ts.DiagnosticCategory.Error, key: "The return type of a parameter decorator function must be either 'void' or 'any'." }, + Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: { code: 1238, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of class decorator when called as an expression." }, + Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: { code: 1239, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of parameter decorator when called as an expression." }, + Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: { code: 1240, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of property decorator when called as an expression." }, + Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: { code: 1241, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of method decorator when called as an expression." }, Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.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: ts.DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -1541,9 +1547,7 @@ var ts; property_declarations_can_only_be_used_in_a_ts_file: { code: 8014, category: ts.DiagnosticCategory.Error, key: "'property declarations' can only be used in a .ts file." }, enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: ts.DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." }, type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: ts.DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." }, - decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: ts.DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, - Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: ts.DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, - class_expressions_are_not_currently_supported: { code: 9003, category: ts.DiagnosticCategory.Error, key: "'class' expressions are not currently supported." } + decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: ts.DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." } }; })(ts || (ts = {})); /// @@ -3214,7 +3218,7 @@ var ts; } } function getStrictModeIdentifierMessage(node) { - if (ts.getAncestor(node, 204) || ts.getAncestor(node, 177)) { + if (ts.getContainingClass(node)) { return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; } if (file.externalModuleIndicator) { @@ -3252,7 +3256,7 @@ var ts; } } function getStrictModeEvalOrArgumentsMessage(node) { - if (ts.getAncestor(node, 204) || ts.getAncestor(node, 177)) { + if (ts.getContainingClass(node)) { return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; } if (file.externalModuleIndicator) { @@ -3504,7 +3508,7 @@ var ts; } if (node.flags & 112 && node.parent.kind === 137 && - (node.parent.parent.kind === 204 || node.parent.parent.kind === 177)) { + ts.isClassLike(node.parent.parent)) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); } @@ -3928,6 +3932,7 @@ var ts; case 208: case 206: case 204: + case 177: return; default: if (isFunctionLike(node)) { @@ -3962,20 +3967,11 @@ var ts; } ts.isVariableLike = isVariableLike; function isAccessor(node) { - if (node) { - switch (node.kind) { - case 138: - case 139: - return true; - } - } - return false; + return node && (node.kind === 138 || node.kind === 139); } ts.isAccessor = isAccessor; function isClassLike(node) { - if (node) { - return node.kind === 204 || node.kind === 177; - } + return node && (node.kind === 204 || node.kind === 177); } ts.isClassLike = isClassLike; function isFunctionLike(node) { @@ -4017,6 +4013,15 @@ var ts; } } ts.getContainingFunction = getContainingFunction; + function getContainingClass(node) { + while (true) { + node = node.parent; + if (!node || isClassLike(node)) { + return node; + } + } + } + ts.getContainingClass = getContainingClass; function getThisContainer(node, includeArrowFunctions) { while (true) { node = node.parent; @@ -4025,7 +4030,7 @@ var ts; } switch (node.kind) { case 129: - if (node.parent.parent.kind === 204) { + if (isClassLike(node.parent.parent)) { return node; } node = node.parent; @@ -4066,7 +4071,7 @@ var ts; return node; switch (node.kind) { case 129: - if (node.parent.parent.kind === 204) { + if (isClassLike(node.parent.parent)) { return node; } node = node.parent; @@ -4406,6 +4411,7 @@ var ts; case 166: case 155: case 204: + case 177: case 137: case 207: case 229: @@ -5107,7 +5113,7 @@ var ts; function isExpressionWithTypeArgumentsInClassExtendsClause(node) { return node.kind === 179 && node.parent.token === 79 && - node.parent.parent.kind === 204; + isClassLike(node.parent.parent); } ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; function isSupportedExpressionWithTypeArguments(node) { @@ -9709,10 +9715,7 @@ var ts; var globalIteratorType; var globalIterableIteratorType; var anyArrayType; - var getGlobalClassDecoratorType; - var getGlobalParameterDecoratorType; - var getGlobalPropertyDecoratorType; - var getGlobalMethodDecoratorType; + var getGlobalTypedPropertyDescriptorType; var tupleTypes = {}; var unionTypes = {}; var stringLiteralTypes = {}; @@ -9969,7 +9972,7 @@ var ts; break; case 134: case 133: - if (location.parent.kind === 204 && !(location.flags & 128)) { + if (ts.isClassLike(location.parent) && !(location.flags & 128)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455)) { @@ -9979,6 +9982,7 @@ var ts; } break; case 204: + case 177: case 205: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056)) { if (lastLocation && lastLocation.flags & 128) { @@ -9987,10 +9991,17 @@ var ts; } break loop; } + if (location.kind === 177 && meaning & 32) { + var className = location.name; + if (className && name === className.text) { + result = location.symbol; + break loop; + } + } break; case 129: grandparent = location.parent.parent; - if (grandparent.kind === 204 || grandparent.kind === 205) { + if (ts.isClassLike(grandparent) || grandparent.kind === 205) { if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); return undefined; @@ -10022,15 +10033,6 @@ var ts; } } break; - case 177: - if (meaning & 32) { - var className = location.name; - if (className && name === className.text) { - result = location.symbol; - break loop; - } - } - break; case 132: if (location.parent && location.parent.kind === 131) { location = location.parent; @@ -10731,15 +10733,24 @@ var ts; } var _displayBuilder; function getSymbolDisplayBuilder() { - function appendSymbolNameOnly(symbol, writer) { - if (symbol.declarations && symbol.declarations.length > 0) { + function getNameOfSymbol(symbol) { + if (symbol.declarations && symbol.declarations.length) { var declaration = symbol.declarations[0]; if (declaration.name) { - writer.writeSymbol(ts.declarationNameToString(declaration.name), symbol); - return; + return ts.declarationNameToString(declaration.name); + } + switch (declaration.kind) { + case 177: + return "(Anonymous class)"; + case 165: + case 166: + return "(Anonymous function)"; } } - writer.writeSymbol(symbol.name, symbol); + return symbol.name; + } + function appendSymbolNameOnly(symbol, writer) { + writer.writeSymbol(getNameOfSymbol(symbol), symbol); } function buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags, typeFlags) { var parentSymbol; @@ -11655,9 +11666,9 @@ var ts; if (!node) { return typeParameters; } - if (node.kind === 204 || node.kind === 203 || - node.kind === 165 || node.kind === 136 || - node.kind === 166) { + if (node.kind === 204 || node.kind === 177 || + node.kind === 203 || node.kind === 165 || + node.kind === 136 || node.kind === 166) { var declarations = node.typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); @@ -11666,14 +11677,15 @@ var ts; } } function getOuterTypeParametersOfClassOrInterface(symbol) { - var kind = symbol.flags & 32 ? 204 : 205; - return appendOuterTypeParameters(undefined, ts.getDeclarationOfKind(symbol, kind)); + var declaration = symbol.flags & 32 ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 205); + return appendOuterTypeParameters(undefined, declaration); } function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) { var result; for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { var node = _a[_i]; - if (node.kind === 205 || node.kind === 204 || node.kind === 206) { + if (node.kind === 205 || node.kind === 204 || + node.kind === 177 || node.kind === 206) { var declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -12686,6 +12698,12 @@ var ts; function getGlobalESSymbolConstructorSymbol() { return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); } + function createTypedPropertyDescriptorType(propertyType) { + var globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); + return globalTypedPropertyDescriptorType !== emptyObjectType + ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) + : emptyObjectType; + } function createTypeFromGenericGlobalType(genericGlobalType, elementType) { return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, [elementType]) : emptyObjectType; } @@ -13101,8 +13119,8 @@ var ts; function checkTypeSubtypeOf(source, target, errorNode, headMessage, containingMessageChain) { return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source, target, errorNode, headMessage) { - return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage); + function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain) { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source, target) { var sourceType = getOrCreateTypeFromSignature(source); @@ -14487,9 +14505,9 @@ var ts; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 204 ? container.parent : undefined; getNodeLinks(node).flags |= 2; if (container.kind === 134 || container.kind === 137) { + var classNode = container.parent; getNodeLinks(classNode).flags |= 4; } else { @@ -14528,9 +14546,8 @@ var ts; if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 204 ? container.parent : undefined; - if (classNode) { - var symbol = getSymbolOfNode(classNode); + if (ts.isClassLike(container.parent)) { + var symbol = getSymbolOfNode(container.parent); return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); } return anyType; @@ -14545,7 +14562,7 @@ var ts; } function checkSuperExpression(node) { var isCallExpression = node.parent.kind === 160 && node.parent.expression === node; - var classDeclaration = ts.getAncestor(node, 204); + var classDeclaration = ts.getContainingClass(node); var classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); var baseClassType = classType && getBaseTypes(classType)[0]; if (!baseClassType) { @@ -14567,7 +14584,7 @@ var ts; container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = languageVersion < 2; } - if (container && container.parent && container.parent.kind === 204) { + if (container && ts.isClassLike(container.parent)) { if (container.flags & 128) { canUseSuperExpression = container.kind === 136 || @@ -15050,7 +15067,7 @@ var ts; if (!(flags & (32 | 64))) { return; } - var enclosingClassDeclaration = ts.getAncestor(node, 204); + var enclosingClassDeclaration = ts.getContainingClass(node); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); if (flags & 32) { @@ -15228,7 +15245,7 @@ var ts; if (node.kind === 162) { checkExpression(node.template); } - else { + else if (node.kind !== 132) { ts.forEach(node.arguments, function (argument) { checkExpression(argument); }); @@ -15278,7 +15295,8 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 176) { + var arg = args[i]; + if (arg && arg.kind === 176) { return i; } } @@ -15288,6 +15306,8 @@ var ts; var adjustedArgCount; var typeArguments; var callIsIncomplete; + var isDecorator; + var spreadArgIndex = -1; if (node.kind === 162) { var tagExpression = node; adjustedArgCount = args.length; @@ -15304,6 +15324,11 @@ var ts; callIsIncomplete = !!templateLiteral.isUnterminated; } } + else if (node.kind === 132) { + isDecorator = true; + typeArguments = undefined; + adjustedArgCount = getEffectiveArgumentCount(node, undefined, signature); + } else { var callExpression = node; if (!callExpression.arguments) { @@ -15313,13 +15338,13 @@ var ts; adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; callIsIncomplete = callExpression.arguments.end === callExpression.end; typeArguments = callExpression.typeArguments; + spreadArgIndex = getSpreadArgumentIndex(args); } var hasRightNumberOfTypeArgs = !typeArguments || (signature.typeParameters && typeArguments.length === signature.typeParameters.length); if (!hasRightNumberOfTypeArgs) { return false; } - var spreadArgIndex = getSpreadArgumentIndex(args); if (spreadArgIndex >= 0) { return signature.hasRestParameter && spreadArgIndex >= signature.parameters.length - 1; } @@ -15346,7 +15371,7 @@ var ts; }); return getSignatureInstantiation(signature, getInferredTypes(context)); } - function inferTypeArguments(signature, args, excludeArgument, context) { + function inferTypeArguments(node, signature, args, excludeArgument, context) { var typeParameters = signature.typeParameters; var inferenceMapper = createInferenceMapper(context); for (var i = 0; i < typeParameters.length; i++) { @@ -15357,15 +15382,13 @@ var ts; if (context.failedTypeParameterIndex !== undefined && !context.inferences[context.failedTypeParameterIndex].isFixed) { context.failedTypeParameterIndex = undefined; } - for (var i = 0; i < args.length; i++) { - var arg = args[i]; - if (arg.kind !== 178) { + var argCount = getEffectiveArgumentCount(node, args, signature); + for (var i = 0; i < argCount; i++) { + var arg = getEffectiveArgument(node, args, i); + if (arg === undefined || arg.kind !== 178) { var paramType = getTypeAtPosition(signature, i); - var argType = void 0; - if (i === 0 && args[i].parent.kind === 162) { - argType = globalTemplateStringsArrayType; - } - else { + var argType = getEffectiveArgumentType(node, i, arg); + if (argType === undefined) { var mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; argType = checkExpressionWithContextualType(arg, paramType, mapper); } @@ -15373,7 +15396,7 @@ var ts; } } if (excludeArgument) { - for (var i = 0; i < args.length; i++) { + for (var i = 0; i < argCount; i++) { if (excludeArgument[i] === false) { var arg = args[i]; var paramType = getTypeAtPosition(signature, i); @@ -15383,7 +15406,7 @@ var ts; } getInferredTypes(context); } - function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors) { + function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors, headMessage) { var typeParameters = signature.typeParameters; var typeArgumentsAreAssignable = true; for (var i = 0; i < typeParameters.length; i++) { @@ -15393,23 +15416,33 @@ var ts; if (typeArgumentsAreAssignable) { var constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { - typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + var errorInfo = void 0; + var typeArgumentHeadMessage = ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (reportErrors && headMessage) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); + typeArgumentHeadMessage = headMessage; + } + typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, typeArgumentHeadMessage, errorInfo); } } } return typeArgumentsAreAssignable; } function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { - for (var i = 0; i < args.length; i++) { - var arg = args[i]; - if (arg.kind !== 178) { + var argCount = getEffectiveArgumentCount(node, args, signature); + for (var i = 0; i < argCount; i++) { + var arg = getEffectiveArgument(node, args, i); + if (arg === undefined || arg.kind !== 178) { var paramType = getTypeAtPosition(signature, i); - var argType = i === 0 && node.kind === 162 - ? globalTemplateStringsArrayType - : arg.kind === 8 && !reportErrors + var argType = getEffectiveArgumentType(node, i, arg); + if (argType === undefined) { + argType = arg.kind === 8 && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); - if (!checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1)) { + } + var errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; + var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; + if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) { return false; } } @@ -15420,22 +15453,165 @@ var ts; var args; if (node.kind === 162) { var template = node.template; - args = [template]; + args = [undefined]; if (template.kind === 174) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); } } + else if (node.kind === 132) { + return undefined; + } else { args = node.arguments || emptyArray; } return args; } - function resolveCall(node, signatures, candidatesOutArray) { + function getEffectiveArgumentCount(node, args, signature) { + if (node.kind === 132) { + switch (node.parent.kind) { + case 204: + case 177: + return 1; + case 134: + return 2; + case 136: + case 138: + case 139: + return signature.parameters.length >= 3 ? 3 : 2; + case 131: + return 3; + } + } + else { + return args.length; + } + } + function getEffectiveDecoratorFirstArgumentType(node) { + switch (node.kind) { + case 204: + case 177: + var classSymbol = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol); + case 131: + node = node.parent; + if (node.kind === 137) { + var classSymbol_1 = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol_1); + } + case 134: + case 136: + case 138: + case 139: + return getParentTypeOfClassElement(node); + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + function getEffectiveDecoratorSecondArgumentType(node) { + switch (node.kind) { + case 204: + ts.Debug.fail("Class decorators should not have a second synthetic argument."); + return unknownType; + case 131: + node = node.parent; + if (node.kind === 137) { + return anyType; + } + case 134: + case 136: + case 138: + case 139: + var element = node; + switch (element.name.kind) { + case 65: + case 7: + case 8: + return getStringLiteralType(element.name); + case 129: + var nameType = checkComputedPropertyName(element.name); + if (allConstituentTypesHaveKind(nameType, 2097152)) { + return nameType; + } + else { + return stringType; + } + default: + ts.Debug.fail("Unsupported property name."); + return unknownType; + } + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + function getEffectiveDecoratorThirdArgumentType(node) { + switch (node.kind) { + case 204: + ts.Debug.fail("Class decorators should not have a third synthetic argument."); + return unknownType; + case 131: + return numberType; + case 134: + ts.Debug.fail("Property decorators should not have a third synthetic argument."); + return unknownType; + case 136: + case 138: + case 139: + var propertyType = getTypeOfNode(node); + return createTypedPropertyDescriptorType(propertyType); + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + function getEffectiveDecoratorArgumentType(node, argIndex) { + if (argIndex === 0) { + return getEffectiveDecoratorFirstArgumentType(node.parent); + } + else if (argIndex === 1) { + return getEffectiveDecoratorSecondArgumentType(node.parent); + } + else if (argIndex === 2) { + return getEffectiveDecoratorThirdArgumentType(node.parent); + } + ts.Debug.fail("Decorators should not have a fourth synthetic argument."); + return unknownType; + } + function getEffectiveArgumentType(node, argIndex, arg) { + if (node.kind === 132) { + return getEffectiveDecoratorArgumentType(node, argIndex); + } + else if (argIndex === 0 && node.kind === 162) { + return globalTemplateStringsArrayType; + } + return undefined; + } + function getEffectiveArgument(node, args, argIndex) { + if (node.kind === 132 || + (argIndex === 0 && node.kind === 162)) { + return undefined; + } + return args[argIndex]; + } + function getEffectiveArgumentErrorNode(node, argIndex, arg) { + if (node.kind === 132) { + return node.expression; + } + else if (argIndex === 0 && node.kind === 162) { + return node.template; + } + else { + return arg; + } + } + function resolveCall(node, signatures, candidatesOutArray, headMessage) { var isTaggedTemplate = node.kind === 162; + var isDecorator = node.kind === 132; var typeArguments; - if (!isTaggedTemplate) { + if (!isTaggedTemplate && !isDecorator) { typeArguments = node.typeArguments; if (node.expression.kind !== 91) { ts.forEach(typeArguments, checkSourceElement); @@ -15444,17 +15620,19 @@ var ts; var candidates = candidatesOutArray || []; reorderCandidates(signatures, candidates); if (!candidates.length) { - error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); return resolveErrorCall(node); } var args = getEffectiveCallArguments(node); var excludeArgument; - for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { - if (isContextSensitive(args[i])) { - if (!excludeArgument) { - excludeArgument = new Array(args.length); + if (!isDecorator) { + for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { + if (isContextSensitive(args[i])) { + if (!excludeArgument) { + excludeArgument = new Array(args.length); + } + excludeArgument[i] = true; } - excludeArgument[i] = true; } } var candidateForArgumentError; @@ -15477,19 +15655,22 @@ var ts; checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], true); + if (!isTaggedTemplate && !isDecorator && typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true, headMessage); } else { ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); var failedTypeParameter = candidateForTypeArgumentError.typeParameters[resultOfFailedInference.failedTypeParameterIndex]; var inferenceCandidates = getInferenceCandidates(resultOfFailedInference, resultOfFailedInference.failedTypeParameterIndex); var diagnosticChainHead = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, typeToString(failedTypeParameter)); + if (headMessage) { + diagnosticChainHead = ts.chainDiagnosticMessages(diagnosticChainHead, headMessage); + } reportNoCommonSupertypeError(inferenceCandidates, node.expression || node.tag, diagnosticChainHead); } } else { - error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); } if (!produceDiagnostics) { for (var _i = 0; _i < candidates.length; _i++) { @@ -15500,6 +15681,14 @@ var ts; } } return resolveErrorCall(node); + function reportError(message, arg0, arg1, arg2) { + var errorInfo; + errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2); + if (headMessage) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage); + } + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo)); + } function chooseOverload(candidates, relation) { for (var _i = 0; _i < candidates.length; _i++) { var originalCandidate = candidates[_i]; @@ -15520,7 +15709,7 @@ var ts; typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, false); } else { - inferTypeArguments(candidate, args, excludeArgument, inferenceContext); + inferTypeArguments(node, candidate, args, excludeArgument, inferenceContext); typeArgumentsAreValid = inferenceContext.failedTypeParameterIndex === undefined; typeArgumentTypes = inferenceContext.inferredTypes; } @@ -15562,7 +15751,7 @@ var ts; if (node.expression.kind === 91) { var superType = checkSuperExpression(node.expression); if (superType !== unknownType) { - var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getAncestor(node, 204)); + var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getContainingClass(node)); var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); return resolveCall(node, baseConstructors, candidatesOutArray); } @@ -15641,6 +15830,41 @@ var ts; } return resolveCall(node, callSignatures, candidatesOutArray); } + function getDiagnosticHeadMessageForDecoratorResolution(node) { + switch (node.parent.kind) { + case 204: + case 177: + return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; + case 131: + return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; + case 134: + return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; + case 136: + case 138: + case 139: + return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression; + } + } + function resolveDecorator(node, candidatesOutArray) { + var funcType = checkExpression(node.expression); + var apparentType = getApparentType(funcType); + if (apparentType === unknownType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0); + if (funcType === anyType || (!callSignatures.length && !(funcType.flags & 16384) && isTypeAssignableTo(funcType, globalFunctionType))) { + return resolveUntypedCall(node); + } + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + if (!callSignatures.length) { + var errorInfo; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); + errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo)); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, headMessage); + } function getResolvedSignature(node, candidatesOutArray) { var links = getNodeLinks(node); if (!links.resolvedSignature || candidatesOutArray) { @@ -15654,6 +15878,9 @@ var ts; else if (node.kind === 162) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } + else if (node.kind === 132) { + links.resolvedSignature = resolveDecorator(node, candidatesOutArray); + } else { ts.Debug.fail("Branch in 'getResolvedSignature' should be unreachable."); } @@ -15869,7 +16096,7 @@ var ts; if (node.type) { checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, undefined); } - checkFunctionExpressionBodies(node.body); + checkFunctionAndClassExpressionBodies(node.body); } } } @@ -16269,7 +16496,7 @@ var ts; if (ts.isFunctionLike(parent) && current === parent.body) { return false; } - else if (current.kind === 204 || current.kind === 177) { + else if (ts.isClassLike(current)) { return true; } current = parent; @@ -17045,29 +17272,37 @@ var ts; } } function checkDecorator(node) { - var expression = node.expression; - var exprType = checkExpression(expression); + var signature = getResolvedSignature(node); + var returnType = getReturnTypeOfSignature(signature); + if (returnType.flags & 1) { + return; + } + var expectedReturnType; + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + var errorInfo; switch (node.parent.kind) { case 204: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); - var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); - checkTypeAssignableTo(exprType, classDecoratorType, node); + expectedReturnType = getUnionType([classConstructorType, voidType]); + break; + case 131: + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any); break; case 134: - checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any); break; case 136: case 138: case 139: var methodType = getTypeOfNode(node.parent); - var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); - checkTypeAssignableTo(exprType, methodDecoratorType, node); - break; - case 131: - checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); + var descriptorType = createTypedPropertyDescriptorType(methodType); + expectedReturnType = getUnionType([descriptorType, voidType]); break; } + checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, errorInfo); } function checkTypeNodeAsExpression(node) { if (node && node.kind === 144) { @@ -17186,7 +17421,7 @@ var ts; } ts.forEach(node.statements, checkSourceElement); if (ts.isFunctionBlock(node) || node.kind === 209) { - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); } } function checkCollisionWithArgumentsInGeneratedCode(node) { @@ -17245,7 +17480,7 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; } - var enclosingClass = ts.getAncestor(node, 204); + var enclosingClass = ts.getContainingClass(node); if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; } @@ -17779,7 +18014,7 @@ var ts; checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0); checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1); }); - if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 204) { + if (type.flags & 1024 && ts.isClassLike(type.symbol.valueDeclaration)) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; @@ -17855,14 +18090,17 @@ var ts; } } function checkClassExpression(node) { - grammarErrorOnNode(node, ts.Diagnostics.class_expressions_are_not_currently_supported); - ts.forEach(node.members, checkSourceElement); - return unknownType; + checkClassLikeDeclaration(node); + return getTypeOfSymbol(getSymbolOfNode(node)); } function checkClassDeclaration(node) { if (!node.name && !(node.flags & 256)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } + checkClassLikeDeclaration(node); + ts.forEach(node.members, checkSourceElement); + } + function checkClassLikeDeclaration(node) { checkGrammarClassDeclarationHeritageClauses(node); checkDecorators(node); if (node.name) { @@ -17923,7 +18161,6 @@ var ts; } }); } - ts.forEach(node.members, checkSourceElement); if (produceDiagnostics) { checkIndexConstraints(type); checkTypeForDuplicateIndexSignatures(node); @@ -18665,17 +18902,20 @@ var ts; return checkMissingDeclaration(node); } } - function checkFunctionExpressionBodies(node) { + function checkFunctionAndClassExpressionBodies(node) { switch (node.kind) { case 165: case 166: - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; + case 177: + ts.forEach(node.members, checkSourceElement); + break; case 136: case 135: - ts.forEach(node.decorators, checkFunctionExpressionBodies); - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.decorators, checkFunctionAndClassExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } @@ -18684,10 +18924,10 @@ var ts; case 138: case 139: case 203: - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); break; case 195: - checkFunctionExpressionBodies(node.expression); + checkFunctionAndClassExpressionBodies(node.expression); break; case 132: case 131: @@ -18744,7 +18984,7 @@ var ts; case 229: case 217: case 230: - ts.forEachChild(node, checkFunctionExpressionBodies); + ts.forEachChild(node, checkFunctionAndClassExpressionBodies); break; } } @@ -18765,7 +19005,7 @@ var ts; emitParam = false; potentialThisCollisions.length = 0; ts.forEach(node.statements, checkSourceElement); - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); if (ts.isExternalModule(node)) { checkExternalModuleExports(node); } @@ -18838,6 +19078,10 @@ var ts; case 207: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; + case 177: + if (location.name) { + copySymbol(location.symbol, meaning); + } case 204: case 205: if (!(memberFlags & 128)) { @@ -18872,40 +19116,6 @@ var ts; } } } - if (isInsideWithStatementBody(location)) { - return []; - } - while (location) { - if (location.locals && !isGlobalSourceFile(location)) { - copySymbols(location.locals, meaning); - } - switch (location.kind) { - case 230: - if (!ts.isExternalModule(location)) - break; - case 208: - copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); - break; - case 207: - copySymbols(getSymbolOfNode(location).exports, meaning & 8); - break; - case 204: - case 205: - if (!(memberFlags & 128)) { - copySymbols(getSymbolOfNode(location).members, meaning & 793056); - } - break; - case 165: - if (location.name) { - copySymbol(location.symbol, meaning); - } - break; - } - memberFlags = location.flags; - location = location.parent; - } - copySymbols(globals, meaning); - return symbolsToArray(symbols); } function isTypeDeclarationName(name) { return name.kind === 65 && @@ -18999,6 +19209,9 @@ var ts; meaning |= 8388608; return resolveEntityName(entityName, meaning); } + if (entityName.parent.kind === 143) { + return resolveEntityName(entityName, 1); + } return undefined; } function getSymbolInfo(node) { @@ -19098,6 +19311,12 @@ var ts; } return checkExpression(expr); } + function getParentTypeOfClassElement(node) { + var classSymbol = getSymbolOfNode(node.parent); + return node.flags & 128 + ? getTypeOfSymbol(classSymbol) + : getDeclaredTypeOfSymbol(classSymbol); + } function getAugmentedPropertiesOfType(type) { type = getApparentType(type); var propsByName = createSymbolTable(getPropertiesOfType(type)); @@ -19500,10 +19719,7 @@ var ts; globalNumberType = getGlobalType("Number"); globalBooleanType = getGlobalType("Boolean"); globalRegExpType = getGlobalType("RegExp"); - getGlobalClassDecoratorType = ts.memoize(function () { return getGlobalType("ClassDecorator"); }); - getGlobalPropertyDecoratorType = ts.memoize(function () { return getGlobalType("PropertyDecorator"); }); - getGlobalMethodDecoratorType = ts.memoize(function () { return getGlobalType("MethodDecorator"); }); - getGlobalParameterDecoratorType = ts.memoize(function () { return getGlobalType("ParameterDecorator"); }); + getGlobalTypedPropertyDescriptorType = ts.memoize(function () { return getGlobalType("TypedPropertyDescriptor", 1); }); if (languageVersion >= 2) { globalTemplateStringsArrayType = getGlobalType("TemplateStringsArray"); globalESSymbolType = getGlobalType("Symbol"); @@ -20045,7 +20261,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 204) { + if (ts.isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -20276,7 +20492,7 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 204) { + if (ts.isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; @@ -21826,6 +22042,9 @@ var ts; function generateNameForExportDefault() { return makeUniqueName("default"); } + function generateNameForClassExpression() { + return makeUniqueName("class"); + } function generateNameForNode(node) { switch (node.kind) { case 65: @@ -21838,9 +22057,10 @@ var ts; return generateNameForImportOrExportDeclaration(node); case 203: case 204: - case 177: case 217: return generateNameForExportDefault(); + case 177: + return generateNameForClassExpression(); } } function getGeneratedNameForNode(node) { diff --git a/bin/tsserver.js b/bin/tsserver.js index 2d937e57fad..b9b8ecc2ad1 100644 --- a/bin/tsserver.js +++ b/bin/tsserver.js @@ -1166,6 +1166,12 @@ var ts; An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, + The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: { code: 1236, category: ts.DiagnosticCategory.Error, key: "The return type of a property decorator function must be either 'void' or 'any'." }, + The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: { code: 1237, category: ts.DiagnosticCategory.Error, key: "The return type of a parameter decorator function must be either 'void' or 'any'." }, + Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: { code: 1238, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of class decorator when called as an expression." }, + Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: { code: 1239, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of parameter decorator when called as an expression." }, + Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: { code: 1240, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of property decorator when called as an expression." }, + Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: { code: 1241, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of method decorator when called as an expression." }, Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.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: ts.DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -1541,9 +1547,7 @@ var ts; property_declarations_can_only_be_used_in_a_ts_file: { code: 8014, category: ts.DiagnosticCategory.Error, key: "'property declarations' can only be used in a .ts file." }, enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: ts.DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." }, type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: ts.DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." }, - decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: ts.DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, - Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: ts.DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, - class_expressions_are_not_currently_supported: { code: 9003, category: ts.DiagnosticCategory.Error, key: "'class' expressions are not currently supported." } + decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: ts.DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." } }; })(ts || (ts = {})); /// @@ -3620,6 +3624,7 @@ var ts; case 208: case 206: case 204: + case 177: return; default: if (isFunctionLike(node)) { @@ -3654,20 +3659,11 @@ var ts; } ts.isVariableLike = isVariableLike; function isAccessor(node) { - if (node) { - switch (node.kind) { - case 138: - case 139: - return true; - } - } - return false; + return node && (node.kind === 138 || node.kind === 139); } ts.isAccessor = isAccessor; function isClassLike(node) { - if (node) { - return node.kind === 204 || node.kind === 177; - } + return node && (node.kind === 204 || node.kind === 177); } ts.isClassLike = isClassLike; function isFunctionLike(node) { @@ -3709,6 +3705,15 @@ var ts; } } ts.getContainingFunction = getContainingFunction; + function getContainingClass(node) { + while (true) { + node = node.parent; + if (!node || isClassLike(node)) { + return node; + } + } + } + ts.getContainingClass = getContainingClass; function getThisContainer(node, includeArrowFunctions) { while (true) { node = node.parent; @@ -3717,7 +3722,7 @@ var ts; } switch (node.kind) { case 129: - if (node.parent.parent.kind === 204) { + if (isClassLike(node.parent.parent)) { return node; } node = node.parent; @@ -3758,7 +3763,7 @@ var ts; return node; switch (node.kind) { case 129: - if (node.parent.parent.kind === 204) { + if (isClassLike(node.parent.parent)) { return node; } node = node.parent; @@ -4098,6 +4103,7 @@ var ts; case 166: case 155: case 204: + case 177: case 137: case 207: case 229: @@ -4799,7 +4805,7 @@ var ts; function isExpressionWithTypeArgumentsInClassExtendsClause(node) { return node.kind === 179 && node.parent.token === 79 && - node.parent.parent.kind === 204; + isClassLike(node.parent.parent); } ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; function isSupportedExpressionWithTypeArguments(node) { @@ -9701,7 +9707,7 @@ var ts; } } function getStrictModeIdentifierMessage(node) { - if (ts.getAncestor(node, 204) || ts.getAncestor(node, 177)) { + if (ts.getContainingClass(node)) { return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; } if (file.externalModuleIndicator) { @@ -9739,7 +9745,7 @@ var ts; } } function getStrictModeEvalOrArgumentsMessage(node) { - if (ts.getAncestor(node, 204) || ts.getAncestor(node, 177)) { + if (ts.getContainingClass(node)) { return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; } if (file.externalModuleIndicator) { @@ -9991,7 +9997,7 @@ var ts; } if (node.flags & 112 && node.parent.kind === 137 && - (node.parent.parent.kind === 204 || node.parent.parent.kind === 177)) { + ts.isClassLike(node.parent.parent)) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); } @@ -10105,10 +10111,7 @@ var ts; var globalIteratorType; var globalIterableIteratorType; var anyArrayType; - var getGlobalClassDecoratorType; - var getGlobalParameterDecoratorType; - var getGlobalPropertyDecoratorType; - var getGlobalMethodDecoratorType; + var getGlobalTypedPropertyDescriptorType; var tupleTypes = {}; var unionTypes = {}; var stringLiteralTypes = {}; @@ -10365,7 +10368,7 @@ var ts; break; case 134: case 133: - if (location.parent.kind === 204 && !(location.flags & 128)) { + if (ts.isClassLike(location.parent) && !(location.flags & 128)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455)) { @@ -10375,6 +10378,7 @@ var ts; } break; case 204: + case 177: case 205: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056)) { if (lastLocation && lastLocation.flags & 128) { @@ -10383,10 +10387,17 @@ var ts; } break loop; } + if (location.kind === 177 && meaning & 32) { + var className = location.name; + if (className && name === className.text) { + result = location.symbol; + break loop; + } + } break; case 129: grandparent = location.parent.parent; - if (grandparent.kind === 204 || grandparent.kind === 205) { + if (ts.isClassLike(grandparent) || grandparent.kind === 205) { if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); return undefined; @@ -10418,15 +10429,6 @@ var ts; } } break; - case 177: - if (meaning & 32) { - var className = location.name; - if (className && name === className.text) { - result = location.symbol; - break loop; - } - } - break; case 132: if (location.parent && location.parent.kind === 131) { location = location.parent; @@ -11127,15 +11129,24 @@ var ts; } var _displayBuilder; function getSymbolDisplayBuilder() { - function appendSymbolNameOnly(symbol, writer) { - if (symbol.declarations && symbol.declarations.length > 0) { + function getNameOfSymbol(symbol) { + if (symbol.declarations && symbol.declarations.length) { var declaration = symbol.declarations[0]; if (declaration.name) { - writer.writeSymbol(ts.declarationNameToString(declaration.name), symbol); - return; + return ts.declarationNameToString(declaration.name); + } + switch (declaration.kind) { + case 177: + return "(Anonymous class)"; + case 165: + case 166: + return "(Anonymous function)"; } } - writer.writeSymbol(symbol.name, symbol); + return symbol.name; + } + function appendSymbolNameOnly(symbol, writer) { + writer.writeSymbol(getNameOfSymbol(symbol), symbol); } function buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags, typeFlags) { var parentSymbol; @@ -12051,9 +12062,9 @@ var ts; if (!node) { return typeParameters; } - if (node.kind === 204 || node.kind === 203 || - node.kind === 165 || node.kind === 136 || - node.kind === 166) { + if (node.kind === 204 || node.kind === 177 || + node.kind === 203 || node.kind === 165 || + node.kind === 136 || node.kind === 166) { var declarations = node.typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); @@ -12062,14 +12073,15 @@ var ts; } } function getOuterTypeParametersOfClassOrInterface(symbol) { - var kind = symbol.flags & 32 ? 204 : 205; - return appendOuterTypeParameters(undefined, ts.getDeclarationOfKind(symbol, kind)); + var declaration = symbol.flags & 32 ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 205); + return appendOuterTypeParameters(undefined, declaration); } function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) { var result; for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { var node = _a[_i]; - if (node.kind === 205 || node.kind === 204 || node.kind === 206) { + if (node.kind === 205 || node.kind === 204 || + node.kind === 177 || node.kind === 206) { var declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -13082,6 +13094,12 @@ var ts; function getGlobalESSymbolConstructorSymbol() { return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); } + function createTypedPropertyDescriptorType(propertyType) { + var globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); + return globalTypedPropertyDescriptorType !== emptyObjectType + ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) + : emptyObjectType; + } function createTypeFromGenericGlobalType(genericGlobalType, elementType) { return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, [elementType]) : emptyObjectType; } @@ -13497,8 +13515,8 @@ var ts; function checkTypeSubtypeOf(source, target, errorNode, headMessage, containingMessageChain) { return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source, target, errorNode, headMessage) { - return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage); + function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain) { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source, target) { var sourceType = getOrCreateTypeFromSignature(source); @@ -14883,9 +14901,9 @@ var ts; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 204 ? container.parent : undefined; getNodeLinks(node).flags |= 2; if (container.kind === 134 || container.kind === 137) { + var classNode = container.parent; getNodeLinks(classNode).flags |= 4; } else { @@ -14924,9 +14942,8 @@ var ts; if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 204 ? container.parent : undefined; - if (classNode) { - var symbol = getSymbolOfNode(classNode); + if (ts.isClassLike(container.parent)) { + var symbol = getSymbolOfNode(container.parent); return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); } return anyType; @@ -14941,7 +14958,7 @@ var ts; } function checkSuperExpression(node) { var isCallExpression = node.parent.kind === 160 && node.parent.expression === node; - var classDeclaration = ts.getAncestor(node, 204); + var classDeclaration = ts.getContainingClass(node); var classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); var baseClassType = classType && getBaseTypes(classType)[0]; if (!baseClassType) { @@ -14963,7 +14980,7 @@ var ts; container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = languageVersion < 2; } - if (container && container.parent && container.parent.kind === 204) { + if (container && ts.isClassLike(container.parent)) { if (container.flags & 128) { canUseSuperExpression = container.kind === 136 || @@ -15446,7 +15463,7 @@ var ts; if (!(flags & (32 | 64))) { return; } - var enclosingClassDeclaration = ts.getAncestor(node, 204); + var enclosingClassDeclaration = ts.getContainingClass(node); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); if (flags & 32) { @@ -15624,7 +15641,7 @@ var ts; if (node.kind === 162) { checkExpression(node.template); } - else { + else if (node.kind !== 132) { ts.forEach(node.arguments, function (argument) { checkExpression(argument); }); @@ -15674,7 +15691,8 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 176) { + var arg = args[i]; + if (arg && arg.kind === 176) { return i; } } @@ -15684,6 +15702,8 @@ var ts; var adjustedArgCount; var typeArguments; var callIsIncomplete; + var isDecorator; + var spreadArgIndex = -1; if (node.kind === 162) { var tagExpression = node; adjustedArgCount = args.length; @@ -15700,6 +15720,11 @@ var ts; callIsIncomplete = !!templateLiteral.isUnterminated; } } + else if (node.kind === 132) { + isDecorator = true; + typeArguments = undefined; + adjustedArgCount = getEffectiveArgumentCount(node, undefined, signature); + } else { var callExpression = node; if (!callExpression.arguments) { @@ -15709,13 +15734,13 @@ var ts; adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; callIsIncomplete = callExpression.arguments.end === callExpression.end; typeArguments = callExpression.typeArguments; + spreadArgIndex = getSpreadArgumentIndex(args); } var hasRightNumberOfTypeArgs = !typeArguments || (signature.typeParameters && typeArguments.length === signature.typeParameters.length); if (!hasRightNumberOfTypeArgs) { return false; } - var spreadArgIndex = getSpreadArgumentIndex(args); if (spreadArgIndex >= 0) { return signature.hasRestParameter && spreadArgIndex >= signature.parameters.length - 1; } @@ -15742,7 +15767,7 @@ var ts; }); return getSignatureInstantiation(signature, getInferredTypes(context)); } - function inferTypeArguments(signature, args, excludeArgument, context) { + function inferTypeArguments(node, signature, args, excludeArgument, context) { var typeParameters = signature.typeParameters; var inferenceMapper = createInferenceMapper(context); for (var i = 0; i < typeParameters.length; i++) { @@ -15753,15 +15778,13 @@ var ts; if (context.failedTypeParameterIndex !== undefined && !context.inferences[context.failedTypeParameterIndex].isFixed) { context.failedTypeParameterIndex = undefined; } - for (var i = 0; i < args.length; i++) { - var arg = args[i]; - if (arg.kind !== 178) { + var argCount = getEffectiveArgumentCount(node, args, signature); + for (var i = 0; i < argCount; i++) { + var arg = getEffectiveArgument(node, args, i); + if (arg === undefined || arg.kind !== 178) { var paramType = getTypeAtPosition(signature, i); - var argType = void 0; - if (i === 0 && args[i].parent.kind === 162) { - argType = globalTemplateStringsArrayType; - } - else { + var argType = getEffectiveArgumentType(node, i, arg); + if (argType === undefined) { var mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; argType = checkExpressionWithContextualType(arg, paramType, mapper); } @@ -15769,7 +15792,7 @@ var ts; } } if (excludeArgument) { - for (var i = 0; i < args.length; i++) { + for (var i = 0; i < argCount; i++) { if (excludeArgument[i] === false) { var arg = args[i]; var paramType = getTypeAtPosition(signature, i); @@ -15779,7 +15802,7 @@ var ts; } getInferredTypes(context); } - function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors) { + function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors, headMessage) { var typeParameters = signature.typeParameters; var typeArgumentsAreAssignable = true; for (var i = 0; i < typeParameters.length; i++) { @@ -15789,23 +15812,33 @@ var ts; if (typeArgumentsAreAssignable) { var constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { - typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + var errorInfo = void 0; + var typeArgumentHeadMessage = ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (reportErrors && headMessage) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); + typeArgumentHeadMessage = headMessage; + } + typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, typeArgumentHeadMessage, errorInfo); } } } return typeArgumentsAreAssignable; } function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { - for (var i = 0; i < args.length; i++) { - var arg = args[i]; - if (arg.kind !== 178) { + var argCount = getEffectiveArgumentCount(node, args, signature); + for (var i = 0; i < argCount; i++) { + var arg = getEffectiveArgument(node, args, i); + if (arg === undefined || arg.kind !== 178) { var paramType = getTypeAtPosition(signature, i); - var argType = i === 0 && node.kind === 162 - ? globalTemplateStringsArrayType - : arg.kind === 8 && !reportErrors + var argType = getEffectiveArgumentType(node, i, arg); + if (argType === undefined) { + argType = arg.kind === 8 && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); - if (!checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1)) { + } + var errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; + var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; + if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) { return false; } } @@ -15816,22 +15849,165 @@ var ts; var args; if (node.kind === 162) { var template = node.template; - args = [template]; + args = [undefined]; if (template.kind === 174) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); } } + else if (node.kind === 132) { + return undefined; + } else { args = node.arguments || emptyArray; } return args; } - function resolveCall(node, signatures, candidatesOutArray) { + function getEffectiveArgumentCount(node, args, signature) { + if (node.kind === 132) { + switch (node.parent.kind) { + case 204: + case 177: + return 1; + case 134: + return 2; + case 136: + case 138: + case 139: + return signature.parameters.length >= 3 ? 3 : 2; + case 131: + return 3; + } + } + else { + return args.length; + } + } + function getEffectiveDecoratorFirstArgumentType(node) { + switch (node.kind) { + case 204: + case 177: + var classSymbol = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol); + case 131: + node = node.parent; + if (node.kind === 137) { + var classSymbol_1 = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol_1); + } + case 134: + case 136: + case 138: + case 139: + return getParentTypeOfClassElement(node); + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + function getEffectiveDecoratorSecondArgumentType(node) { + switch (node.kind) { + case 204: + ts.Debug.fail("Class decorators should not have a second synthetic argument."); + return unknownType; + case 131: + node = node.parent; + if (node.kind === 137) { + return anyType; + } + case 134: + case 136: + case 138: + case 139: + var element = node; + switch (element.name.kind) { + case 65: + case 7: + case 8: + return getStringLiteralType(element.name); + case 129: + var nameType = checkComputedPropertyName(element.name); + if (allConstituentTypesHaveKind(nameType, 2097152)) { + return nameType; + } + else { + return stringType; + } + default: + ts.Debug.fail("Unsupported property name."); + return unknownType; + } + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + function getEffectiveDecoratorThirdArgumentType(node) { + switch (node.kind) { + case 204: + ts.Debug.fail("Class decorators should not have a third synthetic argument."); + return unknownType; + case 131: + return numberType; + case 134: + ts.Debug.fail("Property decorators should not have a third synthetic argument."); + return unknownType; + case 136: + case 138: + case 139: + var propertyType = getTypeOfNode(node); + return createTypedPropertyDescriptorType(propertyType); + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + function getEffectiveDecoratorArgumentType(node, argIndex) { + if (argIndex === 0) { + return getEffectiveDecoratorFirstArgumentType(node.parent); + } + else if (argIndex === 1) { + return getEffectiveDecoratorSecondArgumentType(node.parent); + } + else if (argIndex === 2) { + return getEffectiveDecoratorThirdArgumentType(node.parent); + } + ts.Debug.fail("Decorators should not have a fourth synthetic argument."); + return unknownType; + } + function getEffectiveArgumentType(node, argIndex, arg) { + if (node.kind === 132) { + return getEffectiveDecoratorArgumentType(node, argIndex); + } + else if (argIndex === 0 && node.kind === 162) { + return globalTemplateStringsArrayType; + } + return undefined; + } + function getEffectiveArgument(node, args, argIndex) { + if (node.kind === 132 || + (argIndex === 0 && node.kind === 162)) { + return undefined; + } + return args[argIndex]; + } + function getEffectiveArgumentErrorNode(node, argIndex, arg) { + if (node.kind === 132) { + return node.expression; + } + else if (argIndex === 0 && node.kind === 162) { + return node.template; + } + else { + return arg; + } + } + function resolveCall(node, signatures, candidatesOutArray, headMessage) { var isTaggedTemplate = node.kind === 162; + var isDecorator = node.kind === 132; var typeArguments; - if (!isTaggedTemplate) { + if (!isTaggedTemplate && !isDecorator) { typeArguments = node.typeArguments; if (node.expression.kind !== 91) { ts.forEach(typeArguments, checkSourceElement); @@ -15840,17 +16016,19 @@ var ts; var candidates = candidatesOutArray || []; reorderCandidates(signatures, candidates); if (!candidates.length) { - error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); return resolveErrorCall(node); } var args = getEffectiveCallArguments(node); var excludeArgument; - for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { - if (isContextSensitive(args[i])) { - if (!excludeArgument) { - excludeArgument = new Array(args.length); + if (!isDecorator) { + for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { + if (isContextSensitive(args[i])) { + if (!excludeArgument) { + excludeArgument = new Array(args.length); + } + excludeArgument[i] = true; } - excludeArgument[i] = true; } } var candidateForArgumentError; @@ -15873,19 +16051,22 @@ var ts; checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], true); + if (!isTaggedTemplate && !isDecorator && typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true, headMessage); } else { ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); var failedTypeParameter = candidateForTypeArgumentError.typeParameters[resultOfFailedInference.failedTypeParameterIndex]; var inferenceCandidates = getInferenceCandidates(resultOfFailedInference, resultOfFailedInference.failedTypeParameterIndex); var diagnosticChainHead = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, typeToString(failedTypeParameter)); + if (headMessage) { + diagnosticChainHead = ts.chainDiagnosticMessages(diagnosticChainHead, headMessage); + } reportNoCommonSupertypeError(inferenceCandidates, node.expression || node.tag, diagnosticChainHead); } } else { - error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); } if (!produceDiagnostics) { for (var _i = 0; _i < candidates.length; _i++) { @@ -15896,6 +16077,14 @@ var ts; } } return resolveErrorCall(node); + function reportError(message, arg0, arg1, arg2) { + var errorInfo; + errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2); + if (headMessage) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage); + } + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo)); + } function chooseOverload(candidates, relation) { for (var _i = 0; _i < candidates.length; _i++) { var originalCandidate = candidates[_i]; @@ -15916,7 +16105,7 @@ var ts; typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, false); } else { - inferTypeArguments(candidate, args, excludeArgument, inferenceContext); + inferTypeArguments(node, candidate, args, excludeArgument, inferenceContext); typeArgumentsAreValid = inferenceContext.failedTypeParameterIndex === undefined; typeArgumentTypes = inferenceContext.inferredTypes; } @@ -15958,7 +16147,7 @@ var ts; if (node.expression.kind === 91) { var superType = checkSuperExpression(node.expression); if (superType !== unknownType) { - var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getAncestor(node, 204)); + var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getContainingClass(node)); var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); return resolveCall(node, baseConstructors, candidatesOutArray); } @@ -16037,6 +16226,41 @@ var ts; } return resolveCall(node, callSignatures, candidatesOutArray); } + function getDiagnosticHeadMessageForDecoratorResolution(node) { + switch (node.parent.kind) { + case 204: + case 177: + return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; + case 131: + return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; + case 134: + return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; + case 136: + case 138: + case 139: + return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression; + } + } + function resolveDecorator(node, candidatesOutArray) { + var funcType = checkExpression(node.expression); + var apparentType = getApparentType(funcType); + if (apparentType === unknownType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0); + if (funcType === anyType || (!callSignatures.length && !(funcType.flags & 16384) && isTypeAssignableTo(funcType, globalFunctionType))) { + return resolveUntypedCall(node); + } + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + if (!callSignatures.length) { + var errorInfo; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); + errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo)); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, headMessage); + } function getResolvedSignature(node, candidatesOutArray) { var links = getNodeLinks(node); if (!links.resolvedSignature || candidatesOutArray) { @@ -16050,6 +16274,9 @@ var ts; else if (node.kind === 162) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } + else if (node.kind === 132) { + links.resolvedSignature = resolveDecorator(node, candidatesOutArray); + } else { ts.Debug.fail("Branch in 'getResolvedSignature' should be unreachable."); } @@ -16265,7 +16492,7 @@ var ts; if (node.type) { checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, undefined); } - checkFunctionExpressionBodies(node.body); + checkFunctionAndClassExpressionBodies(node.body); } } } @@ -16665,7 +16892,7 @@ var ts; if (ts.isFunctionLike(parent) && current === parent.body) { return false; } - else if (current.kind === 204 || current.kind === 177) { + else if (ts.isClassLike(current)) { return true; } current = parent; @@ -17441,29 +17668,37 @@ var ts; } } function checkDecorator(node) { - var expression = node.expression; - var exprType = checkExpression(expression); + var signature = getResolvedSignature(node); + var returnType = getReturnTypeOfSignature(signature); + if (returnType.flags & 1) { + return; + } + var expectedReturnType; + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + var errorInfo; switch (node.parent.kind) { case 204: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); - var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); - checkTypeAssignableTo(exprType, classDecoratorType, node); + expectedReturnType = getUnionType([classConstructorType, voidType]); + break; + case 131: + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any); break; case 134: - checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any); break; case 136: case 138: case 139: var methodType = getTypeOfNode(node.parent); - var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); - checkTypeAssignableTo(exprType, methodDecoratorType, node); - break; - case 131: - checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); + var descriptorType = createTypedPropertyDescriptorType(methodType); + expectedReturnType = getUnionType([descriptorType, voidType]); break; } + checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, errorInfo); } function checkTypeNodeAsExpression(node) { if (node && node.kind === 144) { @@ -17582,7 +17817,7 @@ var ts; } ts.forEach(node.statements, checkSourceElement); if (ts.isFunctionBlock(node) || node.kind === 209) { - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); } } function checkCollisionWithArgumentsInGeneratedCode(node) { @@ -17641,7 +17876,7 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; } - var enclosingClass = ts.getAncestor(node, 204); + var enclosingClass = ts.getContainingClass(node); if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; } @@ -18175,7 +18410,7 @@ var ts; checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0); checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1); }); - if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 204) { + if (type.flags & 1024 && ts.isClassLike(type.symbol.valueDeclaration)) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; @@ -18251,14 +18486,17 @@ var ts; } } function checkClassExpression(node) { - grammarErrorOnNode(node, ts.Diagnostics.class_expressions_are_not_currently_supported); - ts.forEach(node.members, checkSourceElement); - return unknownType; + checkClassLikeDeclaration(node); + return getTypeOfSymbol(getSymbolOfNode(node)); } function checkClassDeclaration(node) { if (!node.name && !(node.flags & 256)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } + checkClassLikeDeclaration(node); + ts.forEach(node.members, checkSourceElement); + } + function checkClassLikeDeclaration(node) { checkGrammarClassDeclarationHeritageClauses(node); checkDecorators(node); if (node.name) { @@ -18319,7 +18557,6 @@ var ts; } }); } - ts.forEach(node.members, checkSourceElement); if (produceDiagnostics) { checkIndexConstraints(type); checkTypeForDuplicateIndexSignatures(node); @@ -19061,17 +19298,20 @@ var ts; return checkMissingDeclaration(node); } } - function checkFunctionExpressionBodies(node) { + function checkFunctionAndClassExpressionBodies(node) { switch (node.kind) { case 165: case 166: - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; + case 177: + ts.forEach(node.members, checkSourceElement); + break; case 136: case 135: - ts.forEach(node.decorators, checkFunctionExpressionBodies); - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.decorators, checkFunctionAndClassExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } @@ -19080,10 +19320,10 @@ var ts; case 138: case 139: case 203: - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); break; case 195: - checkFunctionExpressionBodies(node.expression); + checkFunctionAndClassExpressionBodies(node.expression); break; case 132: case 131: @@ -19140,7 +19380,7 @@ var ts; case 229: case 217: case 230: - ts.forEachChild(node, checkFunctionExpressionBodies); + ts.forEachChild(node, checkFunctionAndClassExpressionBodies); break; } } @@ -19161,7 +19401,7 @@ var ts; emitParam = false; potentialThisCollisions.length = 0; ts.forEach(node.statements, checkSourceElement); - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); if (ts.isExternalModule(node)) { checkExternalModuleExports(node); } @@ -19234,6 +19474,10 @@ var ts; case 207: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; + case 177: + if (location.name) { + copySymbol(location.symbol, meaning); + } case 204: case 205: if (!(memberFlags & 128)) { @@ -19268,40 +19512,6 @@ var ts; } } } - if (isInsideWithStatementBody(location)) { - return []; - } - while (location) { - if (location.locals && !isGlobalSourceFile(location)) { - copySymbols(location.locals, meaning); - } - switch (location.kind) { - case 230: - if (!ts.isExternalModule(location)) - break; - case 208: - copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); - break; - case 207: - copySymbols(getSymbolOfNode(location).exports, meaning & 8); - break; - case 204: - case 205: - if (!(memberFlags & 128)) { - copySymbols(getSymbolOfNode(location).members, meaning & 793056); - } - break; - case 165: - if (location.name) { - copySymbol(location.symbol, meaning); - } - break; - } - memberFlags = location.flags; - location = location.parent; - } - copySymbols(globals, meaning); - return symbolsToArray(symbols); } function isTypeDeclarationName(name) { return name.kind === 65 && @@ -19395,6 +19605,9 @@ var ts; meaning |= 8388608; return resolveEntityName(entityName, meaning); } + if (entityName.parent.kind === 143) { + return resolveEntityName(entityName, 1); + } return undefined; } function getSymbolInfo(node) { @@ -19494,6 +19707,12 @@ var ts; } return checkExpression(expr); } + function getParentTypeOfClassElement(node) { + var classSymbol = getSymbolOfNode(node.parent); + return node.flags & 128 + ? getTypeOfSymbol(classSymbol) + : getDeclaredTypeOfSymbol(classSymbol); + } function getAugmentedPropertiesOfType(type) { type = getApparentType(type); var propsByName = createSymbolTable(getPropertiesOfType(type)); @@ -19896,10 +20115,7 @@ var ts; globalNumberType = getGlobalType("Number"); globalBooleanType = getGlobalType("Boolean"); globalRegExpType = getGlobalType("RegExp"); - getGlobalClassDecoratorType = ts.memoize(function () { return getGlobalType("ClassDecorator"); }); - getGlobalPropertyDecoratorType = ts.memoize(function () { return getGlobalType("PropertyDecorator"); }); - getGlobalMethodDecoratorType = ts.memoize(function () { return getGlobalType("MethodDecorator"); }); - getGlobalParameterDecoratorType = ts.memoize(function () { return getGlobalType("ParameterDecorator"); }); + getGlobalTypedPropertyDescriptorType = ts.memoize(function () { return getGlobalType("TypedPropertyDescriptor", 1); }); if (languageVersion >= 2) { globalTemplateStringsArrayType = getGlobalType("TemplateStringsArray"); globalESSymbolType = getGlobalType("Symbol"); @@ -20441,7 +20657,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 204) { + if (ts.isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -20672,7 +20888,7 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 204) { + if (ts.isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; @@ -22222,6 +22438,9 @@ var ts; function generateNameForExportDefault() { return makeUniqueName("default"); } + function generateNameForClassExpression() { + return makeUniqueName("class"); + } function generateNameForNode(node) { switch (node.kind) { case 65: @@ -22234,9 +22453,10 @@ var ts; return generateNameForImportOrExportDeclaration(node); case 203: case 204: - case 177: case 217: return generateNameForExportDefault(); + case 177: + return generateNameForClassExpression(); } } function getGeneratedNameForNode(node) { @@ -31651,6 +31871,10 @@ var ts; if (actualIndentation !== -1) { return actualIndentation; } + actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options); + if (actualIndentation !== -1) { + return actualIndentation + options.IndentSize; + } previous = current; current = current.parent; } @@ -31688,6 +31912,10 @@ var ts; if (actualIndentation !== -1) { return actualIndentation + indentationDelta; } + actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options); + if (actualIndentation !== -1) { + return actualIndentation + indentationDelta; + } } if (shouldIndentChildNode(parent.kind, current.kind) && !parentAndChildShareLine) { indentationDelta += options.IndentSize; @@ -31804,6 +32032,42 @@ var ts; return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : -1; } } + function getLineIndentationWhenExpressionIsInMultiLine(node, sourceFile, options) { + if (node.kind === 17) { + return -1; + } + if (node.parent && (node.parent.kind === 160 || + node.parent.kind === 161) && + node.parent.expression !== node) { + var fullCallOrNewExpression = node.parent.expression; + var startingExpression = getStartingExpression(fullCallOrNewExpression); + if (fullCallOrNewExpression === startingExpression) { + return -1; + } + var fullCallOrNewExpressionEnd = sourceFile.getLineAndCharacterOfPosition(fullCallOrNewExpression.end); + var startingExpressionEnd = sourceFile.getLineAndCharacterOfPosition(startingExpression.end); + if (fullCallOrNewExpressionEnd.line === startingExpressionEnd.line) { + return -1; + } + return findColumnForFirstNonWhitespaceCharacterInLine(fullCallOrNewExpressionEnd, sourceFile, options); + } + return -1; + function getStartingExpression(node) { + while (true) { + switch (node.kind) { + case 160: + case 161: + case 158: + case 159: + node = node.expression; + break; + default: + return node; + } + } + return node; + } + } function deriveActualIndentationFromList(list, index, sourceFile, options) { ts.Debug.assert(index >= 0 && index < list.length); var node = list[index]; diff --git a/bin/typescript.d.ts b/bin/typescript.d.ts index 2fd4bb2c2f3..e7637e0bc19 100644 --- a/bin/typescript.d.ts +++ b/bin/typescript.d.ts @@ -600,7 +600,7 @@ declare module "typescript" { tag: LeftHandSideExpression; template: LiteralExpression | TemplateExpression; } - type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression; + type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator; interface TypeAssertion extends UnaryExpression { type: TypeNode; expression: UnaryExpression; diff --git a/bin/typescript.js b/bin/typescript.js index 6989f225452..6373e3f9c58 100644 --- a/bin/typescript.js +++ b/bin/typescript.js @@ -1950,6 +1950,12 @@ var ts; An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, + The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: { code: 1236, category: ts.DiagnosticCategory.Error, key: "The return type of a property decorator function must be either 'void' or 'any'." }, + The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: { code: 1237, category: ts.DiagnosticCategory.Error, key: "The return type of a parameter decorator function must be either 'void' or 'any'." }, + Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: { code: 1238, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of class decorator when called as an expression." }, + Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: { code: 1239, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of parameter decorator when called as an expression." }, + Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: { code: 1240, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of property decorator when called as an expression." }, + Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: { code: 1241, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of method decorator when called as an expression." }, Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.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: ts.DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -2325,9 +2331,7 @@ var ts; property_declarations_can_only_be_used_in_a_ts_file: { code: 8014, category: ts.DiagnosticCategory.Error, key: "'property declarations' can only be used in a .ts file." }, enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: ts.DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." }, type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: ts.DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." }, - decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: ts.DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, - Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: ts.DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, - class_expressions_are_not_currently_supported: { code: 9003, category: ts.DiagnosticCategory.Error, key: "'class' expressions are not currently supported." } + decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: ts.DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." } }; })(ts || (ts = {})); /// @@ -4284,7 +4288,7 @@ var ts; function getStrictModeIdentifierMessage(node) { // Provide specialized messages to help the user understand why we think they're in // strict mode. - if (ts.getAncestor(node, 204 /* ClassDeclaration */) || ts.getAncestor(node, 177 /* ClassExpression */)) { + if (ts.getContainingClass(node)) { return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; } if (file.externalModuleIndicator) { @@ -4333,7 +4337,7 @@ var ts; function getStrictModeEvalOrArgumentsMessage(node) { // Provide specialized messages to help the user understand why we think they're in // strict mode. - if (ts.getAncestor(node, 204 /* ClassDeclaration */) || ts.getAncestor(node, 177 /* ClassExpression */)) { + if (ts.getContainingClass(node)) { return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; } if (file.externalModuleIndicator) { @@ -4641,7 +4645,7 @@ var ts; // containing class. if (node.flags & 112 /* AccessibilityModifier */ && node.parent.kind === 137 /* Constructor */ && - (node.parent.parent.kind === 204 /* ClassDeclaration */ || node.parent.parent.kind === 177 /* ClassExpression */)) { + ts.isClassLike(node.parent.parent)) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* Property */, 107455 /* PropertyExcludes */); } @@ -5136,6 +5140,7 @@ var ts; case 208 /* ModuleDeclaration */: case 206 /* TypeAliasDeclaration */: case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: // These are not allowed inside a generator now, but eventually they may be allowed // as local types. Regardless, any yield statements contained within them should be // skipped in this traversal. @@ -5177,20 +5182,11 @@ var ts; } ts.isVariableLike = isVariableLike; function isAccessor(node) { - if (node) { - switch (node.kind) { - case 138 /* GetAccessor */: - case 139 /* SetAccessor */: - return true; - } - } - return false; + return node && (node.kind === 138 /* GetAccessor */ || node.kind === 139 /* SetAccessor */); } ts.isAccessor = isAccessor; function isClassLike(node) { - if (node) { - return node.kind === 204 /* ClassDeclaration */ || node.kind === 177 /* ClassExpression */; - } + return node && (node.kind === 204 /* ClassDeclaration */ || node.kind === 177 /* ClassExpression */); } ts.isClassLike = isClassLike; function isFunctionLike(node) { @@ -5232,6 +5228,15 @@ var ts; } } ts.getContainingFunction = getContainingFunction; + function getContainingClass(node) { + while (true) { + node = node.parent; + if (!node || isClassLike(node)) { + return node; + } + } + } + ts.getContainingClass = getContainingClass; function getThisContainer(node, includeArrowFunctions) { while (true) { node = node.parent; @@ -5244,7 +5249,7 @@ var ts; // then the computed property is not a 'this' container. // A computed property name in a class needs to be a this container // so that we can error on it. - if (node.parent.parent.kind === 204 /* ClassDeclaration */) { + if (isClassLike(node.parent.parent)) { return node; } // If this is a computed property, then the parent should not @@ -5300,7 +5305,7 @@ var ts; // then the computed property is not a 'super' container. // A computed property name in a class needs to be a super container // so that we can error on it. - if (node.parent.parent.kind === 204 /* ClassDeclaration */) { + if (isClassLike(node.parent.parent)) { return node; } // If this is a computed property, then the parent should not @@ -5345,7 +5350,7 @@ var ts; if (node.kind === 162 /* TaggedTemplateExpression */) { return node.tag; } - // Will either be a CallExpression or NewExpression. + // Will either be a CallExpression, NewExpression, or Decorator. return node.expression; } ts.getInvokedExpression = getInvokedExpression; @@ -5658,6 +5663,7 @@ var ts; case 166 /* ArrowFunction */: case 155 /* BindingElement */: case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: case 137 /* Constructor */: case 207 /* EnumDeclaration */: case 229 /* EnumMember */: @@ -6429,7 +6435,7 @@ var ts; function isExpressionWithTypeArgumentsInClassExtendsClause(node) { return node.kind === 179 /* ExpressionWithTypeArguments */ && node.parent.token === 79 /* ExtendsKeyword */ && - node.parent.parent.kind === 204 /* ClassDeclaration */; + isClassLike(node.parent.parent); } ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; // Returns false if this heritage clause element's expression contains something unsupported @@ -12210,10 +12216,7 @@ var ts; var globalIteratorType; var globalIterableIteratorType; var anyArrayType; - var getGlobalClassDecoratorType; - var getGlobalParameterDecoratorType; - var getGlobalPropertyDecoratorType; - var getGlobalMethodDecoratorType; + var getGlobalTypedPropertyDescriptorType; var tupleTypes = {}; var unionTypes = {}; var stringLiteralTypes = {}; @@ -12499,7 +12502,7 @@ var ts; // local variables of the constructor. This effectively means that entities from outer scopes // by the same name as a constructor parameter or local variable are inaccessible // in initializer expressions for instance member variables. - if (location.parent.kind === 204 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) { + if (ts.isClassLike(location.parent) && !(location.flags & 128 /* Static */)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455 /* Value */)) { @@ -12510,6 +12513,7 @@ var ts; } break; case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: case 205 /* InterfaceDeclaration */: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056 /* Type */)) { if (lastLocation && lastLocation.flags & 128 /* Static */) { @@ -12521,6 +12525,13 @@ var ts; } break loop; } + if (location.kind === 177 /* ClassExpression */ && meaning & 32 /* Class */) { + var className = location.name; + if (className && name === className.text) { + result = location.symbol; + break loop; + } + } break; // It is not legal to reference a class's own type parameters from a computed property name that // belongs to the class. For example: @@ -12532,7 +12543,7 @@ var ts; // case 129 /* ComputedPropertyName */: grandparent = location.parent.parent; - if (grandparent.kind === 204 /* ClassDeclaration */ || grandparent.kind === 205 /* InterfaceDeclaration */) { + if (ts.isClassLike(grandparent) || grandparent.kind === 205 /* InterfaceDeclaration */) { // A reference to this grandparent's type parameters would be an error if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056 /* Type */)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); @@ -12565,15 +12576,6 @@ var ts; } } break; - case 177 /* ClassExpression */: - if (meaning & 32 /* Class */) { - var className = location.name; - if (className && name === className.text) { - result = location.symbol; - break loop; - } - } - break; case 132 /* Decorator */: // Decorators are resolved at the class declaration. Resolving at the parameter // or member would result in looking up locals in the method. @@ -13407,19 +13409,28 @@ var ts; // This is for caching the result of getSymbolDisplayBuilder. Do not access directly. var _displayBuilder; function getSymbolDisplayBuilder() { + function getNameOfSymbol(symbol) { + if (symbol.declarations && symbol.declarations.length) { + var declaration = symbol.declarations[0]; + if (declaration.name) { + return ts.declarationNameToString(declaration.name); + } + switch (declaration.kind) { + case 177 /* ClassExpression */: + return "(Anonymous class)"; + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + return "(Anonymous function)"; + } + } + return symbol.name; + } /** * Writes only the name of the symbol out to the writer. Uses the original source text * for the name of the symbol if it is available to match how the user inputted the name. */ function appendSymbolNameOnly(symbol, writer) { - if (symbol.declarations && symbol.declarations.length > 0) { - var declaration = symbol.declarations[0]; - if (declaration.name) { - writer.writeSymbol(ts.declarationNameToString(declaration.name), symbol); - return; - } - } - writer.writeSymbol(symbol.name, symbol); + writer.writeSymbol(getNameOfSymbol(symbol), symbol); } /** * Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope @@ -14488,9 +14499,9 @@ var ts; if (!node) { return typeParameters; } - if (node.kind === 204 /* ClassDeclaration */ || node.kind === 203 /* FunctionDeclaration */ || - node.kind === 165 /* FunctionExpression */ || node.kind === 136 /* MethodDeclaration */ || - node.kind === 166 /* ArrowFunction */) { + if (node.kind === 204 /* ClassDeclaration */ || node.kind === 177 /* ClassExpression */ || + node.kind === 203 /* FunctionDeclaration */ || node.kind === 165 /* FunctionExpression */ || + node.kind === 136 /* MethodDeclaration */ || node.kind === 166 /* ArrowFunction */) { var declarations = node.typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); @@ -14500,8 +14511,8 @@ var ts; } // The outer type parameters are those defined by enclosing generic classes, methods, or functions. function getOuterTypeParametersOfClassOrInterface(symbol) { - var kind = symbol.flags & 32 /* Class */ ? 204 /* ClassDeclaration */ : 205 /* InterfaceDeclaration */; - return appendOuterTypeParameters(undefined, ts.getDeclarationOfKind(symbol, kind)); + var declaration = symbol.flags & 32 /* Class */ ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 205 /* InterfaceDeclaration */); + return appendOuterTypeParameters(undefined, declaration); } // The local type parameters are the combined set of type parameters from all declarations of the class, // interface, or type alias. @@ -14509,7 +14520,8 @@ var ts; var result; for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { var node = _a[_i]; - if (node.kind === 205 /* InterfaceDeclaration */ || node.kind === 204 /* ClassDeclaration */ || node.kind === 206 /* TypeAliasDeclaration */) { + if (node.kind === 205 /* InterfaceDeclaration */ || node.kind === 204 /* ClassDeclaration */ || + node.kind === 177 /* ClassExpression */ || node.kind === 206 /* TypeAliasDeclaration */) { var declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -15604,6 +15616,15 @@ var ts; function getGlobalESSymbolConstructorSymbol() { return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); } + /** + * Creates a TypeReference for a generic `TypedPropertyDescriptor`. + */ + function createTypedPropertyDescriptorType(propertyType) { + var globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); + return globalTypedPropertyDescriptorType !== emptyObjectType + ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) + : emptyObjectType; + } /** * Instantiates a global type that is generic with some element type, and returns that instantiation. */ @@ -16042,8 +16063,8 @@ var ts; function checkTypeSubtypeOf(source, target, errorNode, headMessage, containingMessageChain) { return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source, target, errorNode, headMessage) { - return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage); + function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain) { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source, target) { var sourceType = getOrCreateTypeFromSignature(source); @@ -17582,9 +17603,9 @@ var ts; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 204 /* ClassDeclaration */ ? container.parent : undefined; getNodeLinks(node).flags |= 2 /* LexicalThis */; if (container.kind === 134 /* PropertyDeclaration */ || container.kind === 137 /* Constructor */) { + var classNode = container.parent; getNodeLinks(classNode).flags |= 4 /* CaptureThis */; } else { @@ -17629,9 +17650,8 @@ var ts; if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 204 /* ClassDeclaration */ ? container.parent : undefined; - if (classNode) { - var symbol = getSymbolOfNode(classNode); + if (ts.isClassLike(container.parent)) { + var symbol = getSymbolOfNode(container.parent); return container.flags & 128 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); } return anyType; @@ -17646,7 +17666,7 @@ var ts; } function checkSuperExpression(node) { var isCallExpression = node.parent.kind === 160 /* CallExpression */ && node.parent.expression === node; - var classDeclaration = ts.getAncestor(node, 204 /* ClassDeclaration */); + var classDeclaration = ts.getContainingClass(node); var classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); var baseClassType = classType && getBaseTypes(classType)[0]; if (!baseClassType) { @@ -17676,7 +17696,7 @@ var ts; needToCaptureLexicalThis = languageVersion < 2 /* ES6 */; } // topmost container must be something that is directly nested in the class declaration - if (container && container.parent && container.parent.kind === 204 /* ClassDeclaration */) { + if (container && ts.isClassLike(container.parent)) { if (container.flags & 128 /* Static */) { canUseSuperExpression = container.kind === 136 /* MethodDeclaration */ || @@ -18276,7 +18296,7 @@ var ts; } // Property is known to be private or protected at this point // Get the declaring and enclosing class instance types - var enclosingClassDeclaration = ts.getAncestor(node, 204 /* ClassDeclaration */); + var enclosingClassDeclaration = ts.getContainingClass(node); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); // Private property is accessible if declaring and enclosing class are the same @@ -18502,7 +18522,7 @@ var ts; if (node.kind === 162 /* TaggedTemplateExpression */) { checkExpression(node.template); } - else { + else if (node.kind !== 132 /* Decorator */) { ts.forEach(node.arguments, function (argument) { checkExpression(argument); }); @@ -18567,7 +18587,8 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 176 /* SpreadElementExpression */) { + var arg = args[i]; + if (arg && arg.kind === 176 /* SpreadElementExpression */) { return i; } } @@ -18577,6 +18598,8 @@ var ts; var adjustedArgCount; // Apparent number of arguments we will have in this call var typeArguments; // Type arguments (undefined if none) var callIsIncomplete; // In incomplete call we want to be lenient when we have too few arguments + var isDecorator; + var spreadArgIndex = -1; if (node.kind === 162 /* TaggedTemplateExpression */) { var tagExpression = node; // Even if the call is incomplete, we'll have a missing expression as our last argument, @@ -18600,6 +18623,11 @@ var ts; callIsIncomplete = !!templateLiteral.isUnterminated; } } + else if (node.kind === 132 /* Decorator */) { + isDecorator = true; + typeArguments = undefined; + adjustedArgCount = getEffectiveArgumentCount(node, undefined, signature); + } else { var callExpression = node; if (!callExpression.arguments) { @@ -18612,6 +18640,7 @@ var ts; // If we are missing the close paren, the call is incomplete. callIsIncomplete = callExpression.arguments.end === callExpression.end; typeArguments = callExpression.typeArguments; + spreadArgIndex = getSpreadArgumentIndex(args); } // If the user supplied type arguments, but the number of type arguments does not match // the declared number of type parameters, the call has an incorrect arity. @@ -18622,7 +18651,6 @@ var ts; } // If spread arguments are present, check that they correspond to a rest parameter. If so, no // further checking is necessary. - var spreadArgIndex = getSpreadArgumentIndex(args); if (spreadArgIndex >= 0) { return signature.hasRestParameter && spreadArgIndex >= signature.parameters.length - 1; } @@ -18654,7 +18682,7 @@ var ts; }); return getSignatureInstantiation(signature, getInferredTypes(context)); } - function inferTypeArguments(signature, args, excludeArgument, context) { + function inferTypeArguments(node, signature, args, excludeArgument, context) { var typeParameters = signature.typeParameters; var inferenceMapper = createInferenceMapper(context); // Clear out all the inference results from the last time inferTypeArguments was called on this context @@ -18679,15 +18707,16 @@ var ts; } // We perform two passes over the arguments. In the first pass we infer from all arguments, but use // wildcards for all context sensitive function expressions. - for (var i = 0; i < args.length; i++) { - var arg = args[i]; - if (arg.kind !== 178 /* OmittedExpression */) { + var argCount = getEffectiveArgumentCount(node, args, signature); + for (var i = 0; i < argCount; i++) { + var arg = getEffectiveArgument(node, args, i); + // If the effective argument is 'undefined', then it is an argument that is present but is synthetic. + if (arg === undefined || arg.kind !== 178 /* OmittedExpression */) { var paramType = getTypeAtPosition(signature, i); - var argType = void 0; - if (i === 0 && args[i].parent.kind === 162 /* TaggedTemplateExpression */) { - argType = globalTemplateStringsArrayType; - } - else { + var argType = getEffectiveArgumentType(node, i, arg); + // If the effective argument type is 'undefined', there is no synthetic type + // for the argument. In that case, we should check the argument. + if (argType === undefined) { // For context sensitive arguments we pass the identityMapper, which is a signal to treat all // context sensitive function expressions as wildcards var mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; @@ -18699,8 +18728,10 @@ var ts; // In the second pass we visit only context sensitive arguments, and only those that aren't excluded, this // time treating function expressions normally (which may cause previously inferred type arguments to be fixed // as we construct types for contextually typed parameters) + // Decorators will not have `excludeArgument`, as their arguments cannot be contextually typed. + // Tagged template expressions will always have `undefined` for `excludeArgument[0]`. if (excludeArgument) { - for (var i = 0; i < args.length; i++) { + for (var i = 0; i < argCount; i++) { // No need to check for omitted args and template expressions, their exlusion value is always undefined if (excludeArgument[i] === false) { var arg = args[i]; @@ -18711,7 +18742,7 @@ var ts; } getInferredTypes(context); } - function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors) { + function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors, headMessage) { var typeParameters = signature.typeParameters; var typeArgumentsAreAssignable = true; for (var i = 0; i < typeParameters.length; i++) { @@ -18722,27 +18753,38 @@ var ts; if (typeArgumentsAreAssignable /* so far */) { var constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { - typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + var errorInfo = void 0; + var typeArgumentHeadMessage = ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (reportErrors && headMessage) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); + typeArgumentHeadMessage = headMessage; + } + typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, typeArgumentHeadMessage, errorInfo); } } } return typeArgumentsAreAssignable; } function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { - for (var i = 0; i < args.length; i++) { - var arg = args[i]; - if (arg.kind !== 178 /* OmittedExpression */) { + var argCount = getEffectiveArgumentCount(node, args, signature); + for (var i = 0; i < argCount; i++) { + var arg = getEffectiveArgument(node, args, i); + // If the effective argument is 'undefined', then it is an argument that is present but is synthetic. + if (arg === undefined || arg.kind !== 178 /* OmittedExpression */) { // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) var paramType = getTypeAtPosition(signature, i); - // A tagged template expression provides a special first argument, and string literals get string literal types - // unless we're reporting errors - var argType = i === 0 && node.kind === 162 /* TaggedTemplateExpression */ - ? globalTemplateStringsArrayType - : arg.kind === 8 /* StringLiteral */ && !reportErrors + var argType = getEffectiveArgumentType(node, i, arg); + // If the effective argument type is 'undefined', there is no synthetic type + // for the argument. In that case, we should check the argument. + if (argType === undefined) { + argType = arg.kind === 8 /* StringLiteral */ && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + } // Use argument expression as error location when reporting errors - if (!checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1)) { + var errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; + var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; + if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) { return false; } } @@ -18754,28 +18796,276 @@ var ts; * * If 'node' is a CallExpression or a NewExpression, then its argument list is returned. * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution - * expressions, where the first element of the list is the template for error reporting purposes. + * expressions, where the first element of the list is `undefined`. + * If 'node' is a Decorator, the argument list will be `undefined`, and its arguments and types + * will be supplied from calls to `getEffectiveArgumentCount` and `getEffectiveArgumentType`. */ function getEffectiveCallArguments(node) { var args; if (node.kind === 162 /* TaggedTemplateExpression */) { var template = node.template; - args = [template]; + args = [undefined]; if (template.kind === 174 /* TemplateExpression */) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); } } + else if (node.kind === 132 /* Decorator */) { + // For a decorator, we return undefined as we will determine + // the number and types of arguments for a decorator using + // `getEffectiveArgumentCount` and `getEffectiveArgumentType` below. + return undefined; + } else { args = node.arguments || emptyArray; } return args; } - function resolveCall(node, signatures, candidatesOutArray) { + /** + * Returns the effective argument count for a node that works like a function invocation. + * If 'node' is a Decorator, the number of arguments is derived from the decoration + * target and the signature: + * If 'node.target' is a class declaration or class expression, the effective argument + * count is 1. + * If 'node.target' is a parameter declaration, the effective argument count is 3. + * If 'node.target' is a property declaration, the effective argument count is 2. + * If 'node.target' is a method or accessor declaration, the effective argument count + * is 3, although it can be 2 if the signature only accepts two arguments, allowing + * us to match a property decorator. + * Otherwise, the argument count is the length of the 'args' array. + */ + function getEffectiveArgumentCount(node, args, signature) { + if (node.kind === 132 /* Decorator */) { + switch (node.parent.kind) { + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + // A class decorator will have one argument (see `ClassDecorator` in core.d.ts) + return 1; + case 134 /* PropertyDeclaration */: + // A property declaration decorator will have two arguments (see + // `PropertyDecorator` in core.d.ts) + return 2; + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + // A method or accessor declaration decorator will have two or three arguments (see + // `PropertyDecorator` and `MethodDecorator` in core.d.ts) + // If the method decorator signature only accepts a target and a key, we will only + // type check those arguments. + return signature.parameters.length >= 3 ? 3 : 2; + case 131 /* Parameter */: + // A parameter declaration decorator will have three arguments (see + // `ParameterDecorator` in core.d.ts) + return 3; + } + } + else { + return args.length; + } + } + /** + * Returns the effective type of the first argument to a decorator. + * If 'node' is a class declaration or class expression, the effective argument type + * is the type of the static side of the class. + * If 'node' is a parameter declaration, the effective argument type is either the type + * of the static or instance side of the class for the parameter's parent method, + * depending on whether the method is declared static. + * For a constructor, the type is always the type of the static side of the class. + * If 'node' is a property, method, or accessor declaration, the effective argument + * type is the type of the static or instance side of the parent class for class + * element, depending on whether the element is declared static. + */ + function getEffectiveDecoratorFirstArgumentType(node) { + // The first argument to a decorator is its `target`. + switch (node.kind) { + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + // For a class decorator, the `target` is the type of the class (e.g. the + // "static" or "constructor" side of the class) + var classSymbol = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol); + case 131 /* Parameter */: + // For a parameter decorator, the `target` is the parent type of the + // parameter's containing method. + node = node.parent; + if (node.kind === 137 /* Constructor */) { + var classSymbol_1 = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol_1); + } + // fall-through + case 134 /* PropertyDeclaration */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + // For a property or method decorator, the `target` is the + // "static"-side type of the parent of the member if the member is + // declared "static"; otherwise, it is the "instance"-side type of the + // parent of the member. + return getParentTypeOfClassElement(node); + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + /** + * Returns the effective type for the second argument to a decorator. + * If 'node' is a parameter, its effective argument type is one of the following: + * If 'node.parent' is a constructor, the effective argument type is 'any', as we + * will emit `undefined`. + * If 'node.parent' is a member with an identifier, numeric, or string literal name, + * the effective argument type will be a string literal type for the member name. + * If 'node.parent' is a computed property name, the effective argument type will + * either be a symbol type or the string type. + * If 'node' is a member with an identifier, numeric, or string literal name, the + * effective argument type will be a string literal type for the member name. + * If 'node' is a computed property name, the effective argument type will either + * be a symbol type or the string type. + * A class decorator does not have a second argument type. + */ + function getEffectiveDecoratorSecondArgumentType(node) { + // The second argument to a decorator is its `propertyKey` + switch (node.kind) { + case 204 /* ClassDeclaration */: + ts.Debug.fail("Class decorators should not have a second synthetic argument."); + return unknownType; + case 131 /* Parameter */: + node = node.parent; + if (node.kind === 137 /* Constructor */) { + // For a constructor parameter decorator, the `propertyKey` will be `undefined`. + return anyType; + } + // For a non-constructor parameter decorator, the `propertyKey` will be either + // a string or a symbol, based on the name of the parameter's containing method. + // fall-through + case 134 /* PropertyDeclaration */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + // The `propertyKey` for a property or method decorator will be a + // string literal type if the member name is an identifier, number, or string; + // otherwise, if the member name is a computed property name it will + // be either string or symbol. + var element = node; + switch (element.name.kind) { + case 65 /* Identifier */: + case 7 /* NumericLiteral */: + case 8 /* StringLiteral */: + return getStringLiteralType(element.name); + case 129 /* ComputedPropertyName */: + var nameType = checkComputedPropertyName(element.name); + if (allConstituentTypesHaveKind(nameType, 2097152 /* ESSymbol */)) { + return nameType; + } + else { + return stringType; + } + default: + ts.Debug.fail("Unsupported property name."); + return unknownType; + } + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + /** + * Returns the effective argument type for the third argument to a decorator. + * If 'node' is a parameter, the effective argument type is the number type. + * If 'node' is a method or accessor, the effective argument type is a + * `TypedPropertyDescriptor` instantiated with the type of the member. + * Class and property decorators do not have a third effective argument. + */ + function getEffectiveDecoratorThirdArgumentType(node) { + // The third argument to a decorator is either its `descriptor` for a method decorator + // or its `parameterIndex` for a paramter decorator + switch (node.kind) { + case 204 /* ClassDeclaration */: + ts.Debug.fail("Class decorators should not have a third synthetic argument."); + return unknownType; + case 131 /* Parameter */: + // The `parameterIndex` for a parameter decorator is always a number + return numberType; + case 134 /* PropertyDeclaration */: + ts.Debug.fail("Property decorators should not have a third synthetic argument."); + return unknownType; + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor` + // for the type of the member. + var propertyType = getTypeOfNode(node); + return createTypedPropertyDescriptorType(propertyType); + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + /** + * Returns the effective argument type for the provided argument to a decorator. + */ + function getEffectiveDecoratorArgumentType(node, argIndex) { + if (argIndex === 0) { + return getEffectiveDecoratorFirstArgumentType(node.parent); + } + else if (argIndex === 1) { + return getEffectiveDecoratorSecondArgumentType(node.parent); + } + else if (argIndex === 2) { + return getEffectiveDecoratorThirdArgumentType(node.parent); + } + ts.Debug.fail("Decorators should not have a fourth synthetic argument."); + return unknownType; + } + /** + * Gets the effective argument type for an argument in a call expression. + */ + function getEffectiveArgumentType(node, argIndex, arg) { + // Decorators provide special arguments, a tagged template expression provides + // a special first argument, and string literals get string literal types + // unless we're reporting errors + if (node.kind === 132 /* Decorator */) { + return getEffectiveDecoratorArgumentType(node, argIndex); + } + else if (argIndex === 0 && node.kind === 162 /* TaggedTemplateExpression */) { + return globalTemplateStringsArrayType; + } + // This is not a synthetic argument, so we return 'undefined' + // to signal that the caller needs to check the argument. + return undefined; + } + /** + * Gets the effective argument expression for an argument in a call expression. + */ + function getEffectiveArgument(node, args, argIndex) { + // For a decorator or the first argument of a tagged template expression we return undefined. + if (node.kind === 132 /* Decorator */ || + (argIndex === 0 && node.kind === 162 /* TaggedTemplateExpression */)) { + return undefined; + } + return args[argIndex]; + } + /** + * Gets the error node to use when reporting errors for an effective argument. + */ + function getEffectiveArgumentErrorNode(node, argIndex, arg) { + if (node.kind === 132 /* Decorator */) { + // For a decorator, we use the expression of the decorator for error reporting. + return node.expression; + } + else if (argIndex === 0 && node.kind === 162 /* TaggedTemplateExpression */) { + // For a the first argument of a tagged template expression, we use the template of the tag for error reporting. + return node.template; + } + else { + return arg; + } + } + function resolveCall(node, signatures, candidatesOutArray, headMessage) { var isTaggedTemplate = node.kind === 162 /* TaggedTemplateExpression */; + var isDecorator = node.kind === 132 /* Decorator */; var typeArguments; - if (!isTaggedTemplate) { + if (!isTaggedTemplate && !isDecorator) { typeArguments = node.typeArguments; // We already perform checking on the type arguments on the class declaration itself. if (node.expression.kind !== 91 /* SuperKeyword */) { @@ -18786,7 +19076,7 @@ var ts; // reorderCandidates fills up the candidates array directly reorderCandidates(signatures, candidates); if (!candidates.length) { - error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); return resolveErrorCall(node); } var args = getEffectiveCallArguments(node); @@ -18801,13 +19091,20 @@ var ts; // // For a tagged template, then the first argument be 'undefined' if necessary // because it represents a TemplateStringsArray. + // + // For a decorator, no arguments are susceptible to contextual typing due to the fact + // decorators are applied to a declaration by the emitter, and not to an expression. var excludeArgument; - for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { - if (isContextSensitive(args[i])) { - if (!excludeArgument) { - excludeArgument = new Array(args.length); + if (!isDecorator) { + // We do not need to call `getEffectiveArgumentCount` here as it only + // applies when calculating the number of arguments for a decorator. + for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { + if (isContextSensitive(args[i])) { + if (!excludeArgument) { + excludeArgument = new Array(args.length); + } + excludeArgument[i] = true; } - excludeArgument[i] = true; } } // The following variables are captured and modified by calls to chooseOverload. @@ -18871,19 +19168,22 @@ var ts; checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], true); + if (!isTaggedTemplate && !isDecorator && typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true, headMessage); } else { ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); var failedTypeParameter = candidateForTypeArgumentError.typeParameters[resultOfFailedInference.failedTypeParameterIndex]; var inferenceCandidates = getInferenceCandidates(resultOfFailedInference, resultOfFailedInference.failedTypeParameterIndex); var diagnosticChainHead = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, typeToString(failedTypeParameter)); + if (headMessage) { + diagnosticChainHead = ts.chainDiagnosticMessages(diagnosticChainHead, headMessage); + } reportNoCommonSupertypeError(inferenceCandidates, node.expression || node.tag, diagnosticChainHead); } } else { - error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); } // No signature was applicable. We have already reported the errors for the invalid signature. // If this is a type resolution session, e.g. Language Service, try to get better information that anySignature. @@ -18899,6 +19199,14 @@ var ts; } } return resolveErrorCall(node); + function reportError(message, arg0, arg1, arg2) { + var errorInfo; + errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2); + if (headMessage) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage); + } + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo)); + } function chooseOverload(candidates, relation) { for (var _i = 0; _i < candidates.length; _i++) { var originalCandidate = candidates[_i]; @@ -18919,7 +19227,7 @@ var ts; typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, false); } else { - inferTypeArguments(candidate, args, excludeArgument, inferenceContext); + inferTypeArguments(node, candidate, args, excludeArgument, inferenceContext); typeArgumentsAreValid = inferenceContext.failedTypeParameterIndex === undefined; typeArgumentTypes = inferenceContext.inferredTypes; } @@ -18968,7 +19276,7 @@ var ts; if (superType !== unknownType) { // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated // with the type arguments specified in the extends clause. - var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getAncestor(node, 204 /* ClassDeclaration */)); + var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getContainingClass(node)); var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); return resolveCall(node, baseConstructors, candidatesOutArray); } @@ -19082,6 +19390,47 @@ var ts; } return resolveCall(node, callSignatures, candidatesOutArray); } + /** + * Gets the localized diagnostic head message to use for errors when resolving a decorator as a call expression. + */ + function getDiagnosticHeadMessageForDecoratorResolution(node) { + switch (node.parent.kind) { + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; + case 131 /* Parameter */: + return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; + case 134 /* PropertyDeclaration */: + return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression; + } + } + /** + * Resolves a decorator as if it were a call expression. + */ + function resolveDecorator(node, candidatesOutArray) { + var funcType = checkExpression(node.expression); + var apparentType = getApparentType(funcType); + if (apparentType === unknownType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0 /* Call */); + if (funcType === anyType || (!callSignatures.length && !(funcType.flags & 16384 /* Union */) && isTypeAssignableTo(funcType, globalFunctionType))) { + return resolveUntypedCall(node); + } + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + if (!callSignatures.length) { + var errorInfo; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); + errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo)); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, headMessage); + } // candidatesOutArray is passed by signature help in the language service, and collectCandidates // must fill it up with the appropriate candidate signatures function getResolvedSignature(node, candidatesOutArray) { @@ -19101,6 +19450,9 @@ var ts; else if (node.kind === 162 /* TaggedTemplateExpression */) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } + else if (node.kind === 132 /* Decorator */) { + links.resolvedSignature = resolveDecorator(node, candidatesOutArray); + } else { ts.Debug.fail("Branch in 'getResolvedSignature' should be unreachable."); } @@ -19343,7 +19695,7 @@ var ts; if (node.type) { checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, undefined); } - checkFunctionExpressionBodies(node.body); + checkFunctionAndClassExpressionBodies(node.body); } } } @@ -19807,7 +20159,7 @@ var ts; if (ts.isFunctionLike(parent) && current === parent.body) { return false; } - else if (current.kind === 204 /* ClassDeclaration */ || current.kind === 177 /* ClassExpression */) { + else if (ts.isClassLike(current)) { return true; } current = parent; @@ -20707,29 +21059,37 @@ var ts; } /** Check a decorator */ function checkDecorator(node) { - var expression = node.expression; - var exprType = checkExpression(expression); + var signature = getResolvedSignature(node); + var returnType = getReturnTypeOfSignature(signature); + if (returnType.flags & 1 /* Any */) { + return; + } + var expectedReturnType; + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + var errorInfo; switch (node.parent.kind) { case 204 /* ClassDeclaration */: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); - var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); - checkTypeAssignableTo(exprType, classDecoratorType, node); + expectedReturnType = getUnionType([classConstructorType, voidType]); + break; + case 131 /* Parameter */: + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any); break; case 134 /* PropertyDeclaration */: - checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any); break; case 136 /* MethodDeclaration */: case 138 /* GetAccessor */: case 139 /* SetAccessor */: var methodType = getTypeOfNode(node.parent); - var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); - checkTypeAssignableTo(exprType, methodDecoratorType, node); - break; - case 131 /* Parameter */: - checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); + var descriptorType = createTypedPropertyDescriptorType(methodType); + expectedReturnType = getUnionType([descriptorType, voidType]); break; } + checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, errorInfo); } /** Checks a type reference node as an expression. */ function checkTypeNodeAsExpression(node) { @@ -20880,7 +21240,7 @@ var ts; } ts.forEach(node.statements, checkSourceElement); if (ts.isFunctionBlock(node) || node.kind === 209 /* ModuleBlock */) { - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); } } function checkCollisionWithArgumentsInGeneratedCode(node) { @@ -20945,7 +21305,7 @@ var ts; return; } // bubble up and find containing type - var enclosingClass = ts.getAncestor(node, 204 /* ClassDeclaration */); + var enclosingClass = ts.getContainingClass(node); // if containing type was not found or it is ambient - exit (no codegen) if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; @@ -21650,7 +22010,7 @@ var ts; checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */); checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */); }); - if (type.flags & 1024 /* Class */ && type.symbol.valueDeclaration.kind === 204 /* ClassDeclaration */) { + if (type.flags & 1024 /* Class */ && ts.isClassLike(type.symbol.valueDeclaration)) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; @@ -21739,15 +22099,17 @@ var ts; } } function checkClassExpression(node) { - grammarErrorOnNode(node, ts.Diagnostics.class_expressions_are_not_currently_supported); - ts.forEach(node.members, checkSourceElement); - return unknownType; + checkClassLikeDeclaration(node); + return getTypeOfSymbol(getSymbolOfNode(node)); } function checkClassDeclaration(node) { - // Grammar checking if (!node.name && !(node.flags & 256 /* Default */)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } + checkClassLikeDeclaration(node); + ts.forEach(node.members, checkSourceElement); + } + function checkClassLikeDeclaration(node) { checkGrammarClassDeclarationHeritageClauses(node); checkDecorators(node); if (node.name) { @@ -21812,7 +22174,6 @@ var ts; } }); } - ts.forEach(node.members, checkSourceElement); if (produceDiagnostics) { checkIndexConstraints(type); checkTypeForDuplicateIndexSignatures(node); @@ -22608,8 +22969,8 @@ var ts; return checkMissingDeclaration(node); } } - // Function expression bodies are checked after all statements in the enclosing body. This is to ensure - // constructs like the following are permitted: + // Function and class expression bodies are checked after all statements in the enclosing body. This is + // to ensure constructs like the following are permitted: // let foo = function () { // let s = foo(); // return "hello"; @@ -22617,17 +22978,20 @@ var ts; // Here, performing a full type check of the body of the function expression whilst in the process of // determining the type of foo would cause foo to be given type any because of the recursive reference. // Delaying the type check of the body ensures foo has been assigned a type. - function checkFunctionExpressionBodies(node) { + function checkFunctionAndClassExpressionBodies(node) { switch (node.kind) { case 165 /* FunctionExpression */: case 166 /* ArrowFunction */: - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; + case 177 /* ClassExpression */: + ts.forEach(node.members, checkSourceElement); + break; case 136 /* MethodDeclaration */: case 135 /* MethodSignature */: - ts.forEach(node.decorators, checkFunctionExpressionBodies); - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.decorators, checkFunctionAndClassExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } @@ -22636,10 +23000,10 @@ var ts; case 138 /* GetAccessor */: case 139 /* SetAccessor */: case 203 /* FunctionDeclaration */: - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); break; case 195 /* WithStatement */: - checkFunctionExpressionBodies(node.expression); + checkFunctionAndClassExpressionBodies(node.expression); break; case 132 /* Decorator */: case 131 /* Parameter */: @@ -22696,7 +23060,7 @@ var ts; case 229 /* EnumMember */: case 217 /* ExportAssignment */: case 230 /* SourceFile */: - ts.forEachChild(node, checkFunctionExpressionBodies); + ts.forEachChild(node, checkFunctionAndClassExpressionBodies); break; } } @@ -22721,7 +23085,7 @@ var ts; emitParam = false; potentialThisCollisions.length = 0; ts.forEach(node.statements, checkSourceElement); - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); if (ts.isExternalModule(node)) { checkExternalModuleExports(node); } @@ -22796,6 +23160,11 @@ var ts; case 207 /* EnumDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); break; + case 177 /* ClassExpression */: + if (location.name) { + copySymbol(location.symbol, meaning); + } + // Fall through case 204 /* ClassDeclaration */: case 205 /* InterfaceDeclaration */: if (!(memberFlags & 128 /* Static */)) { @@ -22831,41 +23200,6 @@ var ts; } } } - if (isInsideWithStatementBody(location)) { - // We cannot answer semantic questions within a with block, do not proceed any further - return []; - } - while (location) { - if (location.locals && !isGlobalSourceFile(location)) { - copySymbols(location.locals, meaning); - } - switch (location.kind) { - case 230 /* SourceFile */: - if (!ts.isExternalModule(location)) - break; - case 208 /* ModuleDeclaration */: - copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */); - break; - case 207 /* EnumDeclaration */: - copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); - break; - case 204 /* ClassDeclaration */: - case 205 /* InterfaceDeclaration */: - if (!(memberFlags & 128 /* Static */)) { - copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */); - } - break; - case 165 /* FunctionExpression */: - if (location.name) { - copySymbol(location.symbol, meaning); - } - break; - } - memberFlags = location.flags; - location = location.parent; - } - copySymbols(globals, meaning); - return symbolsToArray(symbols); } function isTypeDeclarationName(name) { return name.kind === 65 /* Identifier */ && @@ -22967,6 +23301,9 @@ var ts; meaning |= 8388608 /* Alias */; return resolveEntityName(entityName, meaning); } + if (entityName.parent.kind === 143 /* TypePredicate */) { + return resolveEntityName(entityName, 1 /* FunctionScopedVariable */); + } // Do we want to return undefined here? return undefined; } @@ -23081,6 +23418,16 @@ var ts; } return checkExpression(expr); } + /** + * Gets either the static or instance type of a class element, based on + * whether the element is declared as "static". + */ + function getParentTypeOfClassElement(node) { + var classSymbol = getSymbolOfNode(node.parent); + return node.flags & 128 /* Static */ + ? getTypeOfSymbol(classSymbol) + : getDeclaredTypeOfSymbol(classSymbol); + } // Return the list of properties of the given type, augmented with properties from Function // if the type has call or construct signatures function getAugmentedPropertiesOfType(type) { @@ -23566,10 +23913,7 @@ var ts; globalNumberType = getGlobalType("Number"); globalBooleanType = getGlobalType("Boolean"); globalRegExpType = getGlobalType("RegExp"); - getGlobalClassDecoratorType = ts.memoize(function () { return getGlobalType("ClassDecorator"); }); - getGlobalPropertyDecoratorType = ts.memoize(function () { return getGlobalType("PropertyDecorator"); }); - getGlobalMethodDecoratorType = ts.memoize(function () { return getGlobalType("MethodDecorator"); }); - getGlobalParameterDecoratorType = ts.memoize(function () { return getGlobalType("ParameterDecorator"); }); + getGlobalTypedPropertyDescriptorType = ts.memoize(function () { return getGlobalType("TypedPropertyDescriptor", 1); }); // If we're in ES6 mode, load the TemplateStringsArray. // Otherwise, default to 'unknown' for the purposes of type checking in LS scenarios. if (languageVersion >= 2 /* ES6 */) { @@ -24132,7 +24476,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 204 /* ClassDeclaration */) { + if (ts.isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -24390,7 +24734,7 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 204 /* ClassDeclaration */) { + if (ts.isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; @@ -26121,6 +26465,9 @@ var ts; function generateNameForExportDefault() { return makeUniqueName("default"); } + function generateNameForClassExpression() { + return makeUniqueName("class"); + } function generateNameForNode(node) { switch (node.kind) { case 65 /* Identifier */: @@ -26133,9 +26480,10 @@ var ts; return generateNameForImportOrExportDeclaration(node); case 203 /* FunctionDeclaration */: case 204 /* ClassDeclaration */: - case 177 /* ClassExpression */: case 217 /* ExportAssignment */: return generateNameForExportDefault(); + case 177 /* ClassExpression */: + return generateNameForClassExpression(); } } function getGeneratedNameForNode(node) { @@ -37159,6 +37507,10 @@ var ts; if (actualIndentation !== -1 /* Unknown */) { return actualIndentation; } + actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options); + if (actualIndentation !== -1 /* Unknown */) { + return actualIndentation + options.IndentSize; + } previous = current; current = current.parent; } @@ -37201,6 +37553,10 @@ var ts; if (actualIndentation !== -1 /* Unknown */) { return actualIndentation + indentationDelta; } + actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options); + if (actualIndentation !== -1 /* Unknown */) { + return actualIndentation + indentationDelta; + } } // increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line if (shouldIndentChildNode(parent.kind, current.kind) && !parentAndChildShareLine) { @@ -37338,6 +37694,44 @@ var ts; return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : -1 /* Unknown */; } } + function getLineIndentationWhenExpressionIsInMultiLine(node, sourceFile, options) { + // actual indentation should not be used when: + // - node is close parenthesis - this is the end of the expression + if (node.kind === 17 /* CloseParenToken */) { + return -1 /* Unknown */; + } + if (node.parent && (node.parent.kind === 160 /* CallExpression */ || + node.parent.kind === 161 /* NewExpression */) && + node.parent.expression !== node) { + var fullCallOrNewExpression = node.parent.expression; + var startingExpression = getStartingExpression(fullCallOrNewExpression); + if (fullCallOrNewExpression === startingExpression) { + return -1 /* Unknown */; + } + var fullCallOrNewExpressionEnd = sourceFile.getLineAndCharacterOfPosition(fullCallOrNewExpression.end); + var startingExpressionEnd = sourceFile.getLineAndCharacterOfPosition(startingExpression.end); + if (fullCallOrNewExpressionEnd.line === startingExpressionEnd.line) { + return -1 /* Unknown */; + } + return findColumnForFirstNonWhitespaceCharacterInLine(fullCallOrNewExpressionEnd, sourceFile, options); + } + return -1 /* Unknown */; + function getStartingExpression(node) { + while (true) { + switch (node.kind) { + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + node = node.expression; + break; + default: + return node; + } + } + return node; + } + } function deriveActualIndentationFromList(list, index, sourceFile, options) { ts.Debug.assert(index >= 0 && index < list.length); var node = list[index]; diff --git a/bin/typescriptServices.d.ts b/bin/typescriptServices.d.ts index da6d55bfd80..70e4f42e1ef 100644 --- a/bin/typescriptServices.d.ts +++ b/bin/typescriptServices.d.ts @@ -600,7 +600,7 @@ declare namespace ts { tag: LeftHandSideExpression; template: LiteralExpression | TemplateExpression; } - type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression; + type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator; interface TypeAssertion extends UnaryExpression { type: TypeNode; expression: UnaryExpression; diff --git a/bin/typescriptServices.js b/bin/typescriptServices.js index 6989f225452..6373e3f9c58 100644 --- a/bin/typescriptServices.js +++ b/bin/typescriptServices.js @@ -1950,6 +1950,12 @@ var ts; An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: ts.DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: ts.DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: ts.DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, + The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: { code: 1236, category: ts.DiagnosticCategory.Error, key: "The return type of a property decorator function must be either 'void' or 'any'." }, + The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: { code: 1237, category: ts.DiagnosticCategory.Error, key: "The return type of a parameter decorator function must be either 'void' or 'any'." }, + Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: { code: 1238, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of class decorator when called as an expression." }, + Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: { code: 1239, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of parameter decorator when called as an expression." }, + Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: { code: 1240, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of property decorator when called as an expression." }, + Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: { code: 1241, category: ts.DiagnosticCategory.Error, key: "Unable to resolve signature of method decorator when called as an expression." }, Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.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: ts.DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -2325,9 +2331,7 @@ var ts; property_declarations_can_only_be_used_in_a_ts_file: { code: 8014, category: ts.DiagnosticCategory.Error, key: "'property declarations' can only be used in a .ts file." }, enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: ts.DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." }, type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: ts.DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." }, - decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: ts.DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, - Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: ts.DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, - class_expressions_are_not_currently_supported: { code: 9003, category: ts.DiagnosticCategory.Error, key: "'class' expressions are not currently supported." } + decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: ts.DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." } }; })(ts || (ts = {})); /// @@ -4284,7 +4288,7 @@ var ts; function getStrictModeIdentifierMessage(node) { // Provide specialized messages to help the user understand why we think they're in // strict mode. - if (ts.getAncestor(node, 204 /* ClassDeclaration */) || ts.getAncestor(node, 177 /* ClassExpression */)) { + if (ts.getContainingClass(node)) { return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; } if (file.externalModuleIndicator) { @@ -4333,7 +4337,7 @@ var ts; function getStrictModeEvalOrArgumentsMessage(node) { // Provide specialized messages to help the user understand why we think they're in // strict mode. - if (ts.getAncestor(node, 204 /* ClassDeclaration */) || ts.getAncestor(node, 177 /* ClassExpression */)) { + if (ts.getContainingClass(node)) { return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode; } if (file.externalModuleIndicator) { @@ -4641,7 +4645,7 @@ var ts; // containing class. if (node.flags & 112 /* AccessibilityModifier */ && node.parent.kind === 137 /* Constructor */ && - (node.parent.parent.kind === 204 /* ClassDeclaration */ || node.parent.parent.kind === 177 /* ClassExpression */)) { + ts.isClassLike(node.parent.parent)) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* Property */, 107455 /* PropertyExcludes */); } @@ -5136,6 +5140,7 @@ var ts; case 208 /* ModuleDeclaration */: case 206 /* TypeAliasDeclaration */: case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: // These are not allowed inside a generator now, but eventually they may be allowed // as local types. Regardless, any yield statements contained within them should be // skipped in this traversal. @@ -5177,20 +5182,11 @@ var ts; } ts.isVariableLike = isVariableLike; function isAccessor(node) { - if (node) { - switch (node.kind) { - case 138 /* GetAccessor */: - case 139 /* SetAccessor */: - return true; - } - } - return false; + return node && (node.kind === 138 /* GetAccessor */ || node.kind === 139 /* SetAccessor */); } ts.isAccessor = isAccessor; function isClassLike(node) { - if (node) { - return node.kind === 204 /* ClassDeclaration */ || node.kind === 177 /* ClassExpression */; - } + return node && (node.kind === 204 /* ClassDeclaration */ || node.kind === 177 /* ClassExpression */); } ts.isClassLike = isClassLike; function isFunctionLike(node) { @@ -5232,6 +5228,15 @@ var ts; } } ts.getContainingFunction = getContainingFunction; + function getContainingClass(node) { + while (true) { + node = node.parent; + if (!node || isClassLike(node)) { + return node; + } + } + } + ts.getContainingClass = getContainingClass; function getThisContainer(node, includeArrowFunctions) { while (true) { node = node.parent; @@ -5244,7 +5249,7 @@ var ts; // then the computed property is not a 'this' container. // A computed property name in a class needs to be a this container // so that we can error on it. - if (node.parent.parent.kind === 204 /* ClassDeclaration */) { + if (isClassLike(node.parent.parent)) { return node; } // If this is a computed property, then the parent should not @@ -5300,7 +5305,7 @@ var ts; // then the computed property is not a 'super' container. // A computed property name in a class needs to be a super container // so that we can error on it. - if (node.parent.parent.kind === 204 /* ClassDeclaration */) { + if (isClassLike(node.parent.parent)) { return node; } // If this is a computed property, then the parent should not @@ -5345,7 +5350,7 @@ var ts; if (node.kind === 162 /* TaggedTemplateExpression */) { return node.tag; } - // Will either be a CallExpression or NewExpression. + // Will either be a CallExpression, NewExpression, or Decorator. return node.expression; } ts.getInvokedExpression = getInvokedExpression; @@ -5658,6 +5663,7 @@ var ts; case 166 /* ArrowFunction */: case 155 /* BindingElement */: case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: case 137 /* Constructor */: case 207 /* EnumDeclaration */: case 229 /* EnumMember */: @@ -6429,7 +6435,7 @@ var ts; function isExpressionWithTypeArgumentsInClassExtendsClause(node) { return node.kind === 179 /* ExpressionWithTypeArguments */ && node.parent.token === 79 /* ExtendsKeyword */ && - node.parent.parent.kind === 204 /* ClassDeclaration */; + isClassLike(node.parent.parent); } ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; // Returns false if this heritage clause element's expression contains something unsupported @@ -12210,10 +12216,7 @@ var ts; var globalIteratorType; var globalIterableIteratorType; var anyArrayType; - var getGlobalClassDecoratorType; - var getGlobalParameterDecoratorType; - var getGlobalPropertyDecoratorType; - var getGlobalMethodDecoratorType; + var getGlobalTypedPropertyDescriptorType; var tupleTypes = {}; var unionTypes = {}; var stringLiteralTypes = {}; @@ -12499,7 +12502,7 @@ var ts; // local variables of the constructor. This effectively means that entities from outer scopes // by the same name as a constructor parameter or local variable are inaccessible // in initializer expressions for instance member variables. - if (location.parent.kind === 204 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) { + if (ts.isClassLike(location.parent) && !(location.flags & 128 /* Static */)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455 /* Value */)) { @@ -12510,6 +12513,7 @@ var ts; } break; case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: case 205 /* InterfaceDeclaration */: if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056 /* Type */)) { if (lastLocation && lastLocation.flags & 128 /* Static */) { @@ -12521,6 +12525,13 @@ var ts; } break loop; } + if (location.kind === 177 /* ClassExpression */ && meaning & 32 /* Class */) { + var className = location.name; + if (className && name === className.text) { + result = location.symbol; + break loop; + } + } break; // It is not legal to reference a class's own type parameters from a computed property name that // belongs to the class. For example: @@ -12532,7 +12543,7 @@ var ts; // case 129 /* ComputedPropertyName */: grandparent = location.parent.parent; - if (grandparent.kind === 204 /* ClassDeclaration */ || grandparent.kind === 205 /* InterfaceDeclaration */) { + if (ts.isClassLike(grandparent) || grandparent.kind === 205 /* InterfaceDeclaration */) { // A reference to this grandparent's type parameters would be an error if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & 793056 /* Type */)) { error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); @@ -12565,15 +12576,6 @@ var ts; } } break; - case 177 /* ClassExpression */: - if (meaning & 32 /* Class */) { - var className = location.name; - if (className && name === className.text) { - result = location.symbol; - break loop; - } - } - break; case 132 /* Decorator */: // Decorators are resolved at the class declaration. Resolving at the parameter // or member would result in looking up locals in the method. @@ -13407,19 +13409,28 @@ var ts; // This is for caching the result of getSymbolDisplayBuilder. Do not access directly. var _displayBuilder; function getSymbolDisplayBuilder() { + function getNameOfSymbol(symbol) { + if (symbol.declarations && symbol.declarations.length) { + var declaration = symbol.declarations[0]; + if (declaration.name) { + return ts.declarationNameToString(declaration.name); + } + switch (declaration.kind) { + case 177 /* ClassExpression */: + return "(Anonymous class)"; + case 165 /* FunctionExpression */: + case 166 /* ArrowFunction */: + return "(Anonymous function)"; + } + } + return symbol.name; + } /** * Writes only the name of the symbol out to the writer. Uses the original source text * for the name of the symbol if it is available to match how the user inputted the name. */ function appendSymbolNameOnly(symbol, writer) { - if (symbol.declarations && symbol.declarations.length > 0) { - var declaration = symbol.declarations[0]; - if (declaration.name) { - writer.writeSymbol(ts.declarationNameToString(declaration.name), symbol); - return; - } - } - writer.writeSymbol(symbol.name, symbol); + writer.writeSymbol(getNameOfSymbol(symbol), symbol); } /** * Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope @@ -14488,9 +14499,9 @@ var ts; if (!node) { return typeParameters; } - if (node.kind === 204 /* ClassDeclaration */ || node.kind === 203 /* FunctionDeclaration */ || - node.kind === 165 /* FunctionExpression */ || node.kind === 136 /* MethodDeclaration */ || - node.kind === 166 /* ArrowFunction */) { + if (node.kind === 204 /* ClassDeclaration */ || node.kind === 177 /* ClassExpression */ || + node.kind === 203 /* FunctionDeclaration */ || node.kind === 165 /* FunctionExpression */ || + node.kind === 136 /* MethodDeclaration */ || node.kind === 166 /* ArrowFunction */) { var declarations = node.typeParameters; if (declarations) { return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations); @@ -14500,8 +14511,8 @@ var ts; } // The outer type parameters are those defined by enclosing generic classes, methods, or functions. function getOuterTypeParametersOfClassOrInterface(symbol) { - var kind = symbol.flags & 32 /* Class */ ? 204 /* ClassDeclaration */ : 205 /* InterfaceDeclaration */; - return appendOuterTypeParameters(undefined, ts.getDeclarationOfKind(symbol, kind)); + var declaration = symbol.flags & 32 /* Class */ ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 205 /* InterfaceDeclaration */); + return appendOuterTypeParameters(undefined, declaration); } // The local type parameters are the combined set of type parameters from all declarations of the class, // interface, or type alias. @@ -14509,7 +14520,8 @@ var ts; var result; for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { var node = _a[_i]; - if (node.kind === 205 /* InterfaceDeclaration */ || node.kind === 204 /* ClassDeclaration */ || node.kind === 206 /* TypeAliasDeclaration */) { + if (node.kind === 205 /* InterfaceDeclaration */ || node.kind === 204 /* ClassDeclaration */ || + node.kind === 177 /* ClassExpression */ || node.kind === 206 /* TypeAliasDeclaration */) { var declaration = node; if (declaration.typeParameters) { result = appendTypeParameters(result, declaration.typeParameters); @@ -15604,6 +15616,15 @@ var ts; function getGlobalESSymbolConstructorSymbol() { return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); } + /** + * Creates a TypeReference for a generic `TypedPropertyDescriptor`. + */ + function createTypedPropertyDescriptorType(propertyType) { + var globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); + return globalTypedPropertyDescriptorType !== emptyObjectType + ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) + : emptyObjectType; + } /** * Instantiates a global type that is generic with some element type, and returns that instantiation. */ @@ -16042,8 +16063,8 @@ var ts; function checkTypeSubtypeOf(source, target, errorNode, headMessage, containingMessageChain) { return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source, target, errorNode, headMessage) { - return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage); + function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain) { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source, target) { var sourceType = getOrCreateTypeFromSignature(source); @@ -17582,9 +17603,9 @@ var ts; } } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 204 /* ClassDeclaration */ ? container.parent : undefined; getNodeLinks(node).flags |= 2 /* LexicalThis */; if (container.kind === 134 /* PropertyDeclaration */ || container.kind === 137 /* Constructor */) { + var classNode = container.parent; getNodeLinks(classNode).flags |= 4 /* CaptureThis */; } else { @@ -17629,9 +17650,8 @@ var ts; if (needToCaptureLexicalThis) { captureLexicalThis(node, container); } - var classNode = container.parent && container.parent.kind === 204 /* ClassDeclaration */ ? container.parent : undefined; - if (classNode) { - var symbol = getSymbolOfNode(classNode); + if (ts.isClassLike(container.parent)) { + var symbol = getSymbolOfNode(container.parent); return container.flags & 128 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); } return anyType; @@ -17646,7 +17666,7 @@ var ts; } function checkSuperExpression(node) { var isCallExpression = node.parent.kind === 160 /* CallExpression */ && node.parent.expression === node; - var classDeclaration = ts.getAncestor(node, 204 /* ClassDeclaration */); + var classDeclaration = ts.getContainingClass(node); var classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); var baseClassType = classType && getBaseTypes(classType)[0]; if (!baseClassType) { @@ -17676,7 +17696,7 @@ var ts; needToCaptureLexicalThis = languageVersion < 2 /* ES6 */; } // topmost container must be something that is directly nested in the class declaration - if (container && container.parent && container.parent.kind === 204 /* ClassDeclaration */) { + if (container && ts.isClassLike(container.parent)) { if (container.flags & 128 /* Static */) { canUseSuperExpression = container.kind === 136 /* MethodDeclaration */ || @@ -18276,7 +18296,7 @@ var ts; } // Property is known to be private or protected at this point // Get the declaring and enclosing class instance types - var enclosingClassDeclaration = ts.getAncestor(node, 204 /* ClassDeclaration */); + var enclosingClassDeclaration = ts.getContainingClass(node); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); // Private property is accessible if declaring and enclosing class are the same @@ -18502,7 +18522,7 @@ var ts; if (node.kind === 162 /* TaggedTemplateExpression */) { checkExpression(node.template); } - else { + else if (node.kind !== 132 /* Decorator */) { ts.forEach(node.arguments, function (argument) { checkExpression(argument); }); @@ -18567,7 +18587,8 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 176 /* SpreadElementExpression */) { + var arg = args[i]; + if (arg && arg.kind === 176 /* SpreadElementExpression */) { return i; } } @@ -18577,6 +18598,8 @@ var ts; var adjustedArgCount; // Apparent number of arguments we will have in this call var typeArguments; // Type arguments (undefined if none) var callIsIncomplete; // In incomplete call we want to be lenient when we have too few arguments + var isDecorator; + var spreadArgIndex = -1; if (node.kind === 162 /* TaggedTemplateExpression */) { var tagExpression = node; // Even if the call is incomplete, we'll have a missing expression as our last argument, @@ -18600,6 +18623,11 @@ var ts; callIsIncomplete = !!templateLiteral.isUnterminated; } } + else if (node.kind === 132 /* Decorator */) { + isDecorator = true; + typeArguments = undefined; + adjustedArgCount = getEffectiveArgumentCount(node, undefined, signature); + } else { var callExpression = node; if (!callExpression.arguments) { @@ -18612,6 +18640,7 @@ var ts; // If we are missing the close paren, the call is incomplete. callIsIncomplete = callExpression.arguments.end === callExpression.end; typeArguments = callExpression.typeArguments; + spreadArgIndex = getSpreadArgumentIndex(args); } // If the user supplied type arguments, but the number of type arguments does not match // the declared number of type parameters, the call has an incorrect arity. @@ -18622,7 +18651,6 @@ var ts; } // If spread arguments are present, check that they correspond to a rest parameter. If so, no // further checking is necessary. - var spreadArgIndex = getSpreadArgumentIndex(args); if (spreadArgIndex >= 0) { return signature.hasRestParameter && spreadArgIndex >= signature.parameters.length - 1; } @@ -18654,7 +18682,7 @@ var ts; }); return getSignatureInstantiation(signature, getInferredTypes(context)); } - function inferTypeArguments(signature, args, excludeArgument, context) { + function inferTypeArguments(node, signature, args, excludeArgument, context) { var typeParameters = signature.typeParameters; var inferenceMapper = createInferenceMapper(context); // Clear out all the inference results from the last time inferTypeArguments was called on this context @@ -18679,15 +18707,16 @@ var ts; } // We perform two passes over the arguments. In the first pass we infer from all arguments, but use // wildcards for all context sensitive function expressions. - for (var i = 0; i < args.length; i++) { - var arg = args[i]; - if (arg.kind !== 178 /* OmittedExpression */) { + var argCount = getEffectiveArgumentCount(node, args, signature); + for (var i = 0; i < argCount; i++) { + var arg = getEffectiveArgument(node, args, i); + // If the effective argument is 'undefined', then it is an argument that is present but is synthetic. + if (arg === undefined || arg.kind !== 178 /* OmittedExpression */) { var paramType = getTypeAtPosition(signature, i); - var argType = void 0; - if (i === 0 && args[i].parent.kind === 162 /* TaggedTemplateExpression */) { - argType = globalTemplateStringsArrayType; - } - else { + var argType = getEffectiveArgumentType(node, i, arg); + // If the effective argument type is 'undefined', there is no synthetic type + // for the argument. In that case, we should check the argument. + if (argType === undefined) { // For context sensitive arguments we pass the identityMapper, which is a signal to treat all // context sensitive function expressions as wildcards var mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; @@ -18699,8 +18728,10 @@ var ts; // In the second pass we visit only context sensitive arguments, and only those that aren't excluded, this // time treating function expressions normally (which may cause previously inferred type arguments to be fixed // as we construct types for contextually typed parameters) + // Decorators will not have `excludeArgument`, as their arguments cannot be contextually typed. + // Tagged template expressions will always have `undefined` for `excludeArgument[0]`. if (excludeArgument) { - for (var i = 0; i < args.length; i++) { + for (var i = 0; i < argCount; i++) { // No need to check for omitted args and template expressions, their exlusion value is always undefined if (excludeArgument[i] === false) { var arg = args[i]; @@ -18711,7 +18742,7 @@ var ts; } getInferredTypes(context); } - function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors) { + function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors, headMessage) { var typeParameters = signature.typeParameters; var typeArgumentsAreAssignable = true; for (var i = 0; i < typeParameters.length; i++) { @@ -18722,27 +18753,38 @@ var ts; if (typeArgumentsAreAssignable /* so far */) { var constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { - typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + var errorInfo = void 0; + var typeArgumentHeadMessage = ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (reportErrors && headMessage) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); + typeArgumentHeadMessage = headMessage; + } + typeArgumentsAreAssignable = checkTypeAssignableTo(typeArgument, constraint, reportErrors ? typeArgNode : undefined, typeArgumentHeadMessage, errorInfo); } } } return typeArgumentsAreAssignable; } function checkApplicableSignature(node, args, signature, relation, excludeArgument, reportErrors) { - for (var i = 0; i < args.length; i++) { - var arg = args[i]; - if (arg.kind !== 178 /* OmittedExpression */) { + var argCount = getEffectiveArgumentCount(node, args, signature); + for (var i = 0; i < argCount; i++) { + var arg = getEffectiveArgument(node, args, i); + // If the effective argument is 'undefined', then it is an argument that is present but is synthetic. + if (arg === undefined || arg.kind !== 178 /* OmittedExpression */) { // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) var paramType = getTypeAtPosition(signature, i); - // A tagged template expression provides a special first argument, and string literals get string literal types - // unless we're reporting errors - var argType = i === 0 && node.kind === 162 /* TaggedTemplateExpression */ - ? globalTemplateStringsArrayType - : arg.kind === 8 /* StringLiteral */ && !reportErrors + var argType = getEffectiveArgumentType(node, i, arg); + // If the effective argument type is 'undefined', there is no synthetic type + // for the argument. In that case, we should check the argument. + if (argType === undefined) { + argType = arg.kind === 8 /* StringLiteral */ && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + } // Use argument expression as error location when reporting errors - if (!checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1)) { + var errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; + var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; + if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) { return false; } } @@ -18754,28 +18796,276 @@ var ts; * * If 'node' is a CallExpression or a NewExpression, then its argument list is returned. * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution - * expressions, where the first element of the list is the template for error reporting purposes. + * expressions, where the first element of the list is `undefined`. + * If 'node' is a Decorator, the argument list will be `undefined`, and its arguments and types + * will be supplied from calls to `getEffectiveArgumentCount` and `getEffectiveArgumentType`. */ function getEffectiveCallArguments(node) { var args; if (node.kind === 162 /* TaggedTemplateExpression */) { var template = node.template; - args = [template]; + args = [undefined]; if (template.kind === 174 /* TemplateExpression */) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); } } + else if (node.kind === 132 /* Decorator */) { + // For a decorator, we return undefined as we will determine + // the number and types of arguments for a decorator using + // `getEffectiveArgumentCount` and `getEffectiveArgumentType` below. + return undefined; + } else { args = node.arguments || emptyArray; } return args; } - function resolveCall(node, signatures, candidatesOutArray) { + /** + * Returns the effective argument count for a node that works like a function invocation. + * If 'node' is a Decorator, the number of arguments is derived from the decoration + * target and the signature: + * If 'node.target' is a class declaration or class expression, the effective argument + * count is 1. + * If 'node.target' is a parameter declaration, the effective argument count is 3. + * If 'node.target' is a property declaration, the effective argument count is 2. + * If 'node.target' is a method or accessor declaration, the effective argument count + * is 3, although it can be 2 if the signature only accepts two arguments, allowing + * us to match a property decorator. + * Otherwise, the argument count is the length of the 'args' array. + */ + function getEffectiveArgumentCount(node, args, signature) { + if (node.kind === 132 /* Decorator */) { + switch (node.parent.kind) { + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + // A class decorator will have one argument (see `ClassDecorator` in core.d.ts) + return 1; + case 134 /* PropertyDeclaration */: + // A property declaration decorator will have two arguments (see + // `PropertyDecorator` in core.d.ts) + return 2; + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + // A method or accessor declaration decorator will have two or three arguments (see + // `PropertyDecorator` and `MethodDecorator` in core.d.ts) + // If the method decorator signature only accepts a target and a key, we will only + // type check those arguments. + return signature.parameters.length >= 3 ? 3 : 2; + case 131 /* Parameter */: + // A parameter declaration decorator will have three arguments (see + // `ParameterDecorator` in core.d.ts) + return 3; + } + } + else { + return args.length; + } + } + /** + * Returns the effective type of the first argument to a decorator. + * If 'node' is a class declaration or class expression, the effective argument type + * is the type of the static side of the class. + * If 'node' is a parameter declaration, the effective argument type is either the type + * of the static or instance side of the class for the parameter's parent method, + * depending on whether the method is declared static. + * For a constructor, the type is always the type of the static side of the class. + * If 'node' is a property, method, or accessor declaration, the effective argument + * type is the type of the static or instance side of the parent class for class + * element, depending on whether the element is declared static. + */ + function getEffectiveDecoratorFirstArgumentType(node) { + // The first argument to a decorator is its `target`. + switch (node.kind) { + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + // For a class decorator, the `target` is the type of the class (e.g. the + // "static" or "constructor" side of the class) + var classSymbol = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol); + case 131 /* Parameter */: + // For a parameter decorator, the `target` is the parent type of the + // parameter's containing method. + node = node.parent; + if (node.kind === 137 /* Constructor */) { + var classSymbol_1 = getSymbolOfNode(node); + return getTypeOfSymbol(classSymbol_1); + } + // fall-through + case 134 /* PropertyDeclaration */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + // For a property or method decorator, the `target` is the + // "static"-side type of the parent of the member if the member is + // declared "static"; otherwise, it is the "instance"-side type of the + // parent of the member. + return getParentTypeOfClassElement(node); + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + /** + * Returns the effective type for the second argument to a decorator. + * If 'node' is a parameter, its effective argument type is one of the following: + * If 'node.parent' is a constructor, the effective argument type is 'any', as we + * will emit `undefined`. + * If 'node.parent' is a member with an identifier, numeric, or string literal name, + * the effective argument type will be a string literal type for the member name. + * If 'node.parent' is a computed property name, the effective argument type will + * either be a symbol type or the string type. + * If 'node' is a member with an identifier, numeric, or string literal name, the + * effective argument type will be a string literal type for the member name. + * If 'node' is a computed property name, the effective argument type will either + * be a symbol type or the string type. + * A class decorator does not have a second argument type. + */ + function getEffectiveDecoratorSecondArgumentType(node) { + // The second argument to a decorator is its `propertyKey` + switch (node.kind) { + case 204 /* ClassDeclaration */: + ts.Debug.fail("Class decorators should not have a second synthetic argument."); + return unknownType; + case 131 /* Parameter */: + node = node.parent; + if (node.kind === 137 /* Constructor */) { + // For a constructor parameter decorator, the `propertyKey` will be `undefined`. + return anyType; + } + // For a non-constructor parameter decorator, the `propertyKey` will be either + // a string or a symbol, based on the name of the parameter's containing method. + // fall-through + case 134 /* PropertyDeclaration */: + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + // The `propertyKey` for a property or method decorator will be a + // string literal type if the member name is an identifier, number, or string; + // otherwise, if the member name is a computed property name it will + // be either string or symbol. + var element = node; + switch (element.name.kind) { + case 65 /* Identifier */: + case 7 /* NumericLiteral */: + case 8 /* StringLiteral */: + return getStringLiteralType(element.name); + case 129 /* ComputedPropertyName */: + var nameType = checkComputedPropertyName(element.name); + if (allConstituentTypesHaveKind(nameType, 2097152 /* ESSymbol */)) { + return nameType; + } + else { + return stringType; + } + default: + ts.Debug.fail("Unsupported property name."); + return unknownType; + } + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + /** + * Returns the effective argument type for the third argument to a decorator. + * If 'node' is a parameter, the effective argument type is the number type. + * If 'node' is a method or accessor, the effective argument type is a + * `TypedPropertyDescriptor` instantiated with the type of the member. + * Class and property decorators do not have a third effective argument. + */ + function getEffectiveDecoratorThirdArgumentType(node) { + // The third argument to a decorator is either its `descriptor` for a method decorator + // or its `parameterIndex` for a paramter decorator + switch (node.kind) { + case 204 /* ClassDeclaration */: + ts.Debug.fail("Class decorators should not have a third synthetic argument."); + return unknownType; + case 131 /* Parameter */: + // The `parameterIndex` for a parameter decorator is always a number + return numberType; + case 134 /* PropertyDeclaration */: + ts.Debug.fail("Property decorators should not have a third synthetic argument."); + return unknownType; + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor` + // for the type of the member. + var propertyType = getTypeOfNode(node); + return createTypedPropertyDescriptorType(propertyType); + default: + ts.Debug.fail("Unsupported decorator target."); + return unknownType; + } + } + /** + * Returns the effective argument type for the provided argument to a decorator. + */ + function getEffectiveDecoratorArgumentType(node, argIndex) { + if (argIndex === 0) { + return getEffectiveDecoratorFirstArgumentType(node.parent); + } + else if (argIndex === 1) { + return getEffectiveDecoratorSecondArgumentType(node.parent); + } + else if (argIndex === 2) { + return getEffectiveDecoratorThirdArgumentType(node.parent); + } + ts.Debug.fail("Decorators should not have a fourth synthetic argument."); + return unknownType; + } + /** + * Gets the effective argument type for an argument in a call expression. + */ + function getEffectiveArgumentType(node, argIndex, arg) { + // Decorators provide special arguments, a tagged template expression provides + // a special first argument, and string literals get string literal types + // unless we're reporting errors + if (node.kind === 132 /* Decorator */) { + return getEffectiveDecoratorArgumentType(node, argIndex); + } + else if (argIndex === 0 && node.kind === 162 /* TaggedTemplateExpression */) { + return globalTemplateStringsArrayType; + } + // This is not a synthetic argument, so we return 'undefined' + // to signal that the caller needs to check the argument. + return undefined; + } + /** + * Gets the effective argument expression for an argument in a call expression. + */ + function getEffectiveArgument(node, args, argIndex) { + // For a decorator or the first argument of a tagged template expression we return undefined. + if (node.kind === 132 /* Decorator */ || + (argIndex === 0 && node.kind === 162 /* TaggedTemplateExpression */)) { + return undefined; + } + return args[argIndex]; + } + /** + * Gets the error node to use when reporting errors for an effective argument. + */ + function getEffectiveArgumentErrorNode(node, argIndex, arg) { + if (node.kind === 132 /* Decorator */) { + // For a decorator, we use the expression of the decorator for error reporting. + return node.expression; + } + else if (argIndex === 0 && node.kind === 162 /* TaggedTemplateExpression */) { + // For a the first argument of a tagged template expression, we use the template of the tag for error reporting. + return node.template; + } + else { + return arg; + } + } + function resolveCall(node, signatures, candidatesOutArray, headMessage) { var isTaggedTemplate = node.kind === 162 /* TaggedTemplateExpression */; + var isDecorator = node.kind === 132 /* Decorator */; var typeArguments; - if (!isTaggedTemplate) { + if (!isTaggedTemplate && !isDecorator) { typeArguments = node.typeArguments; // We already perform checking on the type arguments on the class declaration itself. if (node.expression.kind !== 91 /* SuperKeyword */) { @@ -18786,7 +19076,7 @@ var ts; // reorderCandidates fills up the candidates array directly reorderCandidates(signatures, candidates); if (!candidates.length) { - error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); return resolveErrorCall(node); } var args = getEffectiveCallArguments(node); @@ -18801,13 +19091,20 @@ var ts; // // For a tagged template, then the first argument be 'undefined' if necessary // because it represents a TemplateStringsArray. + // + // For a decorator, no arguments are susceptible to contextual typing due to the fact + // decorators are applied to a declaration by the emitter, and not to an expression. var excludeArgument; - for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { - if (isContextSensitive(args[i])) { - if (!excludeArgument) { - excludeArgument = new Array(args.length); + if (!isDecorator) { + // We do not need to call `getEffectiveArgumentCount` here as it only + // applies when calculating the number of arguments for a decorator. + for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) { + if (isContextSensitive(args[i])) { + if (!excludeArgument) { + excludeArgument = new Array(args.length); + } + excludeArgument[i] = true; } - excludeArgument[i] = true; } } // The following variables are captured and modified by calls to chooseOverload. @@ -18871,19 +19168,22 @@ var ts; checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); } else if (candidateForTypeArgumentError) { - if (!isTaggedTemplate && typeArguments) { - checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], true); + if (!isTaggedTemplate && !isDecorator && typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true, headMessage); } else { ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0); var failedTypeParameter = candidateForTypeArgumentError.typeParameters[resultOfFailedInference.failedTypeParameterIndex]; var inferenceCandidates = getInferenceCandidates(resultOfFailedInference, resultOfFailedInference.failedTypeParameterIndex); var diagnosticChainHead = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, typeToString(failedTypeParameter)); + if (headMessage) { + diagnosticChainHead = ts.chainDiagnosticMessages(diagnosticChainHead, headMessage); + } reportNoCommonSupertypeError(inferenceCandidates, node.expression || node.tag, diagnosticChainHead); } } else { - error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); } // No signature was applicable. We have already reported the errors for the invalid signature. // If this is a type resolution session, e.g. Language Service, try to get better information that anySignature. @@ -18899,6 +19199,14 @@ var ts; } } return resolveErrorCall(node); + function reportError(message, arg0, arg1, arg2) { + var errorInfo; + errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2); + if (headMessage) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage); + } + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo)); + } function chooseOverload(candidates, relation) { for (var _i = 0; _i < candidates.length; _i++) { var originalCandidate = candidates[_i]; @@ -18919,7 +19227,7 @@ var ts; typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, false); } else { - inferTypeArguments(candidate, args, excludeArgument, inferenceContext); + inferTypeArguments(node, candidate, args, excludeArgument, inferenceContext); typeArgumentsAreValid = inferenceContext.failedTypeParameterIndex === undefined; typeArgumentTypes = inferenceContext.inferredTypes; } @@ -18968,7 +19276,7 @@ var ts; if (superType !== unknownType) { // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated // with the type arguments specified in the extends clause. - var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getAncestor(node, 204 /* ClassDeclaration */)); + var baseTypeNode = ts.getClassExtendsHeritageClauseElement(ts.getContainingClass(node)); var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments); return resolveCall(node, baseConstructors, candidatesOutArray); } @@ -19082,6 +19390,47 @@ var ts; } return resolveCall(node, callSignatures, candidatesOutArray); } + /** + * Gets the localized diagnostic head message to use for errors when resolving a decorator as a call expression. + */ + function getDiagnosticHeadMessageForDecoratorResolution(node) { + switch (node.parent.kind) { + case 204 /* ClassDeclaration */: + case 177 /* ClassExpression */: + return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; + case 131 /* Parameter */: + return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; + case 134 /* PropertyDeclaration */: + return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; + case 136 /* MethodDeclaration */: + case 138 /* GetAccessor */: + case 139 /* SetAccessor */: + return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression; + } + } + /** + * Resolves a decorator as if it were a call expression. + */ + function resolveDecorator(node, candidatesOutArray) { + var funcType = checkExpression(node.expression); + var apparentType = getApparentType(funcType); + if (apparentType === unknownType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0 /* Call */); + if (funcType === anyType || (!callSignatures.length && !(funcType.flags & 16384 /* Union */) && isTypeAssignableTo(funcType, globalFunctionType))) { + return resolveUntypedCall(node); + } + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + if (!callSignatures.length) { + var errorInfo; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); + errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo)); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, headMessage); + } // candidatesOutArray is passed by signature help in the language service, and collectCandidates // must fill it up with the appropriate candidate signatures function getResolvedSignature(node, candidatesOutArray) { @@ -19101,6 +19450,9 @@ var ts; else if (node.kind === 162 /* TaggedTemplateExpression */) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } + else if (node.kind === 132 /* Decorator */) { + links.resolvedSignature = resolveDecorator(node, candidatesOutArray); + } else { ts.Debug.fail("Branch in 'getResolvedSignature' should be unreachable."); } @@ -19343,7 +19695,7 @@ var ts; if (node.type) { checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, undefined); } - checkFunctionExpressionBodies(node.body); + checkFunctionAndClassExpressionBodies(node.body); } } } @@ -19807,7 +20159,7 @@ var ts; if (ts.isFunctionLike(parent) && current === parent.body) { return false; } - else if (current.kind === 204 /* ClassDeclaration */ || current.kind === 177 /* ClassExpression */) { + else if (ts.isClassLike(current)) { return true; } current = parent; @@ -20707,29 +21059,37 @@ var ts; } /** Check a decorator */ function checkDecorator(node) { - var expression = node.expression; - var exprType = checkExpression(expression); + var signature = getResolvedSignature(node); + var returnType = getReturnTypeOfSignature(signature); + if (returnType.flags & 1 /* Any */) { + return; + } + var expectedReturnType; + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + var errorInfo; switch (node.parent.kind) { case 204 /* ClassDeclaration */: var classSymbol = getSymbolOfNode(node.parent); var classConstructorType = getTypeOfSymbol(classSymbol); - var classDecoratorType = instantiateSingleCallFunctionType(getGlobalClassDecoratorType(), [classConstructorType]); - checkTypeAssignableTo(exprType, classDecoratorType, node); + expectedReturnType = getUnionType([classConstructorType, voidType]); + break; + case 131 /* Parameter */: + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any); break; case 134 /* PropertyDeclaration */: - checkTypeAssignableTo(exprType, getGlobalPropertyDecoratorType(), node); + expectedReturnType = voidType; + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any); break; case 136 /* MethodDeclaration */: case 138 /* GetAccessor */: case 139 /* SetAccessor */: var methodType = getTypeOfNode(node.parent); - var methodDecoratorType = instantiateSingleCallFunctionType(getGlobalMethodDecoratorType(), [methodType]); - checkTypeAssignableTo(exprType, methodDecoratorType, node); - break; - case 131 /* Parameter */: - checkTypeAssignableTo(exprType, getGlobalParameterDecoratorType(), node); + var descriptorType = createTypedPropertyDescriptorType(methodType); + expectedReturnType = getUnionType([descriptorType, voidType]); break; } + checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, errorInfo); } /** Checks a type reference node as an expression. */ function checkTypeNodeAsExpression(node) { @@ -20880,7 +21240,7 @@ var ts; } ts.forEach(node.statements, checkSourceElement); if (ts.isFunctionBlock(node) || node.kind === 209 /* ModuleBlock */) { - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); } } function checkCollisionWithArgumentsInGeneratedCode(node) { @@ -20945,7 +21305,7 @@ var ts; return; } // bubble up and find containing type - var enclosingClass = ts.getAncestor(node, 204 /* ClassDeclaration */); + var enclosingClass = ts.getContainingClass(node); // if containing type was not found or it is ambient - exit (no codegen) if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; @@ -21650,7 +22010,7 @@ var ts; checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */); checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */); }); - if (type.flags & 1024 /* Class */ && type.symbol.valueDeclaration.kind === 204 /* ClassDeclaration */) { + if (type.flags & 1024 /* Class */ && ts.isClassLike(type.symbol.valueDeclaration)) { var classDeclaration = type.symbol.valueDeclaration; for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) { var member = _a[_i]; @@ -21739,15 +22099,17 @@ var ts; } } function checkClassExpression(node) { - grammarErrorOnNode(node, ts.Diagnostics.class_expressions_are_not_currently_supported); - ts.forEach(node.members, checkSourceElement); - return unknownType; + checkClassLikeDeclaration(node); + return getTypeOfSymbol(getSymbolOfNode(node)); } function checkClassDeclaration(node) { - // Grammar checking if (!node.name && !(node.flags & 256 /* Default */)) { grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } + checkClassLikeDeclaration(node); + ts.forEach(node.members, checkSourceElement); + } + function checkClassLikeDeclaration(node) { checkGrammarClassDeclarationHeritageClauses(node); checkDecorators(node); if (node.name) { @@ -21812,7 +22174,6 @@ var ts; } }); } - ts.forEach(node.members, checkSourceElement); if (produceDiagnostics) { checkIndexConstraints(type); checkTypeForDuplicateIndexSignatures(node); @@ -22608,8 +22969,8 @@ var ts; return checkMissingDeclaration(node); } } - // Function expression bodies are checked after all statements in the enclosing body. This is to ensure - // constructs like the following are permitted: + // Function and class expression bodies are checked after all statements in the enclosing body. This is + // to ensure constructs like the following are permitted: // let foo = function () { // let s = foo(); // return "hello"; @@ -22617,17 +22978,20 @@ var ts; // Here, performing a full type check of the body of the function expression whilst in the process of // determining the type of foo would cause foo to be given type any because of the recursive reference. // Delaying the type check of the body ensures foo has been assigned a type. - function checkFunctionExpressionBodies(node) { + function checkFunctionAndClassExpressionBodies(node) { switch (node.kind) { case 165 /* FunctionExpression */: case 166 /* ArrowFunction */: - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; + case 177 /* ClassExpression */: + ts.forEach(node.members, checkSourceElement); + break; case 136 /* MethodDeclaration */: case 135 /* MethodSignature */: - ts.forEach(node.decorators, checkFunctionExpressionBodies); - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.decorators, checkFunctionAndClassExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } @@ -22636,10 +23000,10 @@ var ts; case 138 /* GetAccessor */: case 139 /* SetAccessor */: case 203 /* FunctionDeclaration */: - ts.forEach(node.parameters, checkFunctionExpressionBodies); + ts.forEach(node.parameters, checkFunctionAndClassExpressionBodies); break; case 195 /* WithStatement */: - checkFunctionExpressionBodies(node.expression); + checkFunctionAndClassExpressionBodies(node.expression); break; case 132 /* Decorator */: case 131 /* Parameter */: @@ -22696,7 +23060,7 @@ var ts; case 229 /* EnumMember */: case 217 /* ExportAssignment */: case 230 /* SourceFile */: - ts.forEachChild(node, checkFunctionExpressionBodies); + ts.forEachChild(node, checkFunctionAndClassExpressionBodies); break; } } @@ -22721,7 +23085,7 @@ var ts; emitParam = false; potentialThisCollisions.length = 0; ts.forEach(node.statements, checkSourceElement); - checkFunctionExpressionBodies(node); + checkFunctionAndClassExpressionBodies(node); if (ts.isExternalModule(node)) { checkExternalModuleExports(node); } @@ -22796,6 +23160,11 @@ var ts; case 207 /* EnumDeclaration */: copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); break; + case 177 /* ClassExpression */: + if (location.name) { + copySymbol(location.symbol, meaning); + } + // Fall through case 204 /* ClassDeclaration */: case 205 /* InterfaceDeclaration */: if (!(memberFlags & 128 /* Static */)) { @@ -22831,41 +23200,6 @@ var ts; } } } - if (isInsideWithStatementBody(location)) { - // We cannot answer semantic questions within a with block, do not proceed any further - return []; - } - while (location) { - if (location.locals && !isGlobalSourceFile(location)) { - copySymbols(location.locals, meaning); - } - switch (location.kind) { - case 230 /* SourceFile */: - if (!ts.isExternalModule(location)) - break; - case 208 /* ModuleDeclaration */: - copySymbols(getSymbolOfNode(location).exports, meaning & 8914931 /* ModuleMember */); - break; - case 207 /* EnumDeclaration */: - copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */); - break; - case 204 /* ClassDeclaration */: - case 205 /* InterfaceDeclaration */: - if (!(memberFlags & 128 /* Static */)) { - copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */); - } - break; - case 165 /* FunctionExpression */: - if (location.name) { - copySymbol(location.symbol, meaning); - } - break; - } - memberFlags = location.flags; - location = location.parent; - } - copySymbols(globals, meaning); - return symbolsToArray(symbols); } function isTypeDeclarationName(name) { return name.kind === 65 /* Identifier */ && @@ -22967,6 +23301,9 @@ var ts; meaning |= 8388608 /* Alias */; return resolveEntityName(entityName, meaning); } + if (entityName.parent.kind === 143 /* TypePredicate */) { + return resolveEntityName(entityName, 1 /* FunctionScopedVariable */); + } // Do we want to return undefined here? return undefined; } @@ -23081,6 +23418,16 @@ var ts; } return checkExpression(expr); } + /** + * Gets either the static or instance type of a class element, based on + * whether the element is declared as "static". + */ + function getParentTypeOfClassElement(node) { + var classSymbol = getSymbolOfNode(node.parent); + return node.flags & 128 /* Static */ + ? getTypeOfSymbol(classSymbol) + : getDeclaredTypeOfSymbol(classSymbol); + } // Return the list of properties of the given type, augmented with properties from Function // if the type has call or construct signatures function getAugmentedPropertiesOfType(type) { @@ -23566,10 +23913,7 @@ var ts; globalNumberType = getGlobalType("Number"); globalBooleanType = getGlobalType("Boolean"); globalRegExpType = getGlobalType("RegExp"); - getGlobalClassDecoratorType = ts.memoize(function () { return getGlobalType("ClassDecorator"); }); - getGlobalPropertyDecoratorType = ts.memoize(function () { return getGlobalType("PropertyDecorator"); }); - getGlobalMethodDecoratorType = ts.memoize(function () { return getGlobalType("MethodDecorator"); }); - getGlobalParameterDecoratorType = ts.memoize(function () { return getGlobalType("ParameterDecorator"); }); + getGlobalTypedPropertyDescriptorType = ts.memoize(function () { return getGlobalType("TypedPropertyDescriptor", 1); }); // If we're in ES6 mode, load the TemplateStringsArray. // Otherwise, default to 'unknown' for the purposes of type checking in LS scenarios. if (languageVersion >= 2 /* ES6 */) { @@ -24132,7 +24476,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 204 /* ClassDeclaration */) { + if (ts.isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -24390,7 +24734,7 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 204 /* ClassDeclaration */) { + if (ts.isClassLike(node.parent)) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional) || checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol)) { return true; @@ -26121,6 +26465,9 @@ var ts; function generateNameForExportDefault() { return makeUniqueName("default"); } + function generateNameForClassExpression() { + return makeUniqueName("class"); + } function generateNameForNode(node) { switch (node.kind) { case 65 /* Identifier */: @@ -26133,9 +26480,10 @@ var ts; return generateNameForImportOrExportDeclaration(node); case 203 /* FunctionDeclaration */: case 204 /* ClassDeclaration */: - case 177 /* ClassExpression */: case 217 /* ExportAssignment */: return generateNameForExportDefault(); + case 177 /* ClassExpression */: + return generateNameForClassExpression(); } } function getGeneratedNameForNode(node) { @@ -37159,6 +37507,10 @@ var ts; if (actualIndentation !== -1 /* Unknown */) { return actualIndentation; } + actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options); + if (actualIndentation !== -1 /* Unknown */) { + return actualIndentation + options.IndentSize; + } previous = current; current = current.parent; } @@ -37201,6 +37553,10 @@ var ts; if (actualIndentation !== -1 /* Unknown */) { return actualIndentation + indentationDelta; } + actualIndentation = getLineIndentationWhenExpressionIsInMultiLine(current, sourceFile, options); + if (actualIndentation !== -1 /* Unknown */) { + return actualIndentation + indentationDelta; + } } // increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line if (shouldIndentChildNode(parent.kind, current.kind) && !parentAndChildShareLine) { @@ -37338,6 +37694,44 @@ var ts; return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : -1 /* Unknown */; } } + function getLineIndentationWhenExpressionIsInMultiLine(node, sourceFile, options) { + // actual indentation should not be used when: + // - node is close parenthesis - this is the end of the expression + if (node.kind === 17 /* CloseParenToken */) { + return -1 /* Unknown */; + } + if (node.parent && (node.parent.kind === 160 /* CallExpression */ || + node.parent.kind === 161 /* NewExpression */) && + node.parent.expression !== node) { + var fullCallOrNewExpression = node.parent.expression; + var startingExpression = getStartingExpression(fullCallOrNewExpression); + if (fullCallOrNewExpression === startingExpression) { + return -1 /* Unknown */; + } + var fullCallOrNewExpressionEnd = sourceFile.getLineAndCharacterOfPosition(fullCallOrNewExpression.end); + var startingExpressionEnd = sourceFile.getLineAndCharacterOfPosition(startingExpression.end); + if (fullCallOrNewExpressionEnd.line === startingExpressionEnd.line) { + return -1 /* Unknown */; + } + return findColumnForFirstNonWhitespaceCharacterInLine(fullCallOrNewExpressionEnd, sourceFile, options); + } + return -1 /* Unknown */; + function getStartingExpression(node) { + while (true) { + switch (node.kind) { + case 160 /* CallExpression */: + case 161 /* NewExpression */: + case 158 /* PropertyAccessExpression */: + case 159 /* ElementAccessExpression */: + node = node.expression; + break; + default: + return node; + } + } + return node; + } + } function deriveActualIndentationFromList(list, index, sourceFile, options) { ts.Debug.assert(index >= 0 && index < list.length); var node = list[index]; From 593005237b9e904cd00d7243dfaad22daca63c84 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 24 Jun 2015 13:10:08 -0700 Subject: [PATCH 219/309] cleaner loop --- src/compiler/checker.ts | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 63ac250c2ff..cc23103403e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10730,22 +10730,16 @@ namespace ts { }); } - // forEach(node.members, checkSourceElement); - - if(node.flags & NodeFlags.Abstract) { - forEach(node.members, checkSourceElement); - } - else { - forEach(node.members, element => { + forEach(node.members, node.flags & NodeFlags.Abstract ? + checkSourceElement : + element => { checkSourceElement(element); // Classes containing abstract methods must be marked abstract if (element.flags & NodeFlags.Abstract) { error(node, Diagnostics.Classes_containing_abstract_methods_must_be_marked_abstract); } - return undefined; }); - } if (produceDiagnostics) { checkIndexConstraints(type); From 65828c4d9f2048b5c79468af7d27c96dd20020f5 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Wed, 24 Jun 2015 13:49:59 -0700 Subject: [PATCH 220/309] Spreaded anys should satisfy all required properties --- src/compiler/checker.ts | 13 +++++++--- .../reference/tsxAttributeResolution8.js | 16 ++++++++++++ .../reference/tsxAttributeResolution8.symbols | 23 +++++++++++++++++ .../reference/tsxAttributeResolution8.types | 25 +++++++++++++++++++ .../jsx/tsxAttributeResolution8.tsx | 12 +++++++++ 5 files changed, 85 insertions(+), 4 deletions(-) create mode 100644 tests/baselines/reference/tsxAttributeResolution8.js create mode 100644 tests/baselines/reference/tsxAttributeResolution8.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution8.types create mode 100644 tests/cases/conformance/jsx/tsxAttributeResolution8.tsx diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index fe07a0eae80..dd3b29f25e3 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6830,6 +6830,7 @@ namespace ts { nameTable[prop.name] = true; } } + return type; } /// Returns the type JSX.IntrinsicElements. May return `unknownType` if that type is not present. @@ -7101,24 +7102,28 @@ namespace ts { // Process this array in right-to-left order so we know which // attributes (mostly from spreads) are being overwritten and // thus should have their types ignored + let sawSpreadedAny = false; for (let i = node.attributes.length - 1; i >= 0; i--) { if (node.attributes[i].kind === SyntaxKind.JsxAttribute) { checkJsxAttribute((node.attributes[i]), targetAttributesType, nameTable); } else { Debug.assert(node.attributes[i].kind === SyntaxKind.JsxSpreadAttribute); - checkJsxSpreadAttribute((node.attributes[i]), targetAttributesType, nameTable); + let spreadType = checkJsxSpreadAttribute((node.attributes[i]), targetAttributesType, nameTable); + if(isTypeAny(spreadType)) { + sawSpreadedAny = true; + } } } - // Check that all required properties have been provided - if (targetAttributesType) { + // Check that all required properties have been provided. If an 'any' + // was spreaded in, though, assume that it provided all required properties + if (targetAttributesType && !sawSpreadedAny) { let targetProperties = getPropertiesOfType(targetAttributesType); for (let i = 0; i < targetProperties.length; i++) { if (!(targetProperties[i].flags & SymbolFlags.Optional) && nameTable[targetProperties[i].name] === undefined) { - console.log('oops?'); error(node, Diagnostics.Property_0_is_missing_in_type_1, targetProperties[i].name, typeToString(targetAttributesType)); } } diff --git a/tests/baselines/reference/tsxAttributeResolution8.js b/tests/baselines/reference/tsxAttributeResolution8.js new file mode 100644 index 00000000000..50fff6c80fd --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution8.js @@ -0,0 +1,16 @@ +//// [tsxAttributeResolution8.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: {x: string}; + } +} + +var x: any; +// Should be OK + + +//// [tsxAttributeResolution8.jsx] +var x; +// Should be OK +; diff --git a/tests/baselines/reference/tsxAttributeResolution8.symbols b/tests/baselines/reference/tsxAttributeResolution8.symbols new file mode 100644 index 00000000000..9bb09c6cd85 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution8.symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/jsx/tsxAttributeResolution8.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxAttributeResolution8.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxAttributeResolution8.tsx, 0, 20)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxAttributeResolution8.tsx, 1, 22)) + + test1: {x: string}; +>test1 : Symbol(test1, Decl(tsxAttributeResolution8.tsx, 2, 30)) +>x : Symbol(x, Decl(tsxAttributeResolution8.tsx, 3, 10)) + } +} + +var x: any; +>x : Symbol(x, Decl(tsxAttributeResolution8.tsx, 7, 3)) + +// Should be OK + +>test1 : Symbol(JSX.IntrinsicElements.test1, Decl(tsxAttributeResolution8.tsx, 2, 30)) + diff --git a/tests/baselines/reference/tsxAttributeResolution8.types b/tests/baselines/reference/tsxAttributeResolution8.types new file mode 100644 index 00000000000..db89d6678b6 --- /dev/null +++ b/tests/baselines/reference/tsxAttributeResolution8.types @@ -0,0 +1,25 @@ +=== tests/cases/conformance/jsx/tsxAttributeResolution8.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + test1: {x: string}; +>test1 : { x: string; } +>x : string + } +} + +var x: any; +>x : any + +// Should be OK + +> : JSX.Element +>test1 : any +>x : any + diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution8.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution8.tsx new file mode 100644 index 00000000000..ac99cd15593 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxAttributeResolution8.tsx @@ -0,0 +1,12 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { + test1: {x: string}; + } +} + +var x: any; +// Should be OK + \ No newline at end of file From 02e01d7afcf03af039f2452e1b242b2aac2c39b3 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 17:13:47 -0400 Subject: [PATCH 221/309] Added tests. --- .../completionListInObjectBindingPattern10.ts | 23 +++++++++++++++++++ .../completionListInObjectBindingPattern11.ts | 13 +++++++++++ .../completionListInObjectBindingPattern12.ts | 13 +++++++++++ 3 files changed, 49 insertions(+) create mode 100644 tests/cases/fourslash/completionListInObjectBindingPattern10.ts create mode 100644 tests/cases/fourslash/completionListInObjectBindingPattern11.ts create mode 100644 tests/cases/fourslash/completionListInObjectBindingPattern12.ts diff --git a/tests/cases/fourslash/completionListInObjectBindingPattern10.ts b/tests/cases/fourslash/completionListInObjectBindingPattern10.ts new file mode 100644 index 00000000000..fcc09d1ead4 --- /dev/null +++ b/tests/cases/fourslash/completionListInObjectBindingPattern10.ts @@ -0,0 +1,23 @@ +/// + +////interface I { +//// propertyOfI_1: number; +//// propertyOfI_2: string; +////} +////interface J { +//// property1: I; +//// property2: string; +////} +//// +////var foo: J[]; +////var [{ property1: { propertyOfI_1, }, /*1*/ }, { /*2*/ }] = foo; + +goTo.marker("1"); +verify.completionListContains("property2"); +verify.not.completionListContains("property1"); +verify.not.completionListContains("propertyOfI_2"); +verify.not.completionListContains("propertyOfI_1"); + +goTo.marker("2"); +verify.completionListContains("property1"); +verify.completionListContains("property2"); \ No newline at end of file diff --git a/tests/cases/fourslash/completionListInObjectBindingPattern11.ts b/tests/cases/fourslash/completionListInObjectBindingPattern11.ts new file mode 100644 index 00000000000..25d6651a038 --- /dev/null +++ b/tests/cases/fourslash/completionListInObjectBindingPattern11.ts @@ -0,0 +1,13 @@ +/// + +////interface I { +//// property1: number; +//// property2: string; +////} +//// +////var { property1: prop1, /**/ }: I; + +goTo.marker(""); +verify.completionListContains("property2"); +verify.not.completionListContains("property1"); +verify.not.completionListContains("prop1"); \ No newline at end of file diff --git a/tests/cases/fourslash/completionListInObjectBindingPattern12.ts b/tests/cases/fourslash/completionListInObjectBindingPattern12.ts new file mode 100644 index 00000000000..f31206a21b6 --- /dev/null +++ b/tests/cases/fourslash/completionListInObjectBindingPattern12.ts @@ -0,0 +1,13 @@ +/// + +////interface I { +//// property1: number; +//// property2: string; +////} +//// +////function f({ property1, /**/ }: I): void { +////} + +goTo.marker(""); +verify.completionListContains("property2"); +verify.not.completionListContains("property1"); \ No newline at end of file From 4853fd02677ca469e7f3b206e533e93ce4f7dbca Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Wed, 24 Jun 2015 23:04:52 +0200 Subject: [PATCH 222/309] Fixed formatting spaces on protected keyword --- src/services/formatting/rules.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index abb08f5bf22..9897453e575 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -318,7 +318,7 @@ namespace ts.formatting { this.NoSpaceAfterModuleImport = new Rule(RuleDescriptor.create2(Shared.TokenRange.FromTokens([SyntaxKind.ModuleKeyword, SyntaxKind.RequireKeyword]), SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete)); // Add a space around certain TypeScript keywords - this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); + this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); this.SpaceBeforeCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.ExtendsKeyword, SyntaxKind.ImplementsKeyword])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { From 822199f40a938896f8dcbbe5402234f5194ff3a5 Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Wed, 24 Jun 2015 23:11:11 +0200 Subject: [PATCH 223/309] Added test for formatting on protected modifier --- tests/cases/fourslash/formattingOnClasses.ts | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tests/cases/fourslash/formattingOnClasses.ts b/tests/cases/fourslash/formattingOnClasses.ts index 045ee91e427..0c259dae2ec 100644 --- a/tests/cases/fourslash/formattingOnClasses.ts +++ b/tests/cases/fourslash/formattingOnClasses.ts @@ -77,7 +77,9 @@ /////*60*/ private foo ( ns : any ) { /////*61*/ return ns.toString ( ) ; /////*62*/ } -/////*63*/} +/////*63*/ protected bar ( ) { } +/////*64*/ protected static bar2 ( ) { } +/////*65*/} format.document(); goTo.marker("1"); verify.currentLineContentIs("class a {"); @@ -204,4 +206,8 @@ verify.currentLineContentIs(" return ns.toString();"); goTo.marker("62"); verify.currentLineContentIs(" }"); goTo.marker("63"); +verify.currentLineContentIs(" protected bar() { }"); +goTo.marker("64"); +verify.currentLineContentIs(" protected static bar2() { }"); +goTo.marker("65"); verify.currentLineContentIs("}"); \ No newline at end of file From 14f7dd02d714e3ee9ea92a25222c93b85078c3e0 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Wed, 24 Jun 2015 15:02:20 -0700 Subject: [PATCH 224/309] Revert changes to the parser and augment check to the emitter to handel '1..toString' case --- src/compiler/emitter.ts | 14 ++- src/compiler/parser.ts | 32 +++--- tests/baselines/reference/numLit.errors.txt | 33 +++++++ tests/baselines/reference/numLit.js | 9 +- tests/baselines/reference/numLit.symbols | 65 ------------- tests/baselines/reference/numLit.types | 97 ------------------- .../reference/toStringOnPrimitives.js | 2 +- 7 files changed, 62 insertions(+), 190 deletions(-) create mode 100644 tests/baselines/reference/numLit.errors.txt delete mode 100644 tests/baselines/reference/numLit.symbols delete mode 100644 tests/baselines/reference/numLit.types diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index b7c71c7b09a..4296884fdeb 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1783,11 +1783,21 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { emit(node.expression); let indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, node.dotToken); + + // 1 .toString is a valid property access, emit a space after the literal + let shouldEmitSpace: boolean; if (!indentedBeforeDot && node.expression.kind === SyntaxKind.NumericLiteral) { - write(" ."); // JS compat with numeric literal - } else { + let text = getSourceTextOfNodeFromSourceFile(currentSourceFile, node.expression); + shouldEmitSpace = text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0; + } + + if (shouldEmitSpace) { + write(" ."); + } + else { write("."); } + let indentedAfterDot = indentIfOnDifferentLines(node, node.dotToken, node.name); emit(node.name); decreaseIndentIf(indentedBeforeDot, indentedAfterDot); diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 14c7d6da455..fbb3dad5037 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1830,30 +1830,20 @@ namespace ts { } let tokenPos = scanner.getTokenPos(); - let nextCharCode: number; - nextToken(); finishNode(node); - if (node.kind === SyntaxKind.NumericLiteral) { - // 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 (sourceText.charCodeAt(tokenPos) === CharacterCodes._0 && isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) { - node.flags |= NodeFlags.OctalLiteral; - } - else if (token === SyntaxKind.Identifier && sourceText.charCodeAt(node.end-1) === CharacterCodes.dot) { - nextCharCode = sourceText.charCodeAt(node.end); - if (!isWhiteSpace(nextCharCode) && !isLineBreak(nextCharCode)) { - // If we see 23.Identifier, go back 1 char to scan .Identifier - node.end = node.end - 1; - scanner.setTextPos(node.end); - nextToken() - } - } + // 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))) { + + node.flags |= NodeFlags.OctalLiteral; } return node; diff --git a/tests/baselines/reference/numLit.errors.txt b/tests/baselines/reference/numLit.errors.txt new file mode 100644 index 00000000000..17392011fa6 --- /dev/null +++ b/tests/baselines/reference/numLit.errors.txt @@ -0,0 +1,33 @@ +tests/cases/compiler/numLit.ts(3,3): error TS1005: ';' expected. +tests/cases/compiler/numLit.ts(9,15): error TS1005: ',' expected. +tests/cases/compiler/numLit.ts(9,23): error TS1005: '=' expected. +tests/cases/compiler/numLit.ts(9,24): error TS1109: Expression expected. + + +==== tests/cases/compiler/numLit.ts (4 errors) ==== + 1..toString(); + 1.0.toString(); + 1.toString(); + ~~~~~~~~ +!!! error TS1005: ';' expected. + 1.+2.0 + 3. ; + + // Preserve whitespace where important for JS compatibility + var i: number = 1; + var test1 = i.toString(); + var test2 = 2.toString(); // emitted as 2 .toString() + ~~~~~~~~ +!!! error TS1005: ',' expected. + ~ +!!! error TS1005: '=' expected. + ~ +!!! error TS1109: Expression expected. + var test3 = 3 .toString(); + var test4 = 3 .toString(); + var test5 = 3 .toString(); + var test6 = 3.['toString'](); + var test7 = 3 + .toString(); + var test8 = new Number(4).toString(); + var test9 = 3. + 3. + \ No newline at end of file diff --git a/tests/baselines/reference/numLit.js b/tests/baselines/reference/numLit.js index 5620a9edcad..c68d6925faa 100644 --- a/tests/baselines/reference/numLit.js +++ b/tests/baselines/reference/numLit.js @@ -19,14 +19,15 @@ var test9 = 3. + 3. //// [numLit.js] -1. .toString(); -1.0 .toString(); -1 .toString(); +1..toString(); +1.0.toString(); +1.; +toString(); 1. + 2.0 + 3.; // Preserve whitespace where important for JS compatibility var i = 1; var test1 = i.toString(); -var test2 = 2 .toString(); // emitted as 2 .toString() +var test2 = 2., toString = (); // emitted as 2 .toString() var test3 = 3 .toString(); var test4 = 3 .toString(); var test5 = 3 .toString(); diff --git a/tests/baselines/reference/numLit.symbols b/tests/baselines/reference/numLit.symbols deleted file mode 100644 index 1f4067d233f..00000000000 --- a/tests/baselines/reference/numLit.symbols +++ /dev/null @@ -1,65 +0,0 @@ -=== tests/cases/compiler/numLit.ts === -1..toString(); ->1..toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -1.0.toString(); ->1.0.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -1.toString(); ->1.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -1.+2.0 + 3. ; - -// Preserve whitespace where important for JS compatibility -var i: number = 1; ->i : Symbol(i, Decl(numLit.ts, 6, 3)) - -var test1 = i.toString(); ->test1 : Symbol(test1, Decl(numLit.ts, 7, 3)) ->i.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->i : Symbol(i, Decl(numLit.ts, 6, 3)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -var test2 = 2.toString(); // emitted as 2 .toString() ->test2 : Symbol(test2, Decl(numLit.ts, 8, 3)) ->2.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -var test3 = 3 .toString(); ->test3 : Symbol(test3, Decl(numLit.ts, 9, 3)) ->3 .toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -var test4 = 3 .toString(); ->test4 : Symbol(test4, Decl(numLit.ts, 10, 3)) ->3 .toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -var test5 = 3 .toString(); ->test5 : Symbol(test5, Decl(numLit.ts, 11, 3)) ->3 .toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -var test6 = 3.['toString'](); ->test6 : Symbol(test6, Decl(numLit.ts, 12, 3)) ->'toString' : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -var test7 = 3 ->test7 : Symbol(test7, Decl(numLit.ts, 13, 3)) ->3.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -.toString(); ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -var test8 = new Number(4).toString(); ->test8 : Symbol(test8, Decl(numLit.ts, 15, 3)) ->new Number(4).toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) - -var test9 = 3. + 3. ->test9 : Symbol(test9, Decl(numLit.ts, 16, 3)) - diff --git a/tests/baselines/reference/numLit.types b/tests/baselines/reference/numLit.types deleted file mode 100644 index ba72abb2825..00000000000 --- a/tests/baselines/reference/numLit.types +++ /dev/null @@ -1,97 +0,0 @@ -=== tests/cases/compiler/numLit.ts === -1..toString(); ->1..toString() : string ->1..toString : (radix?: number) => string ->1. : number ->toString : (radix?: number) => string - -1.0.toString(); ->1.0.toString() : string ->1.0.toString : (radix?: number) => string ->1.0 : number ->toString : (radix?: number) => string - -1.toString(); ->1.toString() : string ->1.toString : (radix?: number) => string ->1 : number ->toString : (radix?: number) => string - -1.+2.0 + 3. ; ->1.+2.0 + 3. : number ->1.+2.0 : number ->1. : number ->2.0 : number ->3. : number - -// Preserve whitespace where important for JS compatibility -var i: number = 1; ->i : number ->1 : number - -var test1 = i.toString(); ->test1 : string ->i.toString() : string ->i.toString : (radix?: number) => string ->i : number ->toString : (radix?: number) => string - -var test2 = 2.toString(); // emitted as 2 .toString() ->test2 : string ->2.toString() : string ->2.toString : (radix?: number) => string ->2 : number ->toString : (radix?: number) => string - -var test3 = 3 .toString(); ->test3 : string ->3 .toString() : string ->3 .toString : (radix?: number) => string ->3 : number ->toString : (radix?: number) => string - -var test4 = 3 .toString(); ->test4 : string ->3 .toString() : string ->3 .toString : (radix?: number) => string ->3 : number ->toString : (radix?: number) => string - -var test5 = 3 .toString(); ->test5 : string ->3 .toString() : string ->3 .toString : (radix?: number) => string ->3 : number ->toString : (radix?: number) => string - -var test6 = 3.['toString'](); ->test6 : string ->3.['toString']() : string ->3.['toString'] : (radix?: number) => string ->3. : number ->'toString' : string - -var test7 = 3 ->test7 : string ->3.toString() : string ->3.toString : (radix?: number) => string ->3 : number - -.toString(); ->toString : (radix?: number) => string - -var test8 = new Number(4).toString(); ->test8 : string ->new Number(4).toString() : string ->new Number(4).toString : (radix?: number) => string ->new Number(4) : Number ->Number : NumberConstructor ->4 : number ->toString : (radix?: number) => string - -var test9 = 3. + 3. ->test9 : number ->3. + 3. : number ->3. : number ->3. : number - diff --git a/tests/baselines/reference/toStringOnPrimitives.js b/tests/baselines/reference/toStringOnPrimitives.js index 007bb5429b0..bce8a997ba7 100644 --- a/tests/baselines/reference/toStringOnPrimitives.js +++ b/tests/baselines/reference/toStringOnPrimitives.js @@ -8,4 +8,4 @@ aBool.toString(); true.toString(); var aBool = false; aBool.toString(); -1. .toString(); +1..toString(); From e52a27b3de5f003de74f4d245bed7fabbc26d7f5 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 24 Jun 2015 18:07:49 -0400 Subject: [PATCH 225/309] Renamed function. --- src/services/services.ts | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 25949082e8d..f4e37bf56ea 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -2985,7 +2985,7 @@ namespace ts { } function tryGetGlobalSymbols(): boolean { - let objectLikeContainer = getContainingObjectLiteralOrBindingPatternIfApplicableForCompletion(contextToken); + let objectLikeContainer = tryGetObjectLikeCompletionContainer(contextToken); if (objectLikeContainer) { // Object literal expression, look up possible property names from contextual type isMemberCompletion = true; @@ -3198,9 +3198,11 @@ namespace ts { return false; } - function getContainingObjectLiteralOrBindingPatternIfApplicableForCompletion(contextToken: Node): ObjectLiteralExpression | BindingPattern { - // The locations in an object literal expression that - // are applicable for completion are property name definition locations. + /** + * Returns the immediate owning object literal or binding pattern of a context token, + * on the condition that one exists and that the context implies completion should be given. + */ + function tryGetObjectLikeCompletionContainer(contextToken: Node): ObjectLiteralExpression | BindingPattern { if (contextToken) { switch (contextToken.kind) { case SyntaxKind.OpenBraceToken: // let x = { | From 2a483187a7a6f9073ac928ca4cde8609a0ee8040 Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 25 Jun 2015 00:23:13 +0200 Subject: [PATCH 226/309] Remove unused variables --- src/compiler/checker.ts | 6 ++---- src/compiler/declarationEmitter.ts | 1 - src/compiler/parser.ts | 1 - src/compiler/program.ts | 1 - src/compiler/utilities.ts | 1 - src/services/services.ts | 2 -- 6 files changed, 2 insertions(+), 10 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 609a154ded1..49a61a2fd08 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3518,7 +3518,6 @@ namespace ts { let syntaxKind = kind === IndexKind.Number ? SyntaxKind.NumberKeyword : SyntaxKind.StringKeyword; let indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { - let len = indexSymbol.declarations.length; for (let decl of indexSymbol.declarations) { let node = decl; if (node.parameters.length === 1) { @@ -8374,12 +8373,12 @@ namespace ts { } function checkTypeOfExpression(node: TypeOfExpression): Type { - let operandType = checkExpression(node.expression); + checkExpression(node.expression); return stringType; } function checkVoidExpression(node: VoidExpression): Type { - let operandType = checkExpression(node.expression); + checkExpression(node.expression); return undefinedType; } @@ -12380,7 +12379,6 @@ namespace ts { case SyntaxKind.StringLiteral: // External module name in an import declaration - let moduleName: Expression; if ((isExternalModuleImportEqualsDeclaration(node.parent.parent) && getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) || ((node.parent.kind === SyntaxKind.ImportDeclaration || node.parent.kind === SyntaxKind.ExportDeclaration) && diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index 2ba88f1ac29..54d0d6ff854 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -40,7 +40,6 @@ namespace ts { function emitDeclarations(host: EmitHost, resolver: EmitResolver, diagnostics: Diagnostic[], jsFilePath: string, root?: SourceFile): DeclarationEmit { let newLine = host.getNewLine(); let compilerOptions = host.getCompilerOptions(); - let languageVersion = compilerOptions.target || ScriptTarget.ES3; let write: (s: string) => void; let writeLine: () => void; diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index fbb3dad5037..2c496b8c60d 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -5363,7 +5363,6 @@ namespace ts { let atToken = createNode(SyntaxKind.AtToken, pos - 1); atToken.end = pos; - let startPos = pos; let tagName = scanIdentifier(); if (!tagName) { return; diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 2af9ad9987d..09bd6fbdd28 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -337,7 +337,6 @@ namespace ts { function processSourceFile(fileName: string, isDefaultLib: boolean, refFile?: SourceFile, refPos?: number, refEnd?: number) { let start: number; let length: number; - let extensions: string; let diagnosticArgument: string[]; if (refEnd !== undefined && refPos !== undefined) { start = refPos; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 8162625c25f..ce166aa2f36 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1957,7 +1957,6 @@ namespace ts { function getExpandedCharCodes(input: string): number[] { let output: number[] = []; let length = input.length; - let leadSurrogate: number = undefined; for (let i = 0; i < length; i++) { let charCode = input.charCodeAt(i); diff --git a/src/services/services.ts b/src/services/services.ts index 18510b9a178..077a46a7461 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -95,7 +95,6 @@ namespace ts { export module ScriptSnapshot { class StringScriptSnapshot implements IScriptSnapshot { - private _lineStartPositions: number[] = undefined; constructor(private text: string) { } @@ -2910,7 +2909,6 @@ namespace ts { } let location = getTouchingPropertyName(sourceFile, position); - var target = program.getCompilerOptions().target; let semanticStart = new Date().getTime(); let isMemberCompletion: boolean; From 643832dab5cbf4c11241d541f1352918a3e91816 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 24 Jun 2015 16:46:32 -0700 Subject: [PATCH 227/309] Implement intersection types --- src/compiler/checker.ts | 330 +++++++++++++++++++---------- src/compiler/declarationEmitter.ts | 6 + src/compiler/parser.ts | 23 +- src/compiler/types.ts | 40 ++-- src/services/services.ts | 4 +- 5 files changed, 264 insertions(+), 139 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index a18f2921a9a..109ad1cf29f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -125,6 +125,7 @@ namespace ts { let tupleTypes: Map = {}; let unionTypes: Map = {}; + let intersectionTypes: Map = {}; let stringLiteralTypes: Map = {}; let emitExtends = false; let emitDecorate = false; @@ -1538,8 +1539,8 @@ namespace ts { else if (type.flags & TypeFlags.Tuple) { writeTupleType(type); } - else if (type.flags & TypeFlags.Union) { - writeUnionType(type, flags); + else if (type.flags & (TypeFlags.Union | TypeFlags.Intersection)) { + writeUnionOrIntersectionType(type, flags); } else if (type.flags & TypeFlags.Anonymous) { writeAnonymousType(type, flags); @@ -1558,16 +1559,16 @@ namespace ts { } } - function writeTypeList(types: Type[], union: boolean) { + function writeTypeList(types: Type[], delimiter: SyntaxKind) { for (let i = 0; i < types.length; i++) { if (i > 0) { - if (union) { + if (delimiter !== SyntaxKind.CommaToken) { writeSpace(writer); } - writePunctuation(writer, union ? SyntaxKind.BarToken : SyntaxKind.CommaToken); + writePunctuation(writer, delimiter); writeSpace(writer); } - writeType(types[i], union ? TypeFormatFlags.InElementType : TypeFormatFlags.None); + writeType(types[i], delimiter === SyntaxKind.CommaToken ? TypeFormatFlags.None : TypeFormatFlags.InElementType); } } @@ -1625,15 +1626,15 @@ namespace ts { function writeTupleType(type: TupleType) { writePunctuation(writer, SyntaxKind.OpenBracketToken); - writeTypeList(type.elementTypes, /*union*/ false); + writeTypeList(type.elementTypes, SyntaxKind.CommaToken); writePunctuation(writer, SyntaxKind.CloseBracketToken); } - function writeUnionType(type: UnionType, flags: TypeFormatFlags) { + function writeUnionOrIntersectionType(type: UnionOrIntersectionType, flags: TypeFormatFlags) { if (flags & TypeFormatFlags.InElementType) { writePunctuation(writer, SyntaxKind.OpenParenToken); } - writeTypeList(type.types, /*union*/ true); + writeTypeList(type.types, type.flags & TypeFlags.Union ? SyntaxKind.BarToken : SyntaxKind.AmpersandToken); if (flags & TypeFormatFlags.InElementType) { writePunctuation(writer, SyntaxKind.CloseParenToken); } @@ -1710,7 +1711,7 @@ namespace ts { } function writeLiteralType(type: ObjectType, flags: TypeFormatFlags) { - let resolved = resolveObjectOrUnionTypeMembers(type); + let resolved = resolveStructuredTypeMembers(type); if (!resolved.properties.length && !resolved.stringIndexType && !resolved.numberIndexType) { if (!resolved.callSignatures.length && !resolved.constructSignatures.length) { writePunctuation(writer, SyntaxKind.OpenBraceToken); @@ -2045,6 +2046,7 @@ namespace ts { case SyntaxKind.ArrayType: case SyntaxKind.TupleType: case SyntaxKind.UnionType: + case SyntaxKind.IntersectionType: case SyntaxKind.ParenthesizedType: return isDeclarationVisible(node.parent); @@ -2666,7 +2668,7 @@ namespace ts { if (baseConstructorType.flags & TypeFlags.ObjectType) { // Resolving the members of a class requires us to resolve the base class of that class. // We force resolution here such that we catch circularities now. - resolveObjectOrUnionTypeMembers(baseConstructorType); + resolveStructuredTypeMembers(baseConstructorType); } if (!popTypeResolution()) { error(type.symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol)); @@ -2996,7 +2998,7 @@ namespace ts { } function resolveTupleTypeMembers(type: TupleType) { - let arrayType = resolveObjectOrUnionTypeMembers(createArrayType(getUnionType(type.elementTypes))); + let arrayType = resolveStructuredTypeMembers(createArrayType(getUnionType(type.elementTypes))); let members = createTupleTypeMemberSymbols(type.elementTypes); addInheritedMembers(members, arrayType.properties); setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType); @@ -3062,6 +3064,26 @@ namespace ts { setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexType, numberIndexType); } + function intersectTypes(type1: Type, type2: Type): Type { + return !type1 ? type2 : !type2 ? type1 : getIntersectionType([type1, type2]); + } + + function resolveIntersectionTypeMembers(type: IntersectionType) { + // The members and properties collections are empty for intersection types. To get all properties of an + // intersection type use getPropertiesOfType (only the language service uses this). + let callSignatures: Signature[] = emptyArray; + let constructSignatures: Signature[] = emptyArray; + let stringIndexType: Type = undefined; + let numberIndexType: Type = undefined; + for (let t of type.types) { + callSignatures = concatenate(callSignatures, getSignaturesOfType(t, SignatureKind.Call)); + constructSignatures = concatenate(constructSignatures, getSignaturesOfType(t, SignatureKind.Construct)); + stringIndexType = intersectTypes(stringIndexType, getIndexTypeOfType(t, IndexKind.String)); + numberIndexType = intersectTypes(numberIndexType, getIndexTypeOfType(t, IndexKind.Number)); + } + setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexType, numberIndexType); + } + function resolveAnonymousTypeMembers(type: ObjectType) { let symbol = type.symbol; let members: SymbolTable; @@ -3106,7 +3128,7 @@ namespace ts { setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } - function resolveObjectOrUnionTypeMembers(type: ObjectType): ResolvedType { + function resolveStructuredTypeMembers(type: ObjectType): ResolvedType { if (!(type).members) { if (type.flags & (TypeFlags.Class | TypeFlags.Interface)) { resolveClassOrInterfaceMembers(type); @@ -3120,6 +3142,9 @@ namespace ts { else if (type.flags & TypeFlags.Union) { resolveUnionTypeMembers(type); } + else if (type.flags & TypeFlags.Intersection) { + resolveIntersectionTypeMembers(type); + } else { resolveTypeReferenceMembers(type); } @@ -3130,7 +3155,7 @@ namespace ts { // Return properties of an object type or an empty array for other types function getPropertiesOfObjectType(type: Type): Symbol[] { if (type.flags & TypeFlags.ObjectType) { - return resolveObjectOrUnionTypeMembers(type).properties; + return resolveStructuredTypeMembers(type).properties; } return emptyArray; } @@ -3139,7 +3164,7 @@ namespace ts { // the symbol for that property. Otherwise return undefined. function getPropertyOfObjectType(type: Type, name: string): Symbol { if (type.flags & TypeFlags.ObjectType) { - let resolved = resolveObjectOrUnionTypeMembers(type); + let resolved = resolveStructuredTypeMembers(type); if (hasProperty(resolved.members, name)) { let symbol = resolved.members[name]; if (symbolIsValue(symbol)) { @@ -3149,20 +3174,23 @@ namespace ts { } } - function getPropertiesOfUnionType(type: UnionType): Symbol[] { - let result: Symbol[] = []; - forEach(getPropertiesOfType(type.types[0]), prop => { - let unionProp = getPropertyOfUnionType(type, prop.name); - if (unionProp) { - result.push(unionProp); + function getPropertiesOfUnionOrIntersectionType(type: UnionOrIntersectionType): Symbol[] { + for (let current of type.types) { + for (let prop of getPropertiesOfType(current)) { + getPropertyOfUnionOrIntersectionType(type, prop.name); } - }); - return result; + // The properties of a union type are those that are present in all constituent types, so + // we only need to check the properties of the first type + if (type.flags & TypeFlags.Union) { + break; + } + } + return type.resolvedProperties ? symbolsToArray(type.resolvedProperties) : emptyArray; } function getPropertiesOfType(type: Type): Symbol[] { type = getApparentType(type); - return type.flags & TypeFlags.Union ? getPropertiesOfUnionType(type) : getPropertiesOfObjectType(type); + return type.flags & TypeFlags.UnionOrIntersection ? getPropertiesOfUnionOrIntersectionType(type) : getPropertiesOfObjectType(type); } // For a type parameter, return the base constraint of the type parameter. For the string, number, @@ -3195,24 +3223,33 @@ namespace ts { return type; } - function createUnionProperty(unionType: UnionType, name: string): Symbol { - let types = unionType.types; + function createUnionOrIntersectionProperty(containingType: UnionOrIntersectionType, name: string): Symbol { + let types = containingType.types; let props: Symbol[]; for (let current of types) { let type = getApparentType(current); if (type !== unknownType) { let prop = getPropertyOfType(type, name); - if (!prop || getDeclarationFlagsFromSymbol(prop) & (NodeFlags.Private | NodeFlags.Protected)) { + if (prop && !(getDeclarationFlagsFromSymbol(prop) & (NodeFlags.Private | NodeFlags.Protected))) { + if (!props) { + props = [prop]; + } + else if (!contains(props, prop)) { + props.push(prop); + } + } + else if (containingType.flags & TypeFlags.Union) { + // A union type requires the property to be present in all constituent types return undefined; } - if (!props) { - props = [prop]; - } - else { - props.push(prop); - } } } + if (!props) { + return undefined; + } + if (props.length === 1) { + return props[0]; + } let propTypes: Type[] = []; let declarations: Declaration[] = []; for (let prop of props) { @@ -3221,19 +3258,19 @@ namespace ts { } propTypes.push(getTypeOfSymbol(prop)); } - let result = createSymbol(SymbolFlags.Property | SymbolFlags.Transient | SymbolFlags.UnionProperty, name); - result.unionType = unionType; + let result = createSymbol(SymbolFlags.Property | SymbolFlags.Transient | SymbolFlags.SyntheticProperty, name); + result.containingType = containingType; result.declarations = declarations; - result.type = getUnionType(propTypes); + result.type = containingType.flags & TypeFlags.Union ? getUnionType(propTypes) : getIntersectionType(propTypes); return result; } - function getPropertyOfUnionType(type: UnionType, name: string): Symbol { + function getPropertyOfUnionOrIntersectionType(type: UnionOrIntersectionType, name: string): Symbol { let properties = type.resolvedProperties || (type.resolvedProperties = {}); if (hasProperty(properties, name)) { return properties[name]; } - let property = createUnionProperty(type, name); + let property = createUnionOrIntersectionProperty(type, name); if (property) { properties[name] = property; } @@ -3246,7 +3283,7 @@ namespace ts { function getPropertyOfType(type: Type, name: string): Symbol { type = getApparentType(type); if (type.flags & TypeFlags.ObjectType) { - let resolved = resolveObjectOrUnionTypeMembers(type); + let resolved = resolveStructuredTypeMembers(type); if (hasProperty(resolved.members, name)) { let symbol = resolved.members[name]; if (symbolIsValue(symbol)) { @@ -3261,15 +3298,15 @@ namespace ts { } return getPropertyOfObjectType(globalObjectType, name); } - if (type.flags & TypeFlags.Union) { - return getPropertyOfUnionType(type, name); + if (type.flags & TypeFlags.UnionOrIntersection) { + return getPropertyOfUnionOrIntersectionType(type, name); } return undefined; } - function getSignaturesOfObjectOrUnionType(type: Type, kind: SignatureKind): Signature[] { - if (type.flags & (TypeFlags.ObjectType | TypeFlags.Union)) { - let resolved = resolveObjectOrUnionTypeMembers(type); + function getSignaturesOfStructuredType(type: Type, kind: SignatureKind): Signature[] { + if (type.flags & TypeFlags.StructuredType) { + let resolved = resolveStructuredTypeMembers(type); return kind === SignatureKind.Call ? resolved.callSignatures : resolved.constructSignatures; } return emptyArray; @@ -3278,22 +3315,21 @@ namespace ts { // Return the signatures of the given kind in the given type. Creates synthetic union signatures when necessary and // maps primitive types and type parameters are to their apparent types. function getSignaturesOfType(type: Type, kind: SignatureKind): Signature[] { - return getSignaturesOfObjectOrUnionType(getApparentType(type), kind); + return getSignaturesOfStructuredType(getApparentType(type), kind); } function typeHasCallOrConstructSignatures(type: Type): boolean { let apparentType = getApparentType(type); - if (apparentType.flags & (TypeFlags.ObjectType | TypeFlags.Union)) { - let resolved = resolveObjectOrUnionTypeMembers(type); - return resolved.callSignatures.length > 0 - || resolved.constructSignatures.length > 0; + if (apparentType.flags & TypeFlags.StructuredType) { + let resolved = resolveStructuredTypeMembers(type); + return resolved.callSignatures.length > 0 || resolved.constructSignatures.length > 0; } return false; } - function getIndexTypeOfObjectOrUnionType(type: Type, kind: IndexKind): Type { - if (type.flags & (TypeFlags.ObjectType | TypeFlags.Union)) { - let resolved = resolveObjectOrUnionTypeMembers(type); + function getIndexTypeOfStructuredType(type: Type, kind: IndexKind): Type { + if (type.flags & TypeFlags.StructuredType) { + let resolved = resolveStructuredTypeMembers(type); return kind === IndexKind.String ? resolved.stringIndexType : resolved.numberIndexType; } } @@ -3301,7 +3337,7 @@ namespace ts { // Return the index type of the given kind in the given type. Creates synthetic union index types when necessary and // maps primitive types and type parameters are to their apparent types. function getIndexTypeOfType(type: Type, kind: IndexKind): Type { - return getIndexTypeOfObjectOrUnionType(getApparentType(type), kind); + return getIndexTypeOfStructuredType(getApparentType(type), kind); } // Return list of type parameters with duplicates removed (duplicate identifier errors are generated in the actual @@ -3828,9 +3864,9 @@ namespace ts { return links.resolvedType; } - function addTypeToSortedSet(sortedSet: Type[], type: Type) { - if (type.flags & TypeFlags.Union) { - addTypesToSortedSet(sortedSet, (type).types); + function addTypeToSortedSet(sortedSet: Type[], type: Type, typeKind: TypeFlags) { + if (type.flags & typeKind) { + addTypesToSortedSet(sortedSet, (type).types, typeKind); } else { let i = 0; @@ -3844,9 +3880,9 @@ namespace ts { } } - function addTypesToSortedSet(sortedTypes: Type[], types: Type[]) { + function addTypesToSortedSet(sortedTypes: Type[], types: Type[], typeKind: TypeFlags) { for (let type of types) { - addTypeToSortedSet(sortedTypes, type); + addTypeToSortedSet(sortedTypes, type, typeKind); } } @@ -3897,7 +3933,7 @@ namespace ts { return emptyObjectType; } let sortedTypes: Type[] = []; - addTypesToSortedSet(sortedTypes, types); + addTypesToSortedSet(sortedTypes, types, TypeFlags.Union); if (noSubtypeReduction) { if (containsTypeAny(sortedTypes)) { return anyType; @@ -3947,6 +3983,35 @@ namespace ts { return links.resolvedType; } + // We do not perform supertype reduction on intersection types. Intersection types are created only by the & + // type operator and we can't reduce those because we want to support recursive intersection types. For example, + // a type alias of the form "type List = T & { next: List }" cannot be reduced during its declaration. + function getIntersectionType(types: Type[]): Type { + let sortedTypes: Type[] = []; + addTypesToSortedSet(sortedTypes, types, TypeFlags.Intersection); + if (containsTypeAny(sortedTypes)) { + return anyType; + } + if (sortedTypes.length === 1) { + return sortedTypes[0]; + } + let id = getTypeListId(sortedTypes); + let type = intersectionTypes[id]; + if (!type) { + type = intersectionTypes[id] = createObjectType(TypeFlags.Intersection | getWideningFlagsOfTypes(sortedTypes)); + type.types = sortedTypes; + } + return type; + } + + function getTypeFromIntersectionTypeNode(node: IntersectionTypeNode): Type { + let links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getIntersectionType(map(node.types, getTypeFromTypeNode)); + } + return links.resolvedType; + } + function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node: Node): Type { let links = getNodeLinks(node); if (!links.resolvedType) { @@ -4004,6 +4069,8 @@ namespace ts { return getTypeFromTupleTypeNode(node); case SyntaxKind.UnionType: return getTypeFromUnionTypeNode(node); + case SyntaxKind.IntersectionType: + return getTypeFromIntersectionTypeNode(node); case SyntaxKind.ParenthesizedType: return getTypeFromTypeNode((node).type); case SyntaxKind.FunctionType: @@ -4191,6 +4258,9 @@ namespace ts { if (type.flags & TypeFlags.Union) { return getUnionType(instantiateList((type).types, mapper, instantiateType), /*noSubtypeReduction*/ true); } + if (type.flags & TypeFlags.Intersection) { + return getIntersectionType(instantiateList((type).types, mapper, instantiateType)); + } } return type; } @@ -4231,7 +4301,7 @@ namespace ts { function getTypeWithoutSignatures(type: Type): Type { if (type.flags & TypeFlags.ObjectType) { - let resolved = resolveObjectOrUnionTypeMembers(type); + let resolved = resolveStructuredTypeMembers(type); if (resolved.constructSignatures.length) { let result = createObjectType(TypeFlags.Anonymous, type.symbol); result.members = resolved.members; @@ -4341,37 +4411,10 @@ namespace ts { } } let saveErrorInfo = errorInfo; - if (source.flags & TypeFlags.Union || target.flags & TypeFlags.Union) { - if (relation === identityRelation) { - if (source.flags & TypeFlags.Union && target.flags & TypeFlags.Union) { - if (result = unionTypeRelatedToUnionType(source, target)) { - if (result &= unionTypeRelatedToUnionType(target, source)) { - return result; - } - } - } - else if (source.flags & TypeFlags.Union) { - if (result = unionTypeRelatedToType(source, target, reportErrors)) { - return result; - } - } - else { - if (result = unionTypeRelatedToType(target, source, reportErrors)) { - return result; - } - } - } - else { - if (source.flags & TypeFlags.Union) { - if (result = unionTypeRelatedToType(source, target, reportErrors)) { - return result; - } - } - else { - if (result = typeRelatedToUnionType(source, target, reportErrors)) { - return result; - } - } + if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (source).target === (target).target) { + // We have type references to same target type, see if relationship holds for all type arguments + if (result = typesRelatedTo((source).typeArguments, (target).typeArguments, reportErrors)) { + return result; } } else if (source.flags & TypeFlags.TypeParameter && target.flags & TypeFlags.TypeParameter) { @@ -4379,10 +4422,39 @@ namespace ts { return result; } } - else if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (source).target === (target).target) { - // We have type references to same target type, see if relationship holds for all type arguments - if (result = typesRelatedTo((source).typeArguments, (target).typeArguments, reportErrors)) { - return result; + else if (relation !== identityRelation) { + if (source.flags & TypeFlags.Union) { + if (result = eachTypeRelatedToType(source, target, reportErrors)) { + return result; + } + } + else if (target.flags & TypeFlags.Intersection) { + if (result = typeRelatedToEachType(source, target, reportErrors)) { + return result; + } + } + else { + if (source.flags & TypeFlags.Intersection) { + // If target is a union type the following check will report errors so we suppress them here + if (result = someTypeRelatedToType(source, target, reportErrors && !(target.flags & TypeFlags.Union))) { + return result; + } + } + if (target.flags & TypeFlags.Union) { + if (result = typeRelatedToSomeType(source, target, reportErrors)) { + return result; + } + } + } + } + else { + if (source.flags & TypeFlags.Union && target.flags & TypeFlags.Union || + source.flags & TypeFlags.Intersection && target.flags & TypeFlags.Intersection) { + if (result = eachTypeRelatedToSomeType(source, target)) { + if (result &= eachTypeRelatedToSomeType(target, source)) { + return result; + } + } } } @@ -4398,9 +4470,9 @@ namespace ts { return result; } } - else if (source.flags & TypeFlags.TypeParameter && sourceOrApparentType.flags & TypeFlags.Union) { + else if (source.flags & TypeFlags.TypeParameter && sourceOrApparentType.flags & TypeFlags.UnionOrIntersection) { // We clear the errors first because the following check often gives a better error than - // the union comparison above if it is applicable. + // the union or intersection comparison above if it is applicable. errorInfo = saveErrorInfo; if (result = isRelatedTo(sourceOrApparentType, target, reportErrors)) { return result; @@ -4420,11 +4492,11 @@ namespace ts { return Ternary.False; } - function unionTypeRelatedToUnionType(source: UnionType, target: UnionType): Ternary { + function eachTypeRelatedToSomeType(source: UnionOrIntersectionType, target: UnionOrIntersectionType): Ternary { let result = Ternary.True; let sourceTypes = source.types; for (let sourceType of sourceTypes) { - let related = typeRelatedToUnionType(sourceType, target, false); + let related = typeRelatedToSomeType(sourceType, target, false); if (!related) { return Ternary.False; } @@ -4433,7 +4505,7 @@ namespace ts { return result; } - function typeRelatedToUnionType(source: Type, target: UnionType, reportErrors: boolean): Ternary { + function typeRelatedToSomeType(source: Type, target: UnionOrIntersectionType, reportErrors: boolean): Ternary { let targetTypes = target.types; for (let i = 0, len = targetTypes.length; i < len; i++) { let related = isRelatedTo(source, targetTypes[i], reportErrors && i === len - 1); @@ -4444,7 +4516,31 @@ namespace ts { return Ternary.False; } - function unionTypeRelatedToType(source: UnionType, target: Type, reportErrors: boolean): Ternary { + function typeRelatedToEachType(source: Type, target: UnionOrIntersectionType, reportErrors: boolean): Ternary { + let result = Ternary.True; + let targetTypes = target.types; + for (let targetType of targetTypes) { + let related = isRelatedTo(source, targetType, reportErrors); + if (!related) { + return Ternary.False; + } + result &= related; + } + return result; + } + + function someTypeRelatedToType(source: UnionOrIntersectionType, target: Type, reportErrors: boolean): Ternary { + let sourceTypes = source.types; + for (let i = 0, len = sourceTypes.length; i < len; i++) { + let related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1); + if (related) { + return related; + } + } + return Ternary.False; + } + + function eachTypeRelatedToType(source: UnionOrIntersectionType, target: Type, reportErrors: boolean): Ternary { let result = Ternary.True; let sourceTypes = source.types; for (let sourceType of sourceTypes) { @@ -5284,9 +5380,9 @@ namespace ts { inferiority--; } } - else if (source.flags & TypeFlags.Union) { - // Source is a union type, infer from each consituent type - let sourceTypes = (source).types; + else if (source.flags & TypeFlags.UnionOrIntersection) { + // Source is a union or intersection type, infer from each consituent type + let sourceTypes = (source).types; for (let sourceType of sourceTypes) { inferFromTypes(sourceType, target); } @@ -6245,7 +6341,7 @@ namespace ts { } function getIndexTypeOfContextualType(type: Type, kind: IndexKind) { - return applyToContextualType(type, t => getIndexTypeOfObjectOrUnionType(t, kind)); + return applyToContextualType(type, t => getIndexTypeOfStructuredType(t, kind)); } // Return true if the given contextual type is a tuple-like type @@ -6255,7 +6351,7 @@ namespace ts { // Return true if the given contextual type provides an index signature of the given kind function contextualTypeHasIndexSignature(type: Type, kind: IndexKind): boolean { - return !!(type.flags & TypeFlags.Union ? forEach((type).types, t => getIndexTypeOfObjectOrUnionType(t, kind)) : getIndexTypeOfObjectOrUnionType(type, kind)); + return !!(type.flags & TypeFlags.Union ? forEach((type).types, t => getIndexTypeOfStructuredType(t, kind)) : getIndexTypeOfStructuredType(type, kind)); } // In an object literal contextually typed by a type T, the contextual type of a property assignment is the type of @@ -6363,7 +6459,7 @@ namespace ts { // If the given type is an object or union type, if that type has a single signature, and if // that signature is non-generic, return the signature. Otherwise return undefined. function getNonGenericSignature(type: Type): Signature { - let signatures = getSignaturesOfObjectOrUnionType(type, SignatureKind.Call); + let signatures = getSignaturesOfStructuredType(type, SignatureKind.Call); if (signatures.length === 1) { let signature = signatures[0]; if (!signature.typeParameters) { @@ -6405,7 +6501,7 @@ namespace ts { // The signature set of all constituent type with call signatures should match // So number of signatures allowed is either 0 or 1 if (signatureList && - getSignaturesOfObjectOrUnionType(current, SignatureKind.Call).length > 1) { + getSignaturesOfStructuredType(current, SignatureKind.Call).length > 1) { return undefined; } @@ -7081,7 +7177,7 @@ namespace ts { // If type has a single call signature and no other members, return that signature. Otherwise, return undefined. function getSingleCallSignature(type: Type): Signature { if (type.flags & TypeFlags.ObjectType) { - let resolved = resolveObjectOrUnionTypeMembers(type); + let resolved = resolveStructuredTypeMembers(type); if (resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0 && resolved.properties.length === 0 && !resolved.stringIndexType && !resolved.numberIndexType) { return resolved.callSignatures[0]; @@ -8028,7 +8124,7 @@ namespace ts { if (type.flags & kind) { return true; } - if (type.flags & TypeFlags.Union) { + if (type.flags & TypeFlags.UnionOrIntersection) { let types = (type).types; for (let current of types) { if (current.flags & kind) { @@ -8040,12 +8136,12 @@ namespace ts { return false; } - // Return true if type has the given flags, or is a union type composed of types that all have those flags. + // Return true if type has the given flags, or is a union or intersection type composed of types that all have those flags. function allConstituentTypesHaveKind(type: Type, kind: TypeFlags): boolean { if (type.flags & kind) { return true; } - if (type.flags & TypeFlags.Union) { + if (type.flags & TypeFlags.UnionOrIntersection) { let types = (type).types; for (let current of types) { if (!(current.flags & kind)) { @@ -9048,7 +9144,7 @@ namespace ts { forEach(node.elementTypes, checkSourceElement); } - function checkUnionType(node: UnionTypeNode) { + function checkUnionOrIntersectionType(node: UnionOrIntersectionTypeNode) { forEach(node.types, checkSourceElement); } @@ -11464,7 +11560,8 @@ namespace ts { case SyntaxKind.TupleType: return checkTupleType(node); case SyntaxKind.UnionType: - return checkUnionType(node); + case SyntaxKind.IntersectionType: + return checkUnionOrIntersectionType(node); case SyntaxKind.ParenthesizedType: return checkSourceElement((node).type); case SyntaxKind.FunctionDeclaration: @@ -12092,10 +12189,10 @@ namespace ts { } function getRootSymbols(symbol: Symbol): Symbol[] { - if (symbol.flags & SymbolFlags.UnionProperty) { + if (symbol.flags & SymbolFlags.SyntheticProperty) { let symbols: Symbol[] = []; let name = symbol.name; - forEach(getSymbolLinks(symbol).unionType.types, t => { + forEach(getSymbolLinks(symbol).containingType.types, t => { symbols.push(getPropertyOfType(t, name)); }); return symbols; @@ -12392,6 +12489,7 @@ namespace ts { case SyntaxKind.TypeQuery: case SyntaxKind.TypeLiteral: case SyntaxKind.UnionType: + case SyntaxKind.IntersectionType: case SyntaxKind.AnyKeyword: break; default: diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index 2ba88f1ac29..7f1d61d73c5 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -341,6 +341,8 @@ namespace ts { return emitTupleType(type); case SyntaxKind.UnionType: return emitUnionType(type); + case SyntaxKind.IntersectionType: + return emitIntersectionType(type); case SyntaxKind.ParenthesizedType: return emitParenType(type); case SyntaxKind.FunctionType: @@ -417,6 +419,10 @@ namespace ts { emitSeparatedList(type.types, " | ", emitType); } + function emitIntersectionType(type: IntersectionTypeNode) { + emitSeparatedList(type.types, " & ", emitType); + } + function emitParenType(type: ParenthesizedTypeNode) { write("("); emitType(type.type); diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index fbb3dad5037..d77b7a7a5dd 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -115,7 +115,8 @@ namespace ts { case SyntaxKind.TupleType: return visitNodes(cbNodes, (node).elementTypes); case SyntaxKind.UnionType: - return visitNodes(cbNodes, (node).types); + case SyntaxKind.IntersectionType: + return visitNodes(cbNodes, (node).types); case SyntaxKind.ParenthesizedType: return visitNode(cbNode, (node).type); case SyntaxKind.ObjectBindingPattern: @@ -2353,22 +2354,30 @@ namespace ts { return type; } - function parseUnionTypeOrHigher(): TypeNode { - let type = parseArrayTypeOrHigher(); - if (token === SyntaxKind.BarToken) { + function parseUnionOrIntersectionType(kind: SyntaxKind, parseConstituentType: () => TypeNode, operator: SyntaxKind): TypeNode { + let type = parseConstituentType(); + if (token === operator) { let types = >[type]; types.pos = type.pos; - while (parseOptional(SyntaxKind.BarToken)) { - types.push(parseArrayTypeOrHigher()); + while (parseOptional(operator)) { + types.push(parseConstituentType()); } types.end = getNodeEnd(); - let node = createNode(SyntaxKind.UnionType, type.pos); + let node = createNode(kind, type.pos); node.types = types; type = finishNode(node); } return type; } + function parseIntersectionTypeOrHigher(): TypeNode { + return parseUnionOrIntersectionType(SyntaxKind.IntersectionType, parseArrayTypeOrHigher, SyntaxKind.AmpersandToken); + } + + function parseUnionTypeOrHigher(): TypeNode { + return parseUnionOrIntersectionType(SyntaxKind.UnionType, parseIntersectionTypeOrHigher, SyntaxKind.BarToken); + } + function isStartOfFunctionType(): boolean { if (token === SyntaxKind.LessThanToken) { return true; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index f9a2fa3b7b4..460cd73af50 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -187,6 +187,7 @@ namespace ts { ArrayType, TupleType, UnionType, + IntersectionType, ParenthesizedType, // Binding patterns ObjectBindingPattern, @@ -634,10 +635,14 @@ namespace ts { elementTypes: NodeArray; } - export interface UnionTypeNode extends TypeNode { + export interface UnionOrIntersectionTypeNode extends TypeNode { types: NodeArray; } + export interface UnionTypeNode extends UnionOrIntersectionTypeNode { } + + export interface IntersectionTypeNode extends UnionOrIntersectionTypeNode { } + export interface ParenthesizedTypeNode extends TypeNode { type: TypeNode; } @@ -1479,7 +1484,7 @@ namespace ts { Merged = 0x02000000, // Merged symbol (created during program binding) Transient = 0x04000000, // Transient symbol (created during type check) Prototype = 0x08000000, // Prototype property (no source representation) - UnionProperty = 0x10000000, // Property in union type + SyntheticProperty = 0x10000000, // Property in union or intersection type Optional = 0x20000000, // Optional property ExportStar = 0x40000000, // Export * declaration @@ -1558,7 +1563,7 @@ namespace ts { instantiations?: Map; // Instantiations of generic type alias (undefined if non-generic) mapper?: TypeMapper; // Type mapper for instantiation alias referenced?: boolean; // True if alias symbol has been referenced as a value - unionType?: UnionType; // Containing union type for union property + containingType?: UnionOrIntersectionType; // Containing union or intersection type for synthetic property resolvedExports?: SymbolTable; // Resolved exports of module exportsChecked?: boolean; // True if exports of external module have been checked isNestedRedeclaration?: boolean; // True if symbol is block scoped redeclaration @@ -1620,17 +1625,18 @@ namespace ts { Interface = 0x00000800, // Interface Reference = 0x00001000, // Generic type reference Tuple = 0x00002000, // Tuple - Union = 0x00004000, // Union - Anonymous = 0x00008000, // Anonymous - Instantiated = 0x00010000, // Instantiated anonymous type + Union = 0x00004000, // Union (T | U) + Intersection = 0x00008000, // Intersection (T & U) + Anonymous = 0x00010000, // Anonymous + Instantiated = 0x00020000, // Instantiated anonymous type /* @internal */ - FromSignature = 0x00020000, // Created for signature assignment check - ObjectLiteral = 0x00040000, // Originates in an object literal + FromSignature = 0x00040000, // Created for signature assignment check + ObjectLiteral = 0x00080000, // Originates in an object literal /* @internal */ - ContainsUndefinedOrNull = 0x00080000, // Type is or contains Undefined or Null type + ContainsUndefinedOrNull = 0x00100000, // Type is or contains Undefined or Null type /* @internal */ - ContainsObjectLiteral = 0x00100000, // Type is or contains object literal type - ESSymbol = 0x00200000, // Type of symbol primitive introduced in ES6 + ContainsObjectLiteral = 0x00200000, // Type is or contains object literal type + ESSymbol = 0x00400000, // Type of symbol primitive introduced in ES6 /* @internal */ Intrinsic = Any | String | Number | Boolean | ESSymbol | Void | Undefined | Null, @@ -1639,6 +1645,8 @@ namespace ts { StringLike = String | StringLiteral, NumberLike = Number | Enum, ObjectType = Class | Interface | Reference | Tuple | Anonymous, + UnionOrIntersection = Union | Intersection, + StructuredType = ObjectType | Union | Intersection, /* @internal */ RequiresWidening = ContainsUndefinedOrNull | ContainsObjectLiteral } @@ -1698,7 +1706,7 @@ namespace ts { baseArrayType: TypeReference; // Array where T is best common type of element types } - export interface UnionType extends Type { + export interface UnionOrIntersectionType extends Type { types: Type[]; // Constituent types /* @internal */ reducedType: Type; // Reduced union type (all subtypes removed) @@ -1706,9 +1714,13 @@ namespace ts { resolvedProperties: SymbolTable; // Cache of resolved properties } + export interface UnionType extends UnionOrIntersectionType { } + + export interface IntersectionType extends UnionOrIntersectionType { } + /* @internal */ - // Resolved object or union type - export interface ResolvedType extends ObjectType, UnionType { + // Resolved object, union, or intersection type + export interface ResolvedType extends ObjectType, UnionOrIntersectionType { members: SymbolTable; // Properties by name properties: Symbol[]; // Properties callSignatures: Signature[]; // Call signatures of type diff --git a/src/services/services.ts b/src/services/services.ts index 70022cfe0bf..9fda4d6db37 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -3576,7 +3576,7 @@ namespace ts { if (flags & SymbolFlags.Constructor) return ScriptElementKind.constructorImplementationElement; if (flags & SymbolFlags.Property) { - if (flags & SymbolFlags.UnionProperty) { + if (flags & SymbolFlags.SyntheticProperty) { // If union property is result of union of non method (property/accessors/variables), it is labeled as property let unionPropertyKind = forEach(typeChecker.getRootSymbols(symbol), rootSymbol => { let rootSymbolFlags = rootSymbol.getFlags(); @@ -5078,7 +5078,7 @@ namespace ts { // if this symbol is visible from its parent container, e.g. exported, then bail out // if symbol correspond to the union property - bail out - if (symbol.parent || (symbol.flags & SymbolFlags.UnionProperty)) { + if (symbol.parent || (symbol.flags & SymbolFlags.SyntheticProperty)) { return undefined; } From d2955e8a857925aa6384b6cb5ba93c1d7c0172e9 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 24 Jun 2015 17:53:33 -0700 Subject: [PATCH 228/309] Accepting new baselines --- tests/baselines/reference/APISample_linter.js | 20 +++++++++---------- .../typeParameterExtendingUnion1.symbols | 4 ++-- .../typeParameterExtendingUnion2.symbols | 8 ++++---- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js index 9b2675535f2..5c2a8953a61 100644 --- a/tests/baselines/reference/APISample_linter.js +++ b/tests/baselines/reference/APISample_linter.js @@ -75,26 +75,26 @@ function delint(sourceFile) { delintNode(sourceFile); function delintNode(node) { switch (node.kind) { - case 189 /* ForStatement */: - case 190 /* ForInStatement */: - case 188 /* WhileStatement */: - case 187 /* DoStatement */: - if (node.statement.kind !== 182 /* Block */) { + case 190 /* ForStatement */: + case 191 /* ForInStatement */: + case 189 /* WhileStatement */: + case 188 /* DoStatement */: + if (node.statement.kind !== 183 /* Block */) { report(node, "A looping statement's contents should be wrapped in a block body."); } break; - case 186 /* IfStatement */: + case 187 /* IfStatement */: var ifStatement = node; - if (ifStatement.thenStatement.kind !== 182 /* Block */) { + if (ifStatement.thenStatement.kind !== 183 /* Block */) { report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); } if (ifStatement.elseStatement && - ifStatement.elseStatement.kind !== 182 /* Block */ && - ifStatement.elseStatement.kind !== 186 /* IfStatement */) { + ifStatement.elseStatement.kind !== 183 /* Block */ && + ifStatement.elseStatement.kind !== 187 /* IfStatement */) { report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); } break; - case 172 /* BinaryExpression */: + case 173 /* BinaryExpression */: var op = node.operatorToken.kind; if (op === 28 /* EqualsEqualsToken */ || op == 29 /* ExclamationEqualsToken */) { report(node, "Use '===' and '!=='."); diff --git a/tests/baselines/reference/typeParameterExtendingUnion1.symbols b/tests/baselines/reference/typeParameterExtendingUnion1.symbols index 39b67e6428c..97d900b5d5e 100644 --- a/tests/baselines/reference/typeParameterExtendingUnion1.symbols +++ b/tests/baselines/reference/typeParameterExtendingUnion1.symbols @@ -33,9 +33,9 @@ function f(a: T) { >T : Symbol(T, Decl(typeParameterExtendingUnion1.ts, 8, 11)) a.run(); ->a.run : Symbol(run, Decl(typeParameterExtendingUnion1.ts, 0, 14), Decl(typeParameterExtendingUnion1.ts, 0, 14)) +>a.run : Symbol(Animal.run, Decl(typeParameterExtendingUnion1.ts, 0, 14)) >a : Symbol(a, Decl(typeParameterExtendingUnion1.ts, 8, 32)) ->run : Symbol(run, Decl(typeParameterExtendingUnion1.ts, 0, 14), Decl(typeParameterExtendingUnion1.ts, 0, 14)) +>run : Symbol(Animal.run, Decl(typeParameterExtendingUnion1.ts, 0, 14)) run(a); >run : Symbol(run, Decl(typeParameterExtendingUnion1.ts, 2, 33)) diff --git a/tests/baselines/reference/typeParameterExtendingUnion2.symbols b/tests/baselines/reference/typeParameterExtendingUnion2.symbols index 44d47692a82..21866b3df92 100644 --- a/tests/baselines/reference/typeParameterExtendingUnion2.symbols +++ b/tests/baselines/reference/typeParameterExtendingUnion2.symbols @@ -20,9 +20,9 @@ function run(a: Cat | Dog) { >Dog : Symbol(Dog, Decl(typeParameterExtendingUnion2.ts, 1, 33)) a.run(); ->a.run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 0, 14), Decl(typeParameterExtendingUnion2.ts, 0, 14)) +>a.run : Symbol(Animal.run, Decl(typeParameterExtendingUnion2.ts, 0, 14)) >a : Symbol(a, Decl(typeParameterExtendingUnion2.ts, 4, 13)) ->run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 0, 14), Decl(typeParameterExtendingUnion2.ts, 0, 14)) +>run : Symbol(Animal.run, Decl(typeParameterExtendingUnion2.ts, 0, 14)) } function f(a: T) { @@ -34,9 +34,9 @@ function f(a: T) { >T : Symbol(T, Decl(typeParameterExtendingUnion2.ts, 8, 11)) a.run(); ->a.run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 0, 14), Decl(typeParameterExtendingUnion2.ts, 0, 14)) +>a.run : Symbol(Animal.run, Decl(typeParameterExtendingUnion2.ts, 0, 14)) >a : Symbol(a, Decl(typeParameterExtendingUnion2.ts, 8, 32)) ->run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 0, 14), Decl(typeParameterExtendingUnion2.ts, 0, 14)) +>run : Symbol(Animal.run, Decl(typeParameterExtendingUnion2.ts, 0, 14)) run(a); >run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 2, 33)) From d5710349a29041290d2d2ce9e875e03c18fd79ae Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 24 Jun 2015 17:53:43 -0700 Subject: [PATCH 229/309] Adding tests --- .../intersectionAndUnionTypes.errors.txt | 162 ++++++++++++++++++ .../reference/intersectionAndUnionTypes.js | 72 ++++++++ .../reference/intersectionTypeEquivalence.js | 31 ++++ .../intersectionTypeEquivalence.symbols | 63 +++++++ .../intersectionTypeEquivalence.types | 63 +++++++ .../intersectionTypeInference.errors.txt | 27 +++ .../reference/intersectionTypeInference.js | 28 +++ .../reference/intersectionTypeMembers.js | 44 +++++ .../reference/intersectionTypeMembers.symbols | 100 +++++++++++ .../reference/intersectionTypeMembers.types | 116 +++++++++++++ .../recursiveIntersectionTypes.errors.txt | 32 ++++ .../reference/recursiveIntersectionTypes.js | 31 ++++ .../intersection/intersectionAndUnionTypes.ts | 38 ++++ .../intersectionTypeEquivalence.ts | 16 ++ .../intersection/intersectionTypeInference.ts | 13 ++ .../intersection/intersectionTypeMembers.ts | 27 +++ .../recursiveIntersectionTypes.ts | 19 ++ 17 files changed, 882 insertions(+) create mode 100644 tests/baselines/reference/intersectionAndUnionTypes.errors.txt create mode 100644 tests/baselines/reference/intersectionAndUnionTypes.js create mode 100644 tests/baselines/reference/intersectionTypeEquivalence.js create mode 100644 tests/baselines/reference/intersectionTypeEquivalence.symbols create mode 100644 tests/baselines/reference/intersectionTypeEquivalence.types create mode 100644 tests/baselines/reference/intersectionTypeInference.errors.txt create mode 100644 tests/baselines/reference/intersectionTypeInference.js create mode 100644 tests/baselines/reference/intersectionTypeMembers.js create mode 100644 tests/baselines/reference/intersectionTypeMembers.symbols create mode 100644 tests/baselines/reference/intersectionTypeMembers.types create mode 100644 tests/baselines/reference/recursiveIntersectionTypes.errors.txt create mode 100644 tests/baselines/reference/recursiveIntersectionTypes.js create mode 100644 tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts create mode 100644 tests/cases/conformance/types/intersection/intersectionTypeEquivalence.ts create mode 100644 tests/cases/conformance/types/intersection/intersectionTypeInference.ts create mode 100644 tests/cases/conformance/types/intersection/intersectionTypeMembers.ts create mode 100644 tests/cases/conformance/types/intersection/recursiveIntersectionTypes.ts diff --git a/tests/baselines/reference/intersectionAndUnionTypes.errors.txt b/tests/baselines/reference/intersectionAndUnionTypes.errors.txt new file mode 100644 index 00000000000..4f26cc63ba3 --- /dev/null +++ b/tests/baselines/reference/intersectionAndUnionTypes.errors.txt @@ -0,0 +1,162 @@ +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(19,1): error TS2322: Type 'A' is not assignable to type 'A & B'. + Type 'A' is not assignable to type 'B'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(20,1): error TS2322: Type 'B' is not assignable to type 'A & B'. + Type 'B' is not assignable to type 'A'. + Property 'a' is missing in type 'B'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(23,1): error TS2322: Type 'A | B' is not assignable to type '(A & B) | (C & D)'. + Type 'A' is not assignable to type '(A & B) | (C & D)'. + Type 'A' is not assignable to type 'C & D'. + Type 'A' is not assignable to type 'C'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(25,1): error TS2322: Type 'C | D' is not assignable to type '(A & B) | (C & D)'. + Type 'C' is not assignable to type '(A & B) | (C & D)'. + Type 'C' is not assignable to type 'C & D'. + Type 'C' is not assignable to type 'D'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(26,1): error TS2322: Type '(A & B) | (C & D)' is not assignable to type 'A & B'. + Type 'C & D' is not assignable to type 'A & B'. + Type 'C & D' is not assignable to type 'A'. + Type 'D' is not assignable to type 'A'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(27,1): error TS2322: Type '(A & B) | (C & D)' is not assignable to type 'A | B'. + Type 'C & D' is not assignable to type 'A | B'. + Type 'C & D' is not assignable to type 'B'. + Type 'D' is not assignable to type 'B'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(28,1): error TS2322: Type '(A & B) | (C & D)' is not assignable to type 'C & D'. + Type 'A & B' is not assignable to type 'C & D'. + Type 'A & B' is not assignable to type 'C'. + Type 'B' is not assignable to type 'C'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(29,1): error TS2322: Type '(A & B) | (C & D)' is not assignable to type 'C | D'. + Type 'A & B' is not assignable to type 'C | D'. + Type 'A & B' is not assignable to type 'D'. + Type 'B' is not assignable to type 'D'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(31,1): error TS2322: Type 'A & B' is not assignable to type '(A | B) & (C | D)'. + Type 'A & B' is not assignable to type 'C | D'. + Type 'A & B' is not assignable to type 'D'. + Type 'B' is not assignable to type 'D'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(32,1): error TS2322: Type 'A | B' is not assignable to type '(A | B) & (C | D)'. + Type 'A' is not assignable to type '(A | B) & (C | D)'. + Type 'A' is not assignable to type 'C | D'. + Type 'A' is not assignable to type 'D'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(33,1): error TS2322: Type 'C & D' is not assignable to type '(A | B) & (C | D)'. + Type 'C & D' is not assignable to type 'A | B'. + Type 'C & D' is not assignable to type 'B'. + Type 'D' is not assignable to type 'B'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(34,1): error TS2322: Type 'C | D' is not assignable to type '(A | B) & (C | D)'. + Type 'C' is not assignable to type '(A | B) & (C | D)'. + Type 'C' is not assignable to type 'A | B'. + Type 'C' is not assignable to type 'B'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(35,1): error TS2322: Type '(A | B) & (C | D)' is not assignable to type 'A & B'. + Type '(A | B) & (C | D)' is not assignable to type 'A'. + Type 'C | D' is not assignable to type 'A'. + Type 'C' is not assignable to type 'A'. +tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts(37,1): error TS2322: Type '(A | B) & (C | D)' is not assignable to type 'C & D'. + Type '(A | B) & (C | D)' is not assignable to type 'C'. + Type 'C | D' is not assignable to type 'C'. + Type 'D' is not assignable to type 'C'. + + +==== tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts (14 errors) ==== + interface A { a: string } + interface B { b: string } + interface C { c: string } + interface D { d: string } + + var a: A; + var b: B; + var c: C; + var d: D; + var anb: A & B; + var aob: A | B; + var cnd: C & D; + var cod: C | D; + var x: A & B | C & D; + var y: (A | B) & (C | D); + + a = anb; // Ok + b = anb; // Ok + anb = a; + ~~~ +!!! error TS2322: Type 'A' is not assignable to type 'A & B'. +!!! error TS2322: Type 'A' is not assignable to type 'B'. + anb = b; + ~~~ +!!! error TS2322: Type 'B' is not assignable to type 'A & B'. +!!! error TS2322: Type 'B' is not assignable to type 'A'. +!!! error TS2322: Property 'a' is missing in type 'B'. + + x = anb; // Ok + x = aob; + ~ +!!! error TS2322: Type 'A | B' is not assignable to type '(A & B) | (C & D)'. +!!! error TS2322: Type 'A' is not assignable to type '(A & B) | (C & D)'. +!!! error TS2322: Type 'A' is not assignable to type 'C & D'. +!!! error TS2322: Type 'A' is not assignable to type 'C'. + x = cnd; // Ok + x = cod; + ~ +!!! error TS2322: Type 'C | D' is not assignable to type '(A & B) | (C & D)'. +!!! error TS2322: Type 'C' is not assignable to type '(A & B) | (C & D)'. +!!! error TS2322: Type 'C' is not assignable to type 'C & D'. +!!! error TS2322: Type 'C' is not assignable to type 'D'. + anb = x; + ~~~ +!!! error TS2322: Type '(A & B) | (C & D)' is not assignable to type 'A & B'. +!!! error TS2322: Type 'C & D' is not assignable to type 'A & B'. +!!! error TS2322: Type 'C & D' is not assignable to type 'A'. +!!! error TS2322: Type 'D' is not assignable to type 'A'. + aob = x; + ~~~ +!!! error TS2322: Type '(A & B) | (C & D)' is not assignable to type 'A | B'. +!!! error TS2322: Type 'C & D' is not assignable to type 'A | B'. +!!! error TS2322: Type 'C & D' is not assignable to type 'B'. +!!! error TS2322: Type 'D' is not assignable to type 'B'. + cnd = x; + ~~~ +!!! error TS2322: Type '(A & B) | (C & D)' is not assignable to type 'C & D'. +!!! error TS2322: Type 'A & B' is not assignable to type 'C & D'. +!!! error TS2322: Type 'A & B' is not assignable to type 'C'. +!!! error TS2322: Type 'B' is not assignable to type 'C'. + cod = x; + ~~~ +!!! error TS2322: Type '(A & B) | (C & D)' is not assignable to type 'C | D'. +!!! error TS2322: Type 'A & B' is not assignable to type 'C | D'. +!!! error TS2322: Type 'A & B' is not assignable to type 'D'. +!!! error TS2322: Type 'B' is not assignable to type 'D'. + + y = anb; + ~ +!!! error TS2322: Type 'A & B' is not assignable to type '(A | B) & (C | D)'. +!!! error TS2322: Type 'A & B' is not assignable to type 'C | D'. +!!! error TS2322: Type 'A & B' is not assignable to type 'D'. +!!! error TS2322: Type 'B' is not assignable to type 'D'. + y = aob; + ~ +!!! error TS2322: Type 'A | B' is not assignable to type '(A | B) & (C | D)'. +!!! error TS2322: Type 'A' is not assignable to type '(A | B) & (C | D)'. +!!! error TS2322: Type 'A' is not assignable to type 'C | D'. +!!! error TS2322: Type 'A' is not assignable to type 'D'. + y = cnd; + ~ +!!! error TS2322: Type 'C & D' is not assignable to type '(A | B) & (C | D)'. +!!! error TS2322: Type 'C & D' is not assignable to type 'A | B'. +!!! error TS2322: Type 'C & D' is not assignable to type 'B'. +!!! error TS2322: Type 'D' is not assignable to type 'B'. + y = cod; + ~ +!!! error TS2322: Type 'C | D' is not assignable to type '(A | B) & (C | D)'. +!!! error TS2322: Type 'C' is not assignable to type '(A | B) & (C | D)'. +!!! error TS2322: Type 'C' is not assignable to type 'A | B'. +!!! error TS2322: Type 'C' is not assignable to type 'B'. + anb = y; + ~~~ +!!! error TS2322: Type '(A | B) & (C | D)' is not assignable to type 'A & B'. +!!! error TS2322: Type '(A | B) & (C | D)' is not assignable to type 'A'. +!!! error TS2322: Type 'C | D' is not assignable to type 'A'. +!!! error TS2322: Type 'C' is not assignable to type 'A'. + aob = y; // Ok + cnd = y; + ~~~ +!!! error TS2322: Type '(A | B) & (C | D)' is not assignable to type 'C & D'. +!!! error TS2322: Type '(A | B) & (C | D)' is not assignable to type 'C'. +!!! error TS2322: Type 'C | D' is not assignable to type 'C'. +!!! error TS2322: Type 'D' is not assignable to type 'C'. + cod = y; // Ok + \ No newline at end of file diff --git a/tests/baselines/reference/intersectionAndUnionTypes.js b/tests/baselines/reference/intersectionAndUnionTypes.js new file mode 100644 index 00000000000..ec0adaab8b8 --- /dev/null +++ b/tests/baselines/reference/intersectionAndUnionTypes.js @@ -0,0 +1,72 @@ +//// [intersectionAndUnionTypes.ts] +interface A { a: string } +interface B { b: string } +interface C { c: string } +interface D { d: string } + +var a: A; +var b: B; +var c: C; +var d: D; +var anb: A & B; +var aob: A | B; +var cnd: C & D; +var cod: C | D; +var x: A & B | C & D; +var y: (A | B) & (C | D); + +a = anb; // Ok +b = anb; // Ok +anb = a; +anb = b; + +x = anb; // Ok +x = aob; +x = cnd; // Ok +x = cod; +anb = x; +aob = x; +cnd = x; +cod = x; + +y = anb; +y = aob; +y = cnd; +y = cod; +anb = y; +aob = y; // Ok +cnd = y; +cod = y; // Ok + + +//// [intersectionAndUnionTypes.js] +var a; +var b; +var c; +var d; +var anb; +var aob; +var cnd; +var cod; +var x; +var y; +a = anb; // Ok +b = anb; // Ok +anb = a; +anb = b; +x = anb; // Ok +x = aob; +x = cnd; // Ok +x = cod; +anb = x; +aob = x; +cnd = x; +cod = x; +y = anb; +y = aob; +y = cnd; +y = cod; +anb = y; +aob = y; // Ok +cnd = y; +cod = y; // Ok diff --git a/tests/baselines/reference/intersectionTypeEquivalence.js b/tests/baselines/reference/intersectionTypeEquivalence.js new file mode 100644 index 00000000000..be04bfe7947 --- /dev/null +++ b/tests/baselines/reference/intersectionTypeEquivalence.js @@ -0,0 +1,31 @@ +//// [intersectionTypeEquivalence.ts] +interface A { a: string } +interface B { b: string } +interface C { c: string } + +// A & B is equivalent to B & A. +var y: A & B; +var y : B & A; + +// AB & C is equivalent to A & BC, where AB is A & B and BC is B & C. +var z : A & B & C; +var z : (A & B) & C; +var z : A & (B & C); +var ab : A & B; +var bc : B & C; +var z1: typeof ab & C; +var z1: A & typeof bc; + + +//// [intersectionTypeEquivalence.js] +// A & B is equivalent to B & A. +var y; +var y; +// AB & C is equivalent to A & BC, where AB is A & B and BC is B & C. +var z; +var z; +var z; +var ab; +var bc; +var z1; +var z1; diff --git a/tests/baselines/reference/intersectionTypeEquivalence.symbols b/tests/baselines/reference/intersectionTypeEquivalence.symbols new file mode 100644 index 00000000000..2bec452c44e --- /dev/null +++ b/tests/baselines/reference/intersectionTypeEquivalence.symbols @@ -0,0 +1,63 @@ +=== tests/cases/conformance/types/intersection/intersectionTypeEquivalence.ts === +interface A { a: string } +>A : Symbol(A, Decl(intersectionTypeEquivalence.ts, 0, 0)) +>a : Symbol(a, Decl(intersectionTypeEquivalence.ts, 0, 13)) + +interface B { b: string } +>B : Symbol(B, Decl(intersectionTypeEquivalence.ts, 0, 25)) +>b : Symbol(b, Decl(intersectionTypeEquivalence.ts, 1, 13)) + +interface C { c: string } +>C : Symbol(C, Decl(intersectionTypeEquivalence.ts, 1, 25)) +>c : Symbol(c, Decl(intersectionTypeEquivalence.ts, 2, 13)) + +// A & B is equivalent to B & A. +var y: A & B; +>y : Symbol(y, Decl(intersectionTypeEquivalence.ts, 5, 3), Decl(intersectionTypeEquivalence.ts, 6, 3)) +>A : Symbol(A, Decl(intersectionTypeEquivalence.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionTypeEquivalence.ts, 0, 25)) + +var y : B & A; +>y : Symbol(y, Decl(intersectionTypeEquivalence.ts, 5, 3), Decl(intersectionTypeEquivalence.ts, 6, 3)) +>B : Symbol(B, Decl(intersectionTypeEquivalence.ts, 0, 25)) +>A : Symbol(A, Decl(intersectionTypeEquivalence.ts, 0, 0)) + +// AB & C is equivalent to A & BC, where AB is A & B and BC is B & C. +var z : A & B & C; +>z : Symbol(z, Decl(intersectionTypeEquivalence.ts, 9, 3), Decl(intersectionTypeEquivalence.ts, 10, 3), Decl(intersectionTypeEquivalence.ts, 11, 3)) +>A : Symbol(A, Decl(intersectionTypeEquivalence.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionTypeEquivalence.ts, 0, 25)) +>C : Symbol(C, Decl(intersectionTypeEquivalence.ts, 1, 25)) + +var z : (A & B) & C; +>z : Symbol(z, Decl(intersectionTypeEquivalence.ts, 9, 3), Decl(intersectionTypeEquivalence.ts, 10, 3), Decl(intersectionTypeEquivalence.ts, 11, 3)) +>A : Symbol(A, Decl(intersectionTypeEquivalence.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionTypeEquivalence.ts, 0, 25)) +>C : Symbol(C, Decl(intersectionTypeEquivalence.ts, 1, 25)) + +var z : A & (B & C); +>z : Symbol(z, Decl(intersectionTypeEquivalence.ts, 9, 3), Decl(intersectionTypeEquivalence.ts, 10, 3), Decl(intersectionTypeEquivalence.ts, 11, 3)) +>A : Symbol(A, Decl(intersectionTypeEquivalence.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionTypeEquivalence.ts, 0, 25)) +>C : Symbol(C, Decl(intersectionTypeEquivalence.ts, 1, 25)) + +var ab : A & B; +>ab : Symbol(ab, Decl(intersectionTypeEquivalence.ts, 12, 3)) +>A : Symbol(A, Decl(intersectionTypeEquivalence.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionTypeEquivalence.ts, 0, 25)) + +var bc : B & C; +>bc : Symbol(bc, Decl(intersectionTypeEquivalence.ts, 13, 3)) +>B : Symbol(B, Decl(intersectionTypeEquivalence.ts, 0, 25)) +>C : Symbol(C, Decl(intersectionTypeEquivalence.ts, 1, 25)) + +var z1: typeof ab & C; +>z1 : Symbol(z1, Decl(intersectionTypeEquivalence.ts, 14, 3), Decl(intersectionTypeEquivalence.ts, 15, 3)) +>ab : Symbol(ab, Decl(intersectionTypeEquivalence.ts, 12, 3)) +>C : Symbol(C, Decl(intersectionTypeEquivalence.ts, 1, 25)) + +var z1: A & typeof bc; +>z1 : Symbol(z1, Decl(intersectionTypeEquivalence.ts, 14, 3), Decl(intersectionTypeEquivalence.ts, 15, 3)) +>A : Symbol(A, Decl(intersectionTypeEquivalence.ts, 0, 0)) +>bc : Symbol(bc, Decl(intersectionTypeEquivalence.ts, 13, 3)) + diff --git a/tests/baselines/reference/intersectionTypeEquivalence.types b/tests/baselines/reference/intersectionTypeEquivalence.types new file mode 100644 index 00000000000..25e175275d7 --- /dev/null +++ b/tests/baselines/reference/intersectionTypeEquivalence.types @@ -0,0 +1,63 @@ +=== tests/cases/conformance/types/intersection/intersectionTypeEquivalence.ts === +interface A { a: string } +>A : A +>a : string + +interface B { b: string } +>B : B +>b : string + +interface C { c: string } +>C : C +>c : string + +// A & B is equivalent to B & A. +var y: A & B; +>y : A & B +>A : A +>B : B + +var y : B & A; +>y : A & B +>B : B +>A : A + +// AB & C is equivalent to A & BC, where AB is A & B and BC is B & C. +var z : A & B & C; +>z : A & B & C +>A : A +>B : B +>C : C + +var z : (A & B) & C; +>z : A & B & C +>A : A +>B : B +>C : C + +var z : A & (B & C); +>z : A & B & C +>A : A +>B : B +>C : C + +var ab : A & B; +>ab : A & B +>A : A +>B : B + +var bc : B & C; +>bc : B & C +>B : B +>C : C + +var z1: typeof ab & C; +>z1 : A & B & C +>ab : A & B +>C : C + +var z1: A & typeof bc; +>z1 : A & B & C +>A : A +>bc : B & C + diff --git a/tests/baselines/reference/intersectionTypeInference.errors.txt b/tests/baselines/reference/intersectionTypeInference.errors.txt new file mode 100644 index 00000000000..33c24e111dc --- /dev/null +++ b/tests/baselines/reference/intersectionTypeInference.errors.txt @@ -0,0 +1,27 @@ +tests/cases/conformance/types/intersection/intersectionTypeInference.ts(6,5): error TS2322: Type 'T' is not assignable to type 'T & U'. + Type 'T' is not assignable to type 'U'. +tests/cases/conformance/types/intersection/intersectionTypeInference.ts(7,5): error TS2322: Type 'U' is not assignable to type 'T & U'. + Type 'U' is not assignable to type 'T'. + + +==== tests/cases/conformance/types/intersection/intersectionTypeInference.ts (2 errors) ==== + + function extend(obj1: T, obj2: U): T & U { + var result: T & U; + obj1 = result; + obj2 = result; + result = obj1; // Error + ~~~~~~ +!!! error TS2322: Type 'T' is not assignable to type 'T & U'. +!!! error TS2322: Type 'T' is not assignable to type 'U'. + result = obj2; // Error + ~~~~~~ +!!! error TS2322: Type 'U' is not assignable to type 'T & U'. +!!! error TS2322: Type 'U' is not assignable to type 'T'. + return result; + } + + var x = extend({ a: "hello" }, { b: 42 }); + var s = x.a; + var n = x.b; + \ No newline at end of file diff --git a/tests/baselines/reference/intersectionTypeInference.js b/tests/baselines/reference/intersectionTypeInference.js new file mode 100644 index 00000000000..0b95879a6c0 --- /dev/null +++ b/tests/baselines/reference/intersectionTypeInference.js @@ -0,0 +1,28 @@ +//// [intersectionTypeInference.ts] + +function extend(obj1: T, obj2: U): T & U { + var result: T & U; + obj1 = result; + obj2 = result; + result = obj1; // Error + result = obj2; // Error + return result; +} + +var x = extend({ a: "hello" }, { b: 42 }); +var s = x.a; +var n = x.b; + + +//// [intersectionTypeInference.js] +function extend(obj1, obj2) { + var result; + obj1 = result; + obj2 = result; + result = obj1; // Error + result = obj2; // Error + return result; +} +var x = extend({ a: "hello" }, { b: 42 }); +var s = x.a; +var n = x.b; diff --git a/tests/baselines/reference/intersectionTypeMembers.js b/tests/baselines/reference/intersectionTypeMembers.js new file mode 100644 index 00000000000..9c1cd75d601 --- /dev/null +++ b/tests/baselines/reference/intersectionTypeMembers.js @@ -0,0 +1,44 @@ +//// [intersectionTypeMembers.ts] +// An intersection type has those members that are present in any of its constituent types, +// with types that are intersections of the respective members in the constituent types + +interface A { a: string } +interface B { b: string } +interface C { c: string } + +var abc: A & B & C; +abc.a = "hello"; +abc.b = "hello"; +abc.c = "hello"; + +interface X { x: A } +interface Y { x: B } +interface Z { x: C } + +var xyz: X & Y & Z; +xyz.x.a = "hello"; +xyz.x.b = "hello"; +xyz.x.c = "hello"; + +type F1 = (x: string) => string; +type F2 = (x: number) => number; + +var f: F1 & F2; +var s = f("hello"); +var n = f(42); + + +//// [intersectionTypeMembers.js] +// An intersection type has those members that are present in any of its constituent types, +// with types that are intersections of the respective members in the constituent types +var abc; +abc.a = "hello"; +abc.b = "hello"; +abc.c = "hello"; +var xyz; +xyz.x.a = "hello"; +xyz.x.b = "hello"; +xyz.x.c = "hello"; +var f; +var s = f("hello"); +var n = f(42); diff --git a/tests/baselines/reference/intersectionTypeMembers.symbols b/tests/baselines/reference/intersectionTypeMembers.symbols new file mode 100644 index 00000000000..ebec69b4ebe --- /dev/null +++ b/tests/baselines/reference/intersectionTypeMembers.symbols @@ -0,0 +1,100 @@ +=== tests/cases/conformance/types/intersection/intersectionTypeMembers.ts === +// An intersection type has those members that are present in any of its constituent types, +// with types that are intersections of the respective members in the constituent types + +interface A { a: string } +>A : Symbol(A, Decl(intersectionTypeMembers.ts, 0, 0)) +>a : Symbol(a, Decl(intersectionTypeMembers.ts, 3, 13)) + +interface B { b: string } +>B : Symbol(B, Decl(intersectionTypeMembers.ts, 3, 25)) +>b : Symbol(b, Decl(intersectionTypeMembers.ts, 4, 13)) + +interface C { c: string } +>C : Symbol(C, Decl(intersectionTypeMembers.ts, 4, 25)) +>c : Symbol(c, Decl(intersectionTypeMembers.ts, 5, 13)) + +var abc: A & B & C; +>abc : Symbol(abc, Decl(intersectionTypeMembers.ts, 7, 3)) +>A : Symbol(A, Decl(intersectionTypeMembers.ts, 0, 0)) +>B : Symbol(B, Decl(intersectionTypeMembers.ts, 3, 25)) +>C : Symbol(C, Decl(intersectionTypeMembers.ts, 4, 25)) + +abc.a = "hello"; +>abc.a : Symbol(A.a, Decl(intersectionTypeMembers.ts, 3, 13)) +>abc : Symbol(abc, Decl(intersectionTypeMembers.ts, 7, 3)) +>a : Symbol(A.a, Decl(intersectionTypeMembers.ts, 3, 13)) + +abc.b = "hello"; +>abc.b : Symbol(B.b, Decl(intersectionTypeMembers.ts, 4, 13)) +>abc : Symbol(abc, Decl(intersectionTypeMembers.ts, 7, 3)) +>b : Symbol(B.b, Decl(intersectionTypeMembers.ts, 4, 13)) + +abc.c = "hello"; +>abc.c : Symbol(C.c, Decl(intersectionTypeMembers.ts, 5, 13)) +>abc : Symbol(abc, Decl(intersectionTypeMembers.ts, 7, 3)) +>c : Symbol(C.c, Decl(intersectionTypeMembers.ts, 5, 13)) + +interface X { x: A } +>X : Symbol(X, Decl(intersectionTypeMembers.ts, 10, 16)) +>x : Symbol(x, Decl(intersectionTypeMembers.ts, 12, 13)) +>A : Symbol(A, Decl(intersectionTypeMembers.ts, 0, 0)) + +interface Y { x: B } +>Y : Symbol(Y, Decl(intersectionTypeMembers.ts, 12, 20)) +>x : Symbol(x, Decl(intersectionTypeMembers.ts, 13, 13)) +>B : Symbol(B, Decl(intersectionTypeMembers.ts, 3, 25)) + +interface Z { x: C } +>Z : Symbol(Z, Decl(intersectionTypeMembers.ts, 13, 20)) +>x : Symbol(x, Decl(intersectionTypeMembers.ts, 14, 13)) +>C : Symbol(C, Decl(intersectionTypeMembers.ts, 4, 25)) + +var xyz: X & Y & Z; +>xyz : Symbol(xyz, Decl(intersectionTypeMembers.ts, 16, 3)) +>X : Symbol(X, Decl(intersectionTypeMembers.ts, 10, 16)) +>Y : Symbol(Y, Decl(intersectionTypeMembers.ts, 12, 20)) +>Z : Symbol(Z, Decl(intersectionTypeMembers.ts, 13, 20)) + +xyz.x.a = "hello"; +>xyz.x.a : Symbol(A.a, Decl(intersectionTypeMembers.ts, 3, 13)) +>xyz.x : Symbol(x, Decl(intersectionTypeMembers.ts, 12, 13), Decl(intersectionTypeMembers.ts, 13, 13), Decl(intersectionTypeMembers.ts, 14, 13)) +>xyz : Symbol(xyz, Decl(intersectionTypeMembers.ts, 16, 3)) +>x : Symbol(x, Decl(intersectionTypeMembers.ts, 12, 13), Decl(intersectionTypeMembers.ts, 13, 13), Decl(intersectionTypeMembers.ts, 14, 13)) +>a : Symbol(A.a, Decl(intersectionTypeMembers.ts, 3, 13)) + +xyz.x.b = "hello"; +>xyz.x.b : Symbol(B.b, Decl(intersectionTypeMembers.ts, 4, 13)) +>xyz.x : Symbol(x, Decl(intersectionTypeMembers.ts, 12, 13), Decl(intersectionTypeMembers.ts, 13, 13), Decl(intersectionTypeMembers.ts, 14, 13)) +>xyz : Symbol(xyz, Decl(intersectionTypeMembers.ts, 16, 3)) +>x : Symbol(x, Decl(intersectionTypeMembers.ts, 12, 13), Decl(intersectionTypeMembers.ts, 13, 13), Decl(intersectionTypeMembers.ts, 14, 13)) +>b : Symbol(B.b, Decl(intersectionTypeMembers.ts, 4, 13)) + +xyz.x.c = "hello"; +>xyz.x.c : Symbol(C.c, Decl(intersectionTypeMembers.ts, 5, 13)) +>xyz.x : Symbol(x, Decl(intersectionTypeMembers.ts, 12, 13), Decl(intersectionTypeMembers.ts, 13, 13), Decl(intersectionTypeMembers.ts, 14, 13)) +>xyz : Symbol(xyz, Decl(intersectionTypeMembers.ts, 16, 3)) +>x : Symbol(x, Decl(intersectionTypeMembers.ts, 12, 13), Decl(intersectionTypeMembers.ts, 13, 13), Decl(intersectionTypeMembers.ts, 14, 13)) +>c : Symbol(C.c, Decl(intersectionTypeMembers.ts, 5, 13)) + +type F1 = (x: string) => string; +>F1 : Symbol(F1, Decl(intersectionTypeMembers.ts, 19, 18)) +>x : Symbol(x, Decl(intersectionTypeMembers.ts, 21, 11)) + +type F2 = (x: number) => number; +>F2 : Symbol(F2, Decl(intersectionTypeMembers.ts, 21, 32)) +>x : Symbol(x, Decl(intersectionTypeMembers.ts, 22, 11)) + +var f: F1 & F2; +>f : Symbol(f, Decl(intersectionTypeMembers.ts, 24, 3)) +>F1 : Symbol(F1, Decl(intersectionTypeMembers.ts, 19, 18)) +>F2 : Symbol(F2, Decl(intersectionTypeMembers.ts, 21, 32)) + +var s = f("hello"); +>s : Symbol(s, Decl(intersectionTypeMembers.ts, 25, 3)) +>f : Symbol(f, Decl(intersectionTypeMembers.ts, 24, 3)) + +var n = f(42); +>n : Symbol(n, Decl(intersectionTypeMembers.ts, 26, 3)) +>f : Symbol(f, Decl(intersectionTypeMembers.ts, 24, 3)) + diff --git a/tests/baselines/reference/intersectionTypeMembers.types b/tests/baselines/reference/intersectionTypeMembers.types new file mode 100644 index 00000000000..a97a54c7a81 --- /dev/null +++ b/tests/baselines/reference/intersectionTypeMembers.types @@ -0,0 +1,116 @@ +=== tests/cases/conformance/types/intersection/intersectionTypeMembers.ts === +// An intersection type has those members that are present in any of its constituent types, +// with types that are intersections of the respective members in the constituent types + +interface A { a: string } +>A : A +>a : string + +interface B { b: string } +>B : B +>b : string + +interface C { c: string } +>C : C +>c : string + +var abc: A & B & C; +>abc : A & B & C +>A : A +>B : B +>C : C + +abc.a = "hello"; +>abc.a = "hello" : string +>abc.a : string +>abc : A & B & C +>a : string +>"hello" : string + +abc.b = "hello"; +>abc.b = "hello" : string +>abc.b : string +>abc : A & B & C +>b : string +>"hello" : string + +abc.c = "hello"; +>abc.c = "hello" : string +>abc.c : string +>abc : A & B & C +>c : string +>"hello" : string + +interface X { x: A } +>X : X +>x : A +>A : A + +interface Y { x: B } +>Y : Y +>x : B +>B : B + +interface Z { x: C } +>Z : Z +>x : C +>C : C + +var xyz: X & Y & Z; +>xyz : X & Y & Z +>X : X +>Y : Y +>Z : Z + +xyz.x.a = "hello"; +>xyz.x.a = "hello" : string +>xyz.x.a : string +>xyz.x : A & B & C +>xyz : X & Y & Z +>x : A & B & C +>a : string +>"hello" : string + +xyz.x.b = "hello"; +>xyz.x.b = "hello" : string +>xyz.x.b : string +>xyz.x : A & B & C +>xyz : X & Y & Z +>x : A & B & C +>b : string +>"hello" : string + +xyz.x.c = "hello"; +>xyz.x.c = "hello" : string +>xyz.x.c : string +>xyz.x : A & B & C +>xyz : X & Y & Z +>x : A & B & C +>c : string +>"hello" : string + +type F1 = (x: string) => string; +>F1 : (x: string) => string +>x : string + +type F2 = (x: number) => number; +>F2 : (x: number) => number +>x : number + +var f: F1 & F2; +>f : ((x: string) => string) & ((x: number) => number) +>F1 : (x: string) => string +>F2 : (x: number) => number + +var s = f("hello"); +>s : string +>f("hello") : string +>f : ((x: string) => string) & ((x: number) => number) +>"hello" : string + +var n = f(42); +>n : number +>f(42) : number +>f : ((x: string) => string) & ((x: number) => number) +>42 : number + diff --git a/tests/baselines/reference/recursiveIntersectionTypes.errors.txt b/tests/baselines/reference/recursiveIntersectionTypes.errors.txt new file mode 100644 index 00000000000..bac97470e55 --- /dev/null +++ b/tests/baselines/reference/recursiveIntersectionTypes.errors.txt @@ -0,0 +1,32 @@ +tests/cases/conformance/types/intersection/recursiveIntersectionTypes.ts(19,1): error TS2322: Type 'Entity & { next: Entity & any; }' is not assignable to type 'Product & { next: Product & any; }'. + Type 'Entity & { next: Entity & any; }' is not assignable to type 'Product'. + Type '{ next: Entity & any; }' is not assignable to type 'Product'. + Property 'price' is missing in type '{ next: Entity & any; }'. + + +==== tests/cases/conformance/types/intersection/recursiveIntersectionTypes.ts (1 errors) ==== + type LinkedList = T & { next: LinkedList }; + + interface Entity { + name: string; + } + + interface Product extends Entity { + price: number; + } + + var entityList: LinkedList; + var s = entityList.name; + var s = entityList.next.name; + var s = entityList.next.next.name; + var s = entityList.next.next.next.name; + + var productList: LinkedList; + entityList = productList; + productList = entityList; // Error + ~~~~~~~~~~~ +!!! error TS2322: Type 'Entity & { next: Entity & any; }' is not assignable to type 'Product & { next: Product & any; }'. +!!! error TS2322: Type 'Entity & { next: Entity & any; }' is not assignable to type 'Product'. +!!! error TS2322: Type '{ next: Entity & any; }' is not assignable to type 'Product'. +!!! error TS2322: Property 'price' is missing in type '{ next: Entity & any; }'. + \ No newline at end of file diff --git a/tests/baselines/reference/recursiveIntersectionTypes.js b/tests/baselines/reference/recursiveIntersectionTypes.js new file mode 100644 index 00000000000..88b7e6f831b --- /dev/null +++ b/tests/baselines/reference/recursiveIntersectionTypes.js @@ -0,0 +1,31 @@ +//// [recursiveIntersectionTypes.ts] +type LinkedList = T & { next: LinkedList }; + +interface Entity { + name: string; +} + +interface Product extends Entity { + price: number; +} + +var entityList: LinkedList; +var s = entityList.name; +var s = entityList.next.name; +var s = entityList.next.next.name; +var s = entityList.next.next.next.name; + +var productList: LinkedList; +entityList = productList; +productList = entityList; // Error + + +//// [recursiveIntersectionTypes.js] +var entityList; +var s = entityList.name; +var s = entityList.next.name; +var s = entityList.next.next.name; +var s = entityList.next.next.next.name; +var productList; +entityList = productList; +productList = entityList; // Error diff --git a/tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts b/tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts new file mode 100644 index 00000000000..e6bd671c6b2 --- /dev/null +++ b/tests/cases/conformance/types/intersection/intersectionAndUnionTypes.ts @@ -0,0 +1,38 @@ +interface A { a: string } +interface B { b: string } +interface C { c: string } +interface D { d: string } + +var a: A; +var b: B; +var c: C; +var d: D; +var anb: A & B; +var aob: A | B; +var cnd: C & D; +var cod: C | D; +var x: A & B | C & D; +var y: (A | B) & (C | D); + +a = anb; // Ok +b = anb; // Ok +anb = a; +anb = b; + +x = anb; // Ok +x = aob; +x = cnd; // Ok +x = cod; +anb = x; +aob = x; +cnd = x; +cod = x; + +y = anb; +y = aob; +y = cnd; +y = cod; +anb = y; +aob = y; // Ok +cnd = y; +cod = y; // Ok diff --git a/tests/cases/conformance/types/intersection/intersectionTypeEquivalence.ts b/tests/cases/conformance/types/intersection/intersectionTypeEquivalence.ts new file mode 100644 index 00000000000..fce399eff94 --- /dev/null +++ b/tests/cases/conformance/types/intersection/intersectionTypeEquivalence.ts @@ -0,0 +1,16 @@ +interface A { a: string } +interface B { b: string } +interface C { c: string } + +// A & B is equivalent to B & A. +var y: A & B; +var y : B & A; + +// AB & C is equivalent to A & BC, where AB is A & B and BC is B & C. +var z : A & B & C; +var z : (A & B) & C; +var z : A & (B & C); +var ab : A & B; +var bc : B & C; +var z1: typeof ab & C; +var z1: A & typeof bc; diff --git a/tests/cases/conformance/types/intersection/intersectionTypeInference.ts b/tests/cases/conformance/types/intersection/intersectionTypeInference.ts new file mode 100644 index 00000000000..3126ce09448 --- /dev/null +++ b/tests/cases/conformance/types/intersection/intersectionTypeInference.ts @@ -0,0 +1,13 @@ + +function extend(obj1: T, obj2: U): T & U { + var result: T & U; + obj1 = result; + obj2 = result; + result = obj1; // Error + result = obj2; // Error + return result; +} + +var x = extend({ a: "hello" }, { b: 42 }); +var s = x.a; +var n = x.b; diff --git a/tests/cases/conformance/types/intersection/intersectionTypeMembers.ts b/tests/cases/conformance/types/intersection/intersectionTypeMembers.ts new file mode 100644 index 00000000000..a8c92647f47 --- /dev/null +++ b/tests/cases/conformance/types/intersection/intersectionTypeMembers.ts @@ -0,0 +1,27 @@ +// An intersection type has those members that are present in any of its constituent types, +// with types that are intersections of the respective members in the constituent types + +interface A { a: string } +interface B { b: string } +interface C { c: string } + +var abc: A & B & C; +abc.a = "hello"; +abc.b = "hello"; +abc.c = "hello"; + +interface X { x: A } +interface Y { x: B } +interface Z { x: C } + +var xyz: X & Y & Z; +xyz.x.a = "hello"; +xyz.x.b = "hello"; +xyz.x.c = "hello"; + +type F1 = (x: string) => string; +type F2 = (x: number) => number; + +var f: F1 & F2; +var s = f("hello"); +var n = f(42); diff --git a/tests/cases/conformance/types/intersection/recursiveIntersectionTypes.ts b/tests/cases/conformance/types/intersection/recursiveIntersectionTypes.ts new file mode 100644 index 00000000000..d741d30ac1f --- /dev/null +++ b/tests/cases/conformance/types/intersection/recursiveIntersectionTypes.ts @@ -0,0 +1,19 @@ +type LinkedList = T & { next: LinkedList }; + +interface Entity { + name: string; +} + +interface Product extends Entity { + price: number; +} + +var entityList: LinkedList; +var s = entityList.name; +var s = entityList.next.name; +var s = entityList.next.next.name; +var s = entityList.next.next.next.name; + +var productList: LinkedList; +entityList = productList; +productList = entityList; // Error From f734055ee7522db7d3d1bced6f2ed9e68d483b80 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 25 Jun 2015 12:06:13 -0400 Subject: [PATCH 230/309] externam -> external --- ...nExternamModuleName.ts => goToDefinitionExternalModuleName.ts} | 0 ...xternamModuleName2.ts => goToDefinitionExternalModuleName2.ts} | 0 ...xternamModuleName3.ts => goToDefinitionExternalModuleName3.ts} | 0 ...xternamModuleName4.ts => goToDefinitionExternalModuleName4.ts} | 0 ...xternamModuleName5.ts => goToDefinitionExternalModuleName5.ts} | 0 ...xternamModuleName6.ts => goToDefinitionExternalModuleName6.ts} | 0 ...xternamModuleName7.ts => goToDefinitionExternalModuleName7.ts} | 0 ...xternamModuleName8.ts => goToDefinitionExternalModuleName8.ts} | 0 ...xternamModuleName9.ts => goToDefinitionExternalModuleName9.ts} | 0 9 files changed, 0 insertions(+), 0 deletions(-) rename tests/cases/fourslash/{goToDefinitionExternamModuleName.ts => goToDefinitionExternalModuleName.ts} (100%) rename tests/cases/fourslash/{goToDefinitionExternamModuleName2.ts => goToDefinitionExternalModuleName2.ts} (100%) rename tests/cases/fourslash/{goToDefinitionExternamModuleName3.ts => goToDefinitionExternalModuleName3.ts} (100%) rename tests/cases/fourslash/{goToDefinitionExternamModuleName4.ts => goToDefinitionExternalModuleName4.ts} (100%) rename tests/cases/fourslash/{goToDefinitionExternamModuleName5.ts => goToDefinitionExternalModuleName5.ts} (100%) rename tests/cases/fourslash/{goToDefinitionExternamModuleName6.ts => goToDefinitionExternalModuleName6.ts} (100%) rename tests/cases/fourslash/{goToDefinitionExternamModuleName7.ts => goToDefinitionExternalModuleName7.ts} (100%) rename tests/cases/fourslash/{goToDefinitionExternamModuleName8.ts => goToDefinitionExternalModuleName8.ts} (100%) rename tests/cases/fourslash/{goToDefinitionExternamModuleName9.ts => goToDefinitionExternalModuleName9.ts} (100%) diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName.ts diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName2.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName2.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName2.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName2.ts diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName3.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName3.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName3.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName3.ts diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName4.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName4.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName4.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName4.ts diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName5.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName5.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName5.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName5.ts diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName6.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName6.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName6.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName6.ts diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName7.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName7.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName7.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName7.ts diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName8.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName8.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName8.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName8.ts diff --git a/tests/cases/fourslash/goToDefinitionExternamModuleName9.ts b/tests/cases/fourslash/goToDefinitionExternalModuleName9.ts similarity index 100% rename from tests/cases/fourslash/goToDefinitionExternamModuleName9.ts rename to tests/cases/fourslash/goToDefinitionExternalModuleName9.ts From 6732acaa325ee42322e5fa97e2bd260f358f580d Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 25 Jun 2015 12:10:09 -0400 Subject: [PATCH 231/309] Underscore typings. --- .../fourslash/{underscoreTypings1.ts => underscoreTypings01.ts} | 0 .../fourslash/{underscoreTyping1.ts => underscoreTypings02.ts} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename tests/cases/fourslash/{underscoreTypings1.ts => underscoreTypings01.ts} (100%) rename tests/cases/fourslash/{underscoreTyping1.ts => underscoreTypings02.ts} (100%) diff --git a/tests/cases/fourslash/underscoreTypings1.ts b/tests/cases/fourslash/underscoreTypings01.ts similarity index 100% rename from tests/cases/fourslash/underscoreTypings1.ts rename to tests/cases/fourslash/underscoreTypings01.ts diff --git a/tests/cases/fourslash/underscoreTyping1.ts b/tests/cases/fourslash/underscoreTypings02.ts similarity index 100% rename from tests/cases/fourslash/underscoreTyping1.ts rename to tests/cases/fourslash/underscoreTypings02.ts From 926c25e38b3f77c3b0a558e3ade537ef6ad35f88 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 25 Jun 2015 12:14:59 -0400 Subject: [PATCH 232/309] No more 'scriptLexicalStructure'. --- ...ureBindingPatterns.ts => navigationBarItemsBindingPatterns.ts} | 0 ...uctor.ts => navigationBarItemsBindingPatternsInConstructor.ts} | 0 ...mptyConstructors.ts => navigationBarItemsEmptyConstructors.ts} | 0 ...iptLexicalStructureExports.ts => navigationBarItemsExports.ts} | 0 ...exicalStructureFunctions.ts => navigationBarItemsFunctions.ts} | 0 ...ureFunctionsBroken.ts => navigationBarItemsFunctionsBroken.ts} | 0 ...eFunctionsBroken2.ts => navigationBarItemsFunctionsBroken2.ts} | 0 ...iptLexicalStructureImports.ts => navigationBarItemsImports.ts} | 0 ...{scriptLexicalStructureItems.ts => navigationBarItemsItems.ts} | 0 ...criptLexicalStructureItems2.ts => navigationBarItemsItems2.ts} | 0 ....ts => navigationBarItemsItemsContainsNoAnonymousFunctions.ts} | 0 ...ternalModules.ts => navigationBarItemsItemsExternalModules.ts} | 0 ...rnalModules2.ts => navigationBarItemsItemsExternalModules2.ts} | 0 ...rnalModules3.ts => navigationBarItemsItemsExternalModules3.ts} | 0 ...duleVariables.ts => navigationBarItemsItemsModuleVariables.ts} | 0 ...StructureMissingName1.ts => navigationBarItemsMissingName1.ts} | 0 ...StructureMissingName2.ts => navigationBarItemsMissingName2.ts} | 0 ...iptLexicalStructureModules.ts => navigationBarItemsModules.ts} | 0 ...tifiers.ts => navigationBarItemsMultilineStringIdentifiers.ts} | 0 ...rs.ts => navigationBarItemsPropertiesDefinedInConstructors.ts} | 0 ...tLexicalStructureSymbols1.ts => navigationBarItemsSymbols1.ts} | 0 ...tLexicalStructureSymbols2.ts => navigationBarItemsSymbols2.ts} | 0 ...tLexicalStructureSymbols3.ts => navigationBarItemsSymbols3.ts} | 0 23 files changed, 0 insertions(+), 0 deletions(-) rename tests/cases/fourslash/{scriptLexicalStructureBindingPatterns.ts => navigationBarItemsBindingPatterns.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureBindingPatternsInConstructor.ts => navigationBarItemsBindingPatternsInConstructor.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureEmptyConstructors.ts => navigationBarItemsEmptyConstructors.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureExports.ts => navigationBarItemsExports.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureFunctions.ts => navigationBarItemsFunctions.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureFunctionsBroken.ts => navigationBarItemsFunctionsBroken.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureFunctionsBroken2.ts => navigationBarItemsFunctionsBroken2.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureImports.ts => navigationBarItemsImports.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureItems.ts => navigationBarItemsItems.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureItems2.ts => navigationBarItemsItems2.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureItemsContainsNoAnonymousFunctions.ts => navigationBarItemsItemsContainsNoAnonymousFunctions.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureItemsExternalModules.ts => navigationBarItemsItemsExternalModules.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureItemsExternalModules2.ts => navigationBarItemsItemsExternalModules2.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureItemsExternalModules3.ts => navigationBarItemsItemsExternalModules3.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureItemsModuleVariables.ts => navigationBarItemsItemsModuleVariables.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureMissingName1.ts => navigationBarItemsMissingName1.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureMissingName2.ts => navigationBarItemsMissingName2.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureModules.ts => navigationBarItemsModules.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureMultilineStringIdentifiers.ts => navigationBarItemsMultilineStringIdentifiers.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructurePropertiesDefinedInConstructors.ts => navigationBarItemsPropertiesDefinedInConstructors.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureSymbols1.ts => navigationBarItemsSymbols1.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureSymbols2.ts => navigationBarItemsSymbols2.ts} (100%) rename tests/cases/fourslash/{scriptLexicalStructureSymbols3.ts => navigationBarItemsSymbols3.ts} (100%) diff --git a/tests/cases/fourslash/scriptLexicalStructureBindingPatterns.ts b/tests/cases/fourslash/navigationBarItemsBindingPatterns.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureBindingPatterns.ts rename to tests/cases/fourslash/navigationBarItemsBindingPatterns.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureBindingPatternsInConstructor.ts b/tests/cases/fourslash/navigationBarItemsBindingPatternsInConstructor.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureBindingPatternsInConstructor.ts rename to tests/cases/fourslash/navigationBarItemsBindingPatternsInConstructor.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureEmptyConstructors.ts b/tests/cases/fourslash/navigationBarItemsEmptyConstructors.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureEmptyConstructors.ts rename to tests/cases/fourslash/navigationBarItemsEmptyConstructors.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureExports.ts b/tests/cases/fourslash/navigationBarItemsExports.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureExports.ts rename to tests/cases/fourslash/navigationBarItemsExports.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureFunctions.ts b/tests/cases/fourslash/navigationBarItemsFunctions.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureFunctions.ts rename to tests/cases/fourslash/navigationBarItemsFunctions.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureFunctionsBroken.ts b/tests/cases/fourslash/navigationBarItemsFunctionsBroken.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureFunctionsBroken.ts rename to tests/cases/fourslash/navigationBarItemsFunctionsBroken.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureFunctionsBroken2.ts b/tests/cases/fourslash/navigationBarItemsFunctionsBroken2.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureFunctionsBroken2.ts rename to tests/cases/fourslash/navigationBarItemsFunctionsBroken2.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureImports.ts b/tests/cases/fourslash/navigationBarItemsImports.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureImports.ts rename to tests/cases/fourslash/navigationBarItemsImports.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureItems.ts b/tests/cases/fourslash/navigationBarItemsItems.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureItems.ts rename to tests/cases/fourslash/navigationBarItemsItems.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureItems2.ts b/tests/cases/fourslash/navigationBarItemsItems2.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureItems2.ts rename to tests/cases/fourslash/navigationBarItemsItems2.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureItemsContainsNoAnonymousFunctions.ts b/tests/cases/fourslash/navigationBarItemsItemsContainsNoAnonymousFunctions.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureItemsContainsNoAnonymousFunctions.ts rename to tests/cases/fourslash/navigationBarItemsItemsContainsNoAnonymousFunctions.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureItemsExternalModules.ts b/tests/cases/fourslash/navigationBarItemsItemsExternalModules.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureItemsExternalModules.ts rename to tests/cases/fourslash/navigationBarItemsItemsExternalModules.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureItemsExternalModules2.ts b/tests/cases/fourslash/navigationBarItemsItemsExternalModules2.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureItemsExternalModules2.ts rename to tests/cases/fourslash/navigationBarItemsItemsExternalModules2.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureItemsExternalModules3.ts b/tests/cases/fourslash/navigationBarItemsItemsExternalModules3.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureItemsExternalModules3.ts rename to tests/cases/fourslash/navigationBarItemsItemsExternalModules3.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureItemsModuleVariables.ts b/tests/cases/fourslash/navigationBarItemsItemsModuleVariables.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureItemsModuleVariables.ts rename to tests/cases/fourslash/navigationBarItemsItemsModuleVariables.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureMissingName1.ts b/tests/cases/fourslash/navigationBarItemsMissingName1.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureMissingName1.ts rename to tests/cases/fourslash/navigationBarItemsMissingName1.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureMissingName2.ts b/tests/cases/fourslash/navigationBarItemsMissingName2.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureMissingName2.ts rename to tests/cases/fourslash/navigationBarItemsMissingName2.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureModules.ts b/tests/cases/fourslash/navigationBarItemsModules.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureModules.ts rename to tests/cases/fourslash/navigationBarItemsModules.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureMultilineStringIdentifiers.ts b/tests/cases/fourslash/navigationBarItemsMultilineStringIdentifiers.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureMultilineStringIdentifiers.ts rename to tests/cases/fourslash/navigationBarItemsMultilineStringIdentifiers.ts diff --git a/tests/cases/fourslash/scriptLexicalStructurePropertiesDefinedInConstructors.ts b/tests/cases/fourslash/navigationBarItemsPropertiesDefinedInConstructors.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructurePropertiesDefinedInConstructors.ts rename to tests/cases/fourslash/navigationBarItemsPropertiesDefinedInConstructors.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureSymbols1.ts b/tests/cases/fourslash/navigationBarItemsSymbols1.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureSymbols1.ts rename to tests/cases/fourslash/navigationBarItemsSymbols1.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureSymbols2.ts b/tests/cases/fourslash/navigationBarItemsSymbols2.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureSymbols2.ts rename to tests/cases/fourslash/navigationBarItemsSymbols2.ts diff --git a/tests/cases/fourslash/scriptLexicalStructureSymbols3.ts b/tests/cases/fourslash/navigationBarItemsSymbols3.ts similarity index 100% rename from tests/cases/fourslash/scriptLexicalStructureSymbols3.ts rename to tests/cases/fourslash/navigationBarItemsSymbols3.ts From c04bc692d45f43ec6f428a2477122d98aae2efb7 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 25 Jun 2015 13:21:58 -0400 Subject: [PATCH 233/309] Fixed coment. --- tests/cases/compiler/numLit.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/cases/compiler/numLit.ts b/tests/cases/compiler/numLit.ts index abe3505703d..23cd2ba45f8 100644 --- a/tests/cases/compiler/numLit.ts +++ b/tests/cases/compiler/numLit.ts @@ -6,7 +6,7 @@ // Preserve whitespace where important for JS compatibility var i: number = 1; var test1 = i.toString(); -var test2 = 2.toString(); // emitted as 2 .toString() +var test2 = 2.toString(); var test3 = 3 .toString(); var test4 = 3 .toString(); var test5 = 3 .toString(); From eda3956fa25d25444de843c83df46e9e143bec8f Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 25 Jun 2015 13:34:31 -0400 Subject: [PATCH 234/309] Accepted baselines. --- tests/baselines/reference/numLit.errors.txt | 2 +- tests/baselines/reference/numLit.js | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/baselines/reference/numLit.errors.txt b/tests/baselines/reference/numLit.errors.txt index 17392011fa6..603f655fe84 100644 --- a/tests/baselines/reference/numLit.errors.txt +++ b/tests/baselines/reference/numLit.errors.txt @@ -15,7 +15,7 @@ tests/cases/compiler/numLit.ts(9,24): error TS1109: Expression expected. // Preserve whitespace where important for JS compatibility var i: number = 1; var test1 = i.toString(); - var test2 = 2.toString(); // emitted as 2 .toString() + var test2 = 2.toString(); ~~~~~~~~ !!! error TS1005: ',' expected. ~ diff --git a/tests/baselines/reference/numLit.js b/tests/baselines/reference/numLit.js index c68d6925faa..add93ed0a6a 100644 --- a/tests/baselines/reference/numLit.js +++ b/tests/baselines/reference/numLit.js @@ -7,7 +7,7 @@ // Preserve whitespace where important for JS compatibility var i: number = 1; var test1 = i.toString(); -var test2 = 2.toString(); // emitted as 2 .toString() +var test2 = 2.toString(); var test3 = 3 .toString(); var test4 = 3 .toString(); var test5 = 3 .toString(); @@ -27,7 +27,7 @@ toString(); // Preserve whitespace where important for JS compatibility var i = 1; var test1 = i.toString(); -var test2 = 2., toString = (); // emitted as 2 .toString() +var test2 = 2., toString = (); var test3 = 3 .toString(); var test4 = 3 .toString(); var test5 = 3 .toString(); From ec2d5f3a0d9785d415bae02ba88ab1bb09e9ebf3 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 25 Jun 2015 13:38:42 -0400 Subject: [PATCH 235/309] Renamed test. --- ...ericLiteralsWithTrailingDecimalPoints01.errors.txt} | 10 +++++----- ...s => numericLiteralsWithTrailingDecimalPoints01.js} | 4 ++-- ...s => numericLiteralsWithTrailingDecimalPoints01.ts} | 0 3 files changed, 7 insertions(+), 7 deletions(-) rename tests/baselines/reference/{numLit.errors.txt => numericLiteralsWithTrailingDecimalPoints01.errors.txt} (56%) rename tests/baselines/reference/{numLit.js => numericLiteralsWithTrailingDecimalPoints01.js} (86%) rename tests/cases/compiler/{numLit.ts => numericLiteralsWithTrailingDecimalPoints01.ts} (100%) diff --git a/tests/baselines/reference/numLit.errors.txt b/tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.errors.txt similarity index 56% rename from tests/baselines/reference/numLit.errors.txt rename to tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.errors.txt index 603f655fe84..f08750ff0a6 100644 --- a/tests/baselines/reference/numLit.errors.txt +++ b/tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.errors.txt @@ -1,10 +1,10 @@ -tests/cases/compiler/numLit.ts(3,3): error TS1005: ';' expected. -tests/cases/compiler/numLit.ts(9,15): error TS1005: ',' expected. -tests/cases/compiler/numLit.ts(9,23): error TS1005: '=' expected. -tests/cases/compiler/numLit.ts(9,24): error TS1109: Expression expected. +tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts(3,3): error TS1005: ';' expected. +tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts(9,15): error TS1005: ',' expected. +tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts(9,23): error TS1005: '=' expected. +tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts(9,24): error TS1109: Expression expected. -==== tests/cases/compiler/numLit.ts (4 errors) ==== +==== tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts (4 errors) ==== 1..toString(); 1.0.toString(); 1.toString(); diff --git a/tests/baselines/reference/numLit.js b/tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.js similarity index 86% rename from tests/baselines/reference/numLit.js rename to tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.js index add93ed0a6a..0b1ce1f0736 100644 --- a/tests/baselines/reference/numLit.js +++ b/tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.js @@ -1,4 +1,4 @@ -//// [numLit.ts] +//// [numericLiteralsWithTrailingDecimalPoints01.ts] 1..toString(); 1.0.toString(); 1.toString(); @@ -18,7 +18,7 @@ var test8 = new Number(4).toString(); var test9 = 3. + 3. -//// [numLit.js] +//// [numericLiteralsWithTrailingDecimalPoints01.js] 1..toString(); 1.0.toString(); 1.; diff --git a/tests/cases/compiler/numLit.ts b/tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts similarity index 100% rename from tests/cases/compiler/numLit.ts rename to tests/cases/compiler/numericLiteralsWithTrailingDecimalPoints01.ts From f8b95a5acf5162ca6e35328e67aaf7852657c6a8 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 25 Jun 2015 10:41:39 -0700 Subject: [PATCH 236/309] Drafting constructor assignability restrictions --- src/compiler/checker.ts | 14 ++++++++++++++ src/compiler/diagnosticInformationMap.generated.ts | 1 + src/compiler/diagnosticMessages.json | 4 ++++ 3 files changed, 19 insertions(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index cc23103403e..9c810809f0f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4553,6 +4553,9 @@ namespace ts { result &= stringIndexTypesRelatedTo(source, target, reportErrors); if (result) { result &= numberIndexTypesRelatedTo(source, target, reportErrors); + // if(relation == subtypeRelation && result) { + // result &= abstractnessRelatedTo(source, target, reportErrors); + // } } } } @@ -4574,6 +4577,17 @@ namespace ts { return result; } + function abstractnessRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary { + if ( source.symbol && target.symbol && getDeclarationFlagsFromSymbol(source.symbol) & NodeFlags.Abstract && + !(getDeclarationFlagsFromSymbol(target.symbol) & NodeFlags.Abstract)) { + if (reportErrors) { + reportError(Diagnostics.Constructor_objects_of_abstract_type_cannot_be_assigned_to_constructor_objects_of_non_abstract_type); + } + return Ternary.False; + } + return Ternary.True; + } + function propertiesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary { if (relation === identityRelation) { return propertiesIdenticalTo(source, target); diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 853ee81359c..89c6e8bf109 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -399,6 +399,7 @@ namespace ts { Classes_containing_abstract_methods_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract methods must be marked abstract." }, Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'." }, All_declarations_of_an_abstract_method_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract method must be consecutive." }, + Constructor_objects_of_abstract_type_cannot_be_assigned_to_constructor_objects_of_non_abstract_type: { code: 2517, category: DiagnosticCategory.Error, key: "Constructor objects of abstract type cannot be assigned to constructor objects of non-abstract type" }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 3605bae6900..fa50f5cdcc5 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1583,6 +1583,10 @@ "category": "Error", "code": 2516 }, + "Constructor objects of abstract type cannot be assigned to constructor objects of non-abstract type": { + "category": "Error", + "code":2517 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 From 8180b7d06f6389783fd62e508683c7608475d3be Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 25 Jun 2015 11:14:45 -0700 Subject: [PATCH 237/309] Don't error on JSX elements when JSX.Element isn't present --- src/compiler/checker.ts | 12 +- .../diagnosticInformationMap.generated.ts | 2 +- src/compiler/diagnosticMessages.json | 2 +- .../reference/jsxAndTypeAssertion.errors.txt | 69 +--- .../jsxEsprimaFbTestSuite.errors.txt | 131 ------- .../reference/jsxEsprimaFbTestSuite.symbols | 92 +++++ .../reference/jsxEsprimaFbTestSuite.types | 160 +++++++++ .../jsxInvalidEsprimaTestSuite.errors.txt | 92 +---- .../reference/jsxReactTestSuite.errors.txt | 246 ------------- .../reference/jsxReactTestSuite.symbols | 194 ++++++++++ .../reference/jsxReactTestSuite.types | 332 ++++++++++++++++++ .../reference/tsxElementResolution.errors.txt | 40 --- .../reference/tsxElementResolution.symbols | 51 +++ .../reference/tsxElementResolution.types | 56 +++ .../tsxElementResolution16.errors.txt | 11 +- .../reference/tsxElementResolution16.js | 4 +- .../reference/tsxElementResolution16.symbols | 18 + .../reference/tsxElementResolution16.types | 20 ++ tests/baselines/reference/tsxNoJsx.errors.txt | 9 - tests/baselines/reference/tsxNoJsx.symbols | 5 + tests/baselines/reference/tsxNoJsx.types | 6 + .../reference/tsxTypeErrors.errors.txt | 55 --- .../baselines/reference/tsxTypeErrors.symbols | 65 ++++ tests/baselines/reference/tsxTypeErrors.types | 82 +++++ .../jsx/tsxElementResolution16.tsx | 3 +- .../conformance/jsx/tsxInArrowFunction.tsx | 23 ++ 26 files changed, 1126 insertions(+), 654 deletions(-) delete mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt create mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.symbols create mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.types delete mode 100644 tests/baselines/reference/jsxReactTestSuite.errors.txt create mode 100644 tests/baselines/reference/jsxReactTestSuite.symbols create mode 100644 tests/baselines/reference/jsxReactTestSuite.types delete mode 100644 tests/baselines/reference/tsxElementResolution.errors.txt create mode 100644 tests/baselines/reference/tsxElementResolution.symbols create mode 100644 tests/baselines/reference/tsxElementResolution.types create mode 100644 tests/baselines/reference/tsxElementResolution16.symbols create mode 100644 tests/baselines/reference/tsxElementResolution16.types delete mode 100644 tests/baselines/reference/tsxNoJsx.errors.txt create mode 100644 tests/baselines/reference/tsxNoJsx.symbols create mode 100644 tests/baselines/reference/tsxNoJsx.types delete mode 100644 tests/baselines/reference/tsxTypeErrors.errors.txt create mode 100644 tests/baselines/reference/tsxTypeErrors.symbols create mode 100644 tests/baselines/reference/tsxTypeErrors.types create mode 100644 tests/cases/conformance/jsx/tsxInArrowFunction.tsx diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index dd3b29f25e3..101b8ceb23c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3800,7 +3800,7 @@ namespace ts { function getExportedTypeFromNamespace(namespace: string, name: string): Type { var namespaceSymbol = getGlobalSymbol(namespace, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined); var typeSymbol = namespaceSymbol && getSymbol(namespaceSymbol.exports, name, SymbolFlags.Type); - return (typeSymbol && getDeclaredTypeOfSymbol(typeSymbol)) || unknownType; + return typeSymbol && getDeclaredTypeOfSymbol(typeSymbol); } function getGlobalESSymbolConstructorSymbol() { @@ -6712,7 +6712,7 @@ namespace ts { function checkJsxSelfClosingElement(node: JsxSelfClosingElement) { checkJsxOpeningLikeElement(node); - return jsxElementType; + return jsxElementType || anyType; } function tagNamesAreEquivalent(lhs: EntityName, rhs: EntityName): boolean { @@ -6755,7 +6755,7 @@ namespace ts { } } - return jsxElementType; + return jsxElementType || anyType; } /** @@ -7087,8 +7087,10 @@ namespace ts { error(errorNode, Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided); } - if (jsxElementType === unknownType) { - error(errorNode, Diagnostics.The_global_type_JSX_Element_must_exist_when_using_JSX); + if (jsxElementType === undefined) { + if(compilerOptions.noImplicitAny) { + error(errorNode, Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist); + } } } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 0d908973594..674d6831904 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -391,7 +391,7 @@ namespace ts { Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, JSX_element_attributes_type_0_must_be_an_object_type: { code: 2600, category: DiagnosticCategory.Error, key: "JSX element attributes type '{0}' must be an object type." }, The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: { code: 2601, category: DiagnosticCategory.Error, key: "The return type of a JSX element constructor must return an object type." }, - The_global_type_JSX_Element_must_exist_when_using_JSX: { code: 2602, category: DiagnosticCategory.Error, key: "The global type 'JSX.Element' must exist when using JSX." }, + JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: { code: 2602, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist." }, Property_0_in_type_1_is_not_assignable_to_type_2: { code: 2603, category: DiagnosticCategory.Error, key: "Property '{0}' in type '{1}' is not assignable to type '{2}'" }, JSX_element_type_0_does_not_have_any_construct_or_call_signatures: { code: 2604, category: DiagnosticCategory.Error, key: "JSX element type '{0}' does not have any construct or call signatures." }, JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements: { code: 2605, category: DiagnosticCategory.Error, key: "JSX element type '{0}' is not a constructor function for JSX elements." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 21e352af339..468f162ce3f 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1554,7 +1554,7 @@ "category": "Error", "code": 2601 }, - "The global type 'JSX.Element' must exist when using JSX.": { + "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist.": { "category": "Error", "code": 2602 }, diff --git a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt index ead030952a5..aebabf15133 100644 --- a/tests/baselines/reference/jsxAndTypeAssertion.errors.txt +++ b/tests/baselines/reference/jsxAndTypeAssertion.errors.txt @@ -1,34 +1,14 @@ -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,13): error TS2304: Cannot find name 'test'. tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,17): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(7,19): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(9,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(9,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,17): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(11,32): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(13,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(13,16): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(13,36): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,16): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,31): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(15,45): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(17,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(17,23): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,7): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,12): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,34): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,39): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,53): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(19,58): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS1005: ':' expected. tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expected corresponding JSX closing tag for 'any'. tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expected corresponding JSX closing tag for 'foo'. -==== tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx (28 errors) ==== +==== tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx (8 errors) ==== declare var createElement: any; @@ -36,79 +16,32 @@ tests/cases/conformance/jsx/jsxAndTypeAssertion.tsx(22,1): error TS17002: Expect var x: any; x = { test: }; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~~ !!! error TS2304: Cannot find name 'test'. ~ !!! error TS1005: '}' expected. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. x = ; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. x = hello {{}} ; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1005: '}' expected. x = {}}>hello; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1005: '}' expected. x = {}}>hello{{}}; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1005: '}' expected. - x = x, x = ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - {{/foo/.test(x) ? : }} - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - !!! error TS1005: ':' expected. !!! error TS17002: Expected corresponding JSX closing tag for 'any'. diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt b/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt deleted file mode 100644 index b6c083e3309..00000000000 --- a/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt +++ /dev/null @@ -1,131 +0,0 @@ -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(9,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(15,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(17,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(18,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(21,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(23,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(29,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(29,11): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(29,19): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(31,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(33,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(35,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(37,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(37,6): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,17): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,29): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(41,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(43,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(45,2): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(47,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(49,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(51,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(53,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. - - -==== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx (24 errors) ==== - declare var React: any; - declare var 日本語; - declare var AbC_def; - declare var LeftRight; - declare var x; - declare var a; - declare var props; - - ; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - //; Namespace unsuported - - // {value} ; Namespace unsuported - - ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ; - ~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - <日本語>; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - - ~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - bar - baz - ; - - : } />; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - {}; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - {/* this is a comment */}; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - -
@test content
; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - -

7x invalid-js-identifier
; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - right=monkeys /> gorillas />; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - (
) < x; - ~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - -
; - ~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - -
; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - -
; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - \ No newline at end of file diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols b/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols new file mode 100644 index 00000000000..570bf89f0a4 --- /dev/null +++ b/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols @@ -0,0 +1,92 @@ +=== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx === +declare var React: any; +>React : Symbol(React, Decl(jsxEsprimaFbTestSuite.tsx, 0, 11)) + +declare var 日本語; +>日本語 : Symbol(日本語, Decl(jsxEsprimaFbTestSuite.tsx, 1, 11)) + +declare var AbC_def; +>AbC_def : Symbol(AbC_def, Decl(jsxEsprimaFbTestSuite.tsx, 2, 11)) + +declare var LeftRight; +>LeftRight : Symbol(LeftRight, Decl(jsxEsprimaFbTestSuite.tsx, 3, 11)) + +declare var x; +>x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) + +declare var a; +>a : Symbol(a, Decl(jsxEsprimaFbTestSuite.tsx, 5, 11)) + +declare var props; +>props : Symbol(props, Decl(jsxEsprimaFbTestSuite.tsx, 6, 11)) + +; + +//; Namespace unsuported + +// {value} ; Namespace unsuported + +; +>b : Symbol(unknown) +>c : Symbol(unknown) +>d : Symbol(unknown) +>e : Symbol(unknown) +>f : Symbol(unknown) +>g : Symbol(unknown) +>h : Symbol(unknown) + +; +>b : Symbol(unknown) + +; + +<日本語>; + +AbC_def : Symbol(AbC_def, Decl(jsxEsprimaFbTestSuite.tsx, 2, 11)) + + test="&&"> +>test : Symbol(unknown) + +bar +baz +; + + : } />; +>b : Symbol(unknown) +>x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) + +{}; + +{/* this is a comment */}; + +
@test content
; + +

7x invalid-js-identifier
; + + right=monkeys /> gorillas />; +>LeftRight : Symbol(LeftRight, Decl(jsxEsprimaFbTestSuite.tsx, 3, 11)) +>left : Symbol(unknown) +>right : Symbol(unknown) + +; +>b : Symbol(unknown) + +; +>c : Symbol(unknown) + +(
) < x; +>x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) + +
; + +
; +>post : Symbol(unknown) + +
; +>pre : Symbol(unknown) +>pre2 : Symbol(unknown) + + ; + diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.types b/tests/baselines/reference/jsxEsprimaFbTestSuite.types new file mode 100644 index 00000000000..f32d62fd03f --- /dev/null +++ b/tests/baselines/reference/jsxEsprimaFbTestSuite.types @@ -0,0 +1,160 @@ +=== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx === +declare var React: any; +>React : any + +declare var 日本語; +>日本語 : any + +declare var AbC_def; +>AbC_def : any + +declare var LeftRight; +>LeftRight : any + +declare var x; +>x : any + +declare var a; +>a : any + +declare var props; +>props : any + +; +> : any +>a : any + +//; Namespace unsuported + +// {value} ; Namespace unsuported + +; +> : any +>a : any +>b : any +>c : any +>d : any +>e : any +>f : any +>g : any +>h : any + +; +> : any +>a : any +>b : any + + : any +>a : any + +/>; + +<日本語>; +><日本語> : any +>日本語 : any +>日本語 : any + +barbaz : any +>AbC_def : any + + test="&&"> +>test : any + +bar +baz +; +>AbC_def : any + + : } />; +> : } /> : any +>a : any +>b : any +>x ? : : any +>x : any +> : any +>c : any +> : any +>d : any + +{}; +>{} : any +>a : any +>a : any + +{/* this is a comment */}; +>{/* this is a comment */} : any +>a : any +>a : any + +
@test content
; +>
@test content
: any +>div : any +>div : any + +

7x invalid-js-identifier
; +>

7x invalid-js-identifier
: any +>div : any +>
: any +>br : any +>div : any + + right=monkeys /> gorillas />; +> right=monkeys /> gorillas /> : any +>LeftRight : any +>left : any +> : any +>a : any +>right : any +>monkeys /> gorillas : any +>b : any +>b : any + +; +> : any +>a : any +>b : any +>a : any +>b : any + +; +> : any +>a : any +>b : any +>c : any +>a : any +>b : any +>c : any + +(
) < x; +>(
) < x : boolean +>(
) : any +>
: any +>div : any +>x : any + +
; +>
: any +>div : any +>props : any + +
; +>
: any +>div : any +>props : any +>post : any + +
; +>
: any +>div : any +>pre : any +>pre2 : any +>props : any +>div : any + + ; +> : any +>a : any +>a : any + diff --git a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt index f509044703a..e63809913f2 100644 --- a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt +++ b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt @@ -1,14 +1,12 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,1): error TS1128: Declaration or statement expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,3): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(3,4): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(4,3): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,1): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,2): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,3): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,6): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(5,7): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,6): error TS1005: '{' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,6): error TS2304: Cannot find name 'd'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,9): error TS1109: Expression expected. @@ -16,9 +14,7 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(6,10): error TS1109: tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,1): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,2): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(7,4): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(8,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(8,4): error TS17002: Expected corresponding JSX closing tag for 'a'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(9,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(9,13): error TS1002: Unterminated string literal. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,1): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,2): error TS2304: Cannot find name 'a'. @@ -27,19 +23,16 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,4): error TS2304: tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,6): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,8): error TS2304: Cannot find name 'b'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(10,10): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,3): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,5): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,11): error TS1005: '>' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,12): error TS2304: Cannot find name 'b'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(11,16): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,2): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,5): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,13): error TS1005: '>' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,14): error TS2304: Cannot find name 'c'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(12,16): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,2): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(13,8): error TS17002: Expected corresponding JSX closing tag for 'a.b.c'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,1): error TS1109: Expression expected. @@ -48,59 +41,36 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,5): error TS1109: tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,7): error TS1128: Declaration or statement expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,8): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(14,10): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,2): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,4): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(15,9): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,3): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,4): error TS2304: Cannot find name 'foo'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,9): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,11): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,13): error TS2304: Cannot find name 'foo'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(16,18): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,3): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,11): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,13): error TS2304: Cannot find name 'a'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(17,22): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(18,4): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(19,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(20,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(20,23): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(21,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(21,50): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(22,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(22,10): error TS1005: '}' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(23,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(23,20): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(24,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(24,15): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(25,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(25,7): error TS1005: '...' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(25,7): error TS2304: Cannot find name 'props'. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(27,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(27,17): error TS1005: '>' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(27,18): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,10): error TS2304: Cannot find name 'props'. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,28): error TS1005: '>' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,29): error TS1109: Expression expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(30,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(31,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(32,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(32,6): error TS1005: '{' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,6): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,7): error TS1003: Identifier expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(34,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,4): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002: Expected corresponding JSX closing tag for 'a'. -==== tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx (100 errors) ==== +==== tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx (70 errors) ==== declare var React: any; ; @@ -111,8 +81,6 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 ~ !!! error TS1109: Expression expected. ; - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1003: Identifier expected. <:a />; @@ -127,8 +95,6 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 ~ !!! error TS1109: Expression expected. ; - ~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1005: '{' expected. ~ @@ -145,13 +111,9 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 ~ !!! error TS1109: Expression expected. ; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~~ !!! error TS17002: Expected corresponding JSX closing tag for 'a'. ; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1005: '}' expected. ; - ~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1003: Identifier expected.
; - ~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~~~ !!! error TS1003: Identifier expected.
; - ~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~~~ !!! error TS1005: '...' expected. ~~~~~ !!! error TS2304: Cannot find name 'props'.
stuff
; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1005: '>' expected. ~~~ !!! error TS1109: Expression expected.
stuff
; - ~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~~~ !!! error TS2304: Cannot find name 'props'. ~ @@ -309,29 +233,15 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 !!! error TS1109: Expression expected. >; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. >; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ; - ~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1005: '{' expected. ; - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~ !!! error TS1003: Identifier expected. }; - ~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ; - ~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. ~~~ !!! error TS1003: Identifier expected. diff --git a/tests/baselines/reference/jsxReactTestSuite.errors.txt b/tests/baselines/reference/jsxReactTestSuite.errors.txt deleted file mode 100644 index 4e9e5c42492..00000000000 --- a/tests/baselines/reference/jsxReactTestSuite.errors.txt +++ /dev/null @@ -1,246 +0,0 @@ -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(15,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(17,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(21,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(22,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(22,8): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(23,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(23,19): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(24,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(28,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(32,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(33,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(37,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(55,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(58,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(62,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(69,3): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(73,5): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(79,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(81,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(83,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(85,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(87,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(89,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(91,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(94,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(97,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(99,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(101,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(103,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(105,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(107,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(109,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(112,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(112,38): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/jsxReactTestSuite.tsx(114,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. - - -==== tests/cases/conformance/jsx/jsxReactTestSuite.tsx (35 errors) ==== - - declare var React: any; - declare var Component:any; - declare var Composite:any; - declare var Composite2:any; - declare var Child:any; - declare var Namespace:any; - declare var foo: any; - declare var bar: any; - declare var y:any; - declare var x:any; - declare var z:any; - declare var hasOwnProperty:any; - -
text
; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - -
- ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - {this.props.children} -
; - -
- ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. -

- ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - {foo}
{bar} - ~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. -
- ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. -
; - - - - ~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - {this.props.children} - ; - - - ~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ; - - var x = -
- ~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. -
; - - ( -
- ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - {/* A comment at the beginning */} - {/* A second comment at the beginning */} - - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - {/* A nested comment */} - - {/* A sandwiched comment */} -
- ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - {/* A comment at the end */} - {/* A second comment at the end */} -
- ); - - ( -
- ~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. -
- ); - -
 
; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - -
 
; - ~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - testing; - ~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - - ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - ~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - Text; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - - \ No newline at end of file diff --git a/tests/baselines/reference/jsxReactTestSuite.symbols b/tests/baselines/reference/jsxReactTestSuite.symbols new file mode 100644 index 00000000000..9e382742f0d --- /dev/null +++ b/tests/baselines/reference/jsxReactTestSuite.symbols @@ -0,0 +1,194 @@ +=== tests/cases/conformance/jsx/jsxReactTestSuite.tsx === + +declare var React: any; +>React : Symbol(React, Decl(jsxReactTestSuite.tsx, 1, 11)) + +declare var Component:any; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) + +declare var Composite:any; +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) + +declare var Composite2:any; +>Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 4, 11)) + +declare var Child:any; +>Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 5, 11)) + +declare var Namespace:any; +>Namespace : Symbol(Namespace, Decl(jsxReactTestSuite.tsx, 6, 11)) + +declare var foo: any; +>foo : Symbol(foo, Decl(jsxReactTestSuite.tsx, 7, 11)) + +declare var bar: any; +>bar : Symbol(bar, Decl(jsxReactTestSuite.tsx, 8, 11)) + +declare var y:any; +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 9, 11)) + +declare var x:any; +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) + +declare var z:any; +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) + +declare var hasOwnProperty:any; +>hasOwnProperty : Symbol(hasOwnProperty, Decl(jsxReactTestSuite.tsx, 12, 11)) + +
text
; + +
+ {this.props.children} +
; + +
+

+ {foo}
{bar} +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) + +
+
; + + + +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) + + {this.props.children} +; + + +>Composite : Symbol(Composite, Decl(jsxReactTestSuite.tsx, 3, 11)) + + +>Composite2 : Symbol(Composite2, Decl(jsxReactTestSuite.tsx, 4, 11)) + +; + +var x = +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) + +
attr1 : Symbol(unknown) + + "foo" + "bar" + } + attr2={ +>attr2 : Symbol(unknown) + + "foo" + "bar" + + + "baz" + "bug" + } + attr3={ +>attr3 : Symbol(unknown) + + "foo" + "bar" + + "baz" + "bug" + // Extra line here. + } + attr4="baz"> +>attr4 : Symbol(unknown) + +
; + +( +
+ {/* A comment at the beginning */} + {/* A second comment at the beginning */} + + {/* A nested comment */} + + {/* A sandwiched comment */} +
+ {/* A comment at the end */} + {/* A second comment at the end */} +
+); + +( +
+>attr1 : Symbol(unknown) + + attr2 : Symbol(unknown) + + /> +
+); + +
 
; + +
 
; + +testing; + +; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>constructor : Symbol(unknown) + +; +>Component : Symbol(unknown) + +; +>Component : Symbol(unknown) + +Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>y : Symbol(unknown) + +={2 } z />; +>z : Symbol(unknown) + +Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) + + {...this.props} sound="moo" />; +>sound : Symbol(unknown) + +; + +; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>x : Symbol(unknown) + +; + +; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) + +; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>y : Symbol(unknown) + +; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>y : Symbol(unknown) +>z : Symbol(unknown) + +; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>x : Symbol(unknown) + + +; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>x : Symbol(unknown) +>y : Symbol(unknown) +>Child : Symbol(Child, Decl(jsxReactTestSuite.tsx, 5, 11)) + +Text; +>Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>x : Symbol(unknown) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 113, 27)) +>z : Symbol(z, Decl(jsxReactTestSuite.tsx, 11, 11)) +>z : Symbol(unknown) + + + diff --git a/tests/baselines/reference/jsxReactTestSuite.types b/tests/baselines/reference/jsxReactTestSuite.types new file mode 100644 index 00000000000..db7ebf8d912 --- /dev/null +++ b/tests/baselines/reference/jsxReactTestSuite.types @@ -0,0 +1,332 @@ +=== tests/cases/conformance/jsx/jsxReactTestSuite.tsx === + +declare var React: any; +>React : any + +declare var Component:any; +>Component : any + +declare var Composite:any; +>Composite : any + +declare var Composite2:any; +>Composite2 : any + +declare var Child:any; +>Child : any + +declare var Namespace:any; +>Namespace : any + +declare var foo: any; +>foo : any + +declare var bar: any; +>bar : any + +declare var y:any; +>y : any + +declare var x:any; +>x : any + +declare var z:any; +>z : any + +declare var hasOwnProperty:any; +>hasOwnProperty : any + +
text
; +>
text
: any +>div : any +>div : any + +
+>
{this.props.children}
: any +>div : any + + {this.props.children} +>this.props.children : any +>this.props : any +>this : any +>props : any +>children : any + +
; +>div : any + +
+>

{foo}
{bar}
: any +>div : any + +

+>

: any +>div : any +>
: any +>br : any +>div : any + + {foo}
{bar} +>{foo}
{bar} : any +>Component : any +>foo : any +>
: any +>br : any +>bar : any +>Component : any + +
+>
: any +>br : any + +
; +>div : any + + + +> {this.props.children} : any +>Composite : any + + {this.props.children} +>this.props.children : any +>this.props : any +>this : any +>props : any +>children : any + +; +>Composite : any + + +> : any +>Composite : any + + +> : any +>Composite2 : any + +; +>Composite : any + +var x = +>x : any + +
: any +>div : any + + attr1={ +>attr1 : any + + "foo" + "bar" +>"foo" + "bar" : string +>"foo" : string +>"bar" : string + } + attr2={ +>attr2 : any + + "foo" + "bar" + +>"foo" + "bar" + "baz" + "bug" : string +>"foo" + "bar" + "baz" : string +>"foo" + "bar" : string +>"foo" : string +>"bar" : string + + "baz" + "bug" +>"baz" : string +>"bug" : string + } + attr3={ +>attr3 : any + + "foo" + "bar" + +>"foo" + "bar" + "baz" + "bug" : string +>"foo" + "bar" + "baz" : string +>"foo" + "bar" : string +>"foo" : string +>"bar" : string + + "baz" + "bug" +>"baz" : string +>"bug" : string + + // Extra line here. + } + attr4="baz"> +>attr4 : any + +
; +>div : any + +( +>(
{/* A comment at the beginning */} {/* A second comment at the beginning */} {/* A nested comment */} {/* A sandwiched comment */}
{/* A comment at the end */} {/* A second comment at the end */}
) : any + +
+>
{/* A comment at the beginning */} {/* A second comment at the beginning */} {/* A nested comment */} {/* A sandwiched comment */}
{/* A comment at the end */} {/* A second comment at the end */}
: any +>div : any + + {/* A comment at the beginning */} + {/* A second comment at the beginning */} + +> {/* A nested comment */} : any +>span : any + + {/* A nested comment */} + +>span : any + + {/* A sandwiched comment */} +
+>
: any +>br : any + + {/* A comment at the end */} + {/* A second comment at the end */} +
+>div : any + +); + +( +>(
) : any + +
: any +>div : any + + /* a multi-line + comment */ + attr1="foo"> +>attr1 : any + + : any +>span : any + + attr2="bar" +>attr2 : any + + /> +
+>div : any + +); + +
 
; +>
 
: any +>div : any +>div : any + +
 
; +>
 
: any +>div : any +>div : any + +testing; +>testing : any +>hasOwnProperty : any +>hasOwnProperty : any + +; +> : any +>Component : any +>constructor : any + +; +> : any +>Namespace : any +>Component : any + +; +> : any +>Namespace : any +>DeepNamespace : any +>Component : any + + : any +>Component : any +>x : any +>y : any + +={2 } z />; +>z : any + + : any +>Component : any + + {...this.props} sound="moo" />; +>this.props : any +>this : any +>props : any +>sound : any + +; +> : any +>font-face : any + +; +> : any +>Component : any +>x : any +>y : any + +; +> : any +>x-component : any + +; +> : any +>Component : any +>x : any + +; +> : any +>Component : any +>x : any +>y : any + +; +> : any +>Component : any +>x : any +>y : any +>z : any + +; +> : any +>Component : any +>x : any +>y : any + + +; +> : any +>Component : any +>x : any +>y : any +>z : any +>z : any +> : any +>Child : any +>Component : any + +Text; +>Text : any +>Component : any +>x : any +>(z = { y: 2 }, z) : any +>z = { y: 2 }, z : any +>z = { y: 2 } : { y: number; } +>z : any +>{ y: 2 } : { y: number; } +>y : number +>2 : number +>z : any +>z : any +>Component : any + + + diff --git a/tests/baselines/reference/tsxElementResolution.errors.txt b/tests/baselines/reference/tsxElementResolution.errors.txt deleted file mode 100644 index 4e5cb93b007..00000000000 --- a/tests/baselines/reference/tsxElementResolution.errors.txt +++ /dev/null @@ -1,40 +0,0 @@ -tests/cases/conformance/jsx/tsxElementResolution.tsx(18,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/tsxElementResolution.tsx(19,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/tsxElementResolution.tsx(23,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/tsxElementResolution.tsx(24,9): error TS2602: The global type 'JSX.Element' must exist when using JSX. - - -==== tests/cases/conformance/jsx/tsxElementResolution.tsx (4 errors) ==== - - declare namespace JSX { - interface IntrinsicElements { - foundFirst: { x: string }; - 'string_named'; - 'var'; - } - } - - class foundFirst { } - class Other {} - - module Dotted { - export class Name { } - } - - // Should find the intrinsic element, not the class element - var a = ; - ~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - var b = ; - ~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - // TODO: This should not be a parse error (should - // parse a property name here, not identifier) - // var c = ; - var d = ; - ~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - var e = ; - ~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution.symbols b/tests/baselines/reference/tsxElementResolution.symbols new file mode 100644 index 00000000000..4cdd0c23cf1 --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/jsx/tsxElementResolution.tsx === + +declare namespace JSX { +>JSX : Symbol(JSX, Decl(tsxElementResolution.tsx, 0, 0)) + + interface IntrinsicElements { +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxElementResolution.tsx, 1, 23)) + + foundFirst: { x: string }; +>foundFirst : Symbol(foundFirst, Decl(tsxElementResolution.tsx, 2, 30)) +>x : Symbol(x, Decl(tsxElementResolution.tsx, 3, 15)) + + 'string_named'; + 'var'; + } +} + +class foundFirst { } +>foundFirst : Symbol(foundFirst, Decl(tsxElementResolution.tsx, 7, 1)) + +class Other {} +>Other : Symbol(Other, Decl(tsxElementResolution.tsx, 9, 20)) + +module Dotted { +>Dotted : Symbol(Dotted, Decl(tsxElementResolution.tsx, 10, 14)) + + export class Name { } +>Name : Symbol(Name, Decl(tsxElementResolution.tsx, 12, 15)) +} + +// Should find the intrinsic element, not the class element +var a = ; +>a : Symbol(a, Decl(tsxElementResolution.tsx, 17, 3)) +>foundFirst : Symbol(JSX.IntrinsicElements.foundFirst, Decl(tsxElementResolution.tsx, 2, 30)) +>x : Symbol(x, Decl(tsxElementResolution.tsx, 3, 15)) + +var b = ; +>b : Symbol(b, Decl(tsxElementResolution.tsx, 18, 3)) +>string_named : Symbol(JSX.IntrinsicElements.'string_named', Decl(tsxElementResolution.tsx, 3, 28)) + +// TODO: This should not be a parse error (should +// parse a property name here, not identifier) +// var c = ; +var d = ; +>d : Symbol(d, Decl(tsxElementResolution.tsx, 22, 3)) +>Other : Symbol(Other, Decl(tsxElementResolution.tsx, 9, 20)) + +var e = ; +>e : Symbol(e, Decl(tsxElementResolution.tsx, 23, 3)) +>Name : Symbol(Dotted.Name, Decl(tsxElementResolution.tsx, 12, 15)) + diff --git a/tests/baselines/reference/tsxElementResolution.types b/tests/baselines/reference/tsxElementResolution.types new file mode 100644 index 00000000000..89600bbbc2f --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution.types @@ -0,0 +1,56 @@ +=== tests/cases/conformance/jsx/tsxElementResolution.tsx === + +declare namespace JSX { +>JSX : any + + interface IntrinsicElements { +>IntrinsicElements : IntrinsicElements + + foundFirst: { x: string }; +>foundFirst : { x: string; } +>x : string + + 'string_named'; + 'var'; + } +} + +class foundFirst { } +>foundFirst : foundFirst + +class Other {} +>Other : Other + +module Dotted { +>Dotted : typeof Dotted + + export class Name { } +>Name : Name +} + +// Should find the intrinsic element, not the class element +var a = ; +>a : any +> : any +>foundFirst : typeof foundFirst +>x : any + +var b = ; +>b : any +> : any +>string_named : any + +// TODO: This should not be a parse error (should +// parse a property name here, not identifier) +// var c = ; +var d = ; +>d : any +> : any +>Other : typeof Other + +var e = ; +>e : any +> : any +>Dotted : any +>Name : any + diff --git a/tests/baselines/reference/tsxElementResolution16.errors.txt b/tests/baselines/reference/tsxElementResolution16.errors.txt index 3bdc9286c56..0e30cad9673 100644 --- a/tests/baselines/reference/tsxElementResolution16.errors.txt +++ b/tests/baselines/reference/tsxElementResolution16.errors.txt @@ -1,7 +1,8 @@ -tests/cases/conformance/jsx/tsxElementResolution16.tsx(8,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. +tests/cases/conformance/jsx/tsxElementResolution16.tsx(8,1): error TS2602: JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist. +tests/cases/conformance/jsx/tsxElementResolution16.tsx(8,1): error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists -==== tests/cases/conformance/jsx/tsxElementResolution16.tsx (1 errors) ==== +==== tests/cases/conformance/jsx/tsxElementResolution16.tsx (2 errors) ==== declare module JSX { } @@ -9,7 +10,9 @@ tests/cases/conformance/jsx/tsxElementResolution16.tsx(8,1): error TS2602: The g new(n: string): {}; } var obj1: Obj1; - ; // Error (JSX.Element is missing) + ; // Error (JSX.Element is implicit any) ~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. +!!! error TS2602: JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist. + ~~~~~~~~~~~~~~~ +!!! error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists \ No newline at end of file diff --git a/tests/baselines/reference/tsxElementResolution16.js b/tests/baselines/reference/tsxElementResolution16.js index c63c3b7f83a..1961215fa05 100644 --- a/tests/baselines/reference/tsxElementResolution16.js +++ b/tests/baselines/reference/tsxElementResolution16.js @@ -6,9 +6,9 @@ interface Obj1 { new(n: string): {}; } var obj1: Obj1; -; // Error (JSX.Element is missing) +; // Error (JSX.Element is implicit any) //// [tsxElementResolution16.jsx] var obj1; -; // Error (JSX.Element is missing) +; // Error (JSX.Element is implicit any) diff --git a/tests/baselines/reference/tsxElementResolution16.symbols b/tests/baselines/reference/tsxElementResolution16.symbols new file mode 100644 index 00000000000..e01f19b991f --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution16.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/jsx/tsxElementResolution16.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxElementResolution16.tsx, 0, 0)) +} + +interface Obj1 { +>Obj1 : Symbol(Obj1, Decl(tsxElementResolution16.tsx, 1, 1)) + + new(n: string): {}; +>n : Symbol(n, Decl(tsxElementResolution16.tsx, 4, 5)) +} +var obj1: Obj1; +>obj1 : Symbol(obj1, Decl(tsxElementResolution16.tsx, 6, 3)) +>Obj1 : Symbol(Obj1, Decl(tsxElementResolution16.tsx, 1, 1)) + +; // Error (JSX.Element is missing) +>x : Symbol(unknown) + diff --git a/tests/baselines/reference/tsxElementResolution16.types b/tests/baselines/reference/tsxElementResolution16.types new file mode 100644 index 00000000000..3b8604e737d --- /dev/null +++ b/tests/baselines/reference/tsxElementResolution16.types @@ -0,0 +1,20 @@ +=== tests/cases/conformance/jsx/tsxElementResolution16.tsx === +declare module JSX { +>JSX : any +} + +interface Obj1 { +>Obj1 : Obj1 + + new(n: string): {}; +>n : string +} +var obj1: Obj1; +>obj1 : Obj1 +>Obj1 : Obj1 + +; // Error (JSX.Element is missing) +> : any +>obj1 : Obj1 +>x : any + diff --git a/tests/baselines/reference/tsxNoJsx.errors.txt b/tests/baselines/reference/tsxNoJsx.errors.txt deleted file mode 100644 index 9e5c6762c9e..00000000000 --- a/tests/baselines/reference/tsxNoJsx.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/conformance/jsx/tsxNoJsx.tsx(2,1): error TS2602: The global type 'JSX.Element' must exist when using JSX. - - -==== tests/cases/conformance/jsx/tsxNoJsx.tsx (1 errors) ==== - - ; - ~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - \ No newline at end of file diff --git a/tests/baselines/reference/tsxNoJsx.symbols b/tests/baselines/reference/tsxNoJsx.symbols new file mode 100644 index 00000000000..6744c2edb10 --- /dev/null +++ b/tests/baselines/reference/tsxNoJsx.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/jsx/tsxNoJsx.tsx === + +No type information for this code.; +No type information for this code. +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/tsxNoJsx.types b/tests/baselines/reference/tsxNoJsx.types new file mode 100644 index 00000000000..52e6769795e --- /dev/null +++ b/tests/baselines/reference/tsxNoJsx.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/jsx/tsxNoJsx.tsx === + +; +> : any +>nope : any + diff --git a/tests/baselines/reference/tsxTypeErrors.errors.txt b/tests/baselines/reference/tsxTypeErrors.errors.txt deleted file mode 100644 index 42959efe6fe..00000000000 --- a/tests/baselines/reference/tsxTypeErrors.errors.txt +++ /dev/null @@ -1,55 +0,0 @@ -tests/cases/conformance/jsx/tsxTypeErrors.tsx(3,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/tsxTypeErrors.tsx(6,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/tsxTypeErrors.tsx(10,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/tsxTypeErrors.tsx(13,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/tsxTypeErrors.tsx(26,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. -tests/cases/conformance/jsx/tsxTypeErrors.tsx(32,10): error TS2602: The global type 'JSX.Element' must exist when using JSX. - - -==== tests/cases/conformance/jsx/tsxTypeErrors.tsx (6 errors) ==== - - // A built-in element (OK) - var a1 =
; - ~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - // A built-in element with a mistyped property (error) - var a2 = - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - // A built-in element with a badly-typed attribute value (error) - var thing = { oops: 100 }; - var a3 =
- ~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - // Mistyped html name (error) - var e1 = - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - // A custom type - class MyClass { - props: { - pt?: { x: number; y: number; }; - name?: string; - reqd: boolean; - } - } - - // Let's use it - // TODO: Error on missing 'reqd' - var b1 = ; - ~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - // Mistyped attribute member - // sample.tsx(23,22): error TS2322: Type '{ x: number; y: string; }' is not assignable to type '{ x: number; y: number; }'. - // Types of property 'y' are incompatible. - // Type 'string' is not assignable to type 'number'. - var b2 = ; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2602: The global type 'JSX.Element' must exist when using JSX. - - \ No newline at end of file diff --git a/tests/baselines/reference/tsxTypeErrors.symbols b/tests/baselines/reference/tsxTypeErrors.symbols new file mode 100644 index 00000000000..bfe0c568640 --- /dev/null +++ b/tests/baselines/reference/tsxTypeErrors.symbols @@ -0,0 +1,65 @@ +=== tests/cases/conformance/jsx/tsxTypeErrors.tsx === + +// A built-in element (OK) +var a1 =
; +>a1 : Symbol(a1, Decl(tsxTypeErrors.tsx, 2, 3)) +>id : Symbol(unknown) + +// A built-in element with a mistyped property (error) +var a2 = +>a2 : Symbol(a2, Decl(tsxTypeErrors.tsx, 5, 3)) +>srce : Symbol(unknown) + +// A built-in element with a badly-typed attribute value (error) +var thing = { oops: 100 }; +>thing : Symbol(thing, Decl(tsxTypeErrors.tsx, 8, 3)) +>oops : Symbol(oops, Decl(tsxTypeErrors.tsx, 8, 13)) + +var a3 =
+>a3 : Symbol(a3, Decl(tsxTypeErrors.tsx, 9, 3)) +>id : Symbol(unknown) + +// Mistyped html name (error) +var e1 = +>e1 : Symbol(e1, Decl(tsxTypeErrors.tsx, 12, 3)) +>src : Symbol(unknown) + +// A custom type +class MyClass { +>MyClass : Symbol(MyClass, Decl(tsxTypeErrors.tsx, 12, 31)) + + props: { +>props : Symbol(props, Decl(tsxTypeErrors.tsx, 15, 15)) + + pt?: { x: number; y: number; }; +>pt : Symbol(pt, Decl(tsxTypeErrors.tsx, 16, 10)) +>x : Symbol(x, Decl(tsxTypeErrors.tsx, 17, 10)) +>y : Symbol(y, Decl(tsxTypeErrors.tsx, 17, 21)) + + name?: string; +>name : Symbol(name, Decl(tsxTypeErrors.tsx, 17, 35)) + + reqd: boolean; +>reqd : Symbol(reqd, Decl(tsxTypeErrors.tsx, 18, 15)) + } +} + +// Let's use it +// TODO: Error on missing 'reqd' +var b1 = ; +>b1 : Symbol(b1, Decl(tsxTypeErrors.tsx, 25, 3)) +>MyClass : Symbol(MyClass, Decl(tsxTypeErrors.tsx, 12, 31)) +>reqd : Symbol(unknown) + +// Mistyped attribute member +// sample.tsx(23,22): error TS2322: Type '{ x: number; y: string; }' is not assignable to type '{ x: number; y: number; }'. +// Types of property 'y' are incompatible. +// Type 'string' is not assignable to type 'number'. +var b2 = ; +>b2 : Symbol(b2, Decl(tsxTypeErrors.tsx, 31, 3)) +>MyClass : Symbol(MyClass, Decl(tsxTypeErrors.tsx, 12, 31)) +>pt : Symbol(unknown) +>x : Symbol(x, Decl(tsxTypeErrors.tsx, 31, 23)) +>y : Symbol(y, Decl(tsxTypeErrors.tsx, 31, 28)) + + diff --git a/tests/baselines/reference/tsxTypeErrors.types b/tests/baselines/reference/tsxTypeErrors.types new file mode 100644 index 00000000000..92c7148b314 --- /dev/null +++ b/tests/baselines/reference/tsxTypeErrors.types @@ -0,0 +1,82 @@ +=== tests/cases/conformance/jsx/tsxTypeErrors.tsx === + +// A built-in element (OK) +var a1 =
; +>a1 : any +>
: any +>div : any +>id : any + +// A built-in element with a mistyped property (error) +var a2 = +>a2 : any +> : any +>img : any +>srce : any + +// A built-in element with a badly-typed attribute value (error) +var thing = { oops: 100 }; +>thing : { oops: number; } +>{ oops: 100 } : { oops: number; } +>oops : number +>100 : number + +var a3 =
+>a3 : any +>
: any +>div : any +>id : any +>thing : any + +// Mistyped html name (error) +var e1 = +>e1 : any +> : any +>imag : any +>src : any + +// A custom type +class MyClass { +>MyClass : MyClass + + props: { +>props : { pt?: { x: number; y: number; }; name?: string; reqd: boolean; } + + pt?: { x: number; y: number; }; +>pt : { x: number; y: number; } +>x : number +>y : number + + name?: string; +>name : string + + reqd: boolean; +>reqd : boolean + } +} + +// Let's use it +// TODO: Error on missing 'reqd' +var b1 = ; +>b1 : any +> : any +>MyClass : typeof MyClass +>reqd : any +>true : boolean + +// Mistyped attribute member +// sample.tsx(23,22): error TS2322: Type '{ x: number; y: string; }' is not assignable to type '{ x: number; y: number; }'. +// Types of property 'y' are incompatible. +// Type 'string' is not assignable to type 'number'. +var b2 = ; +>b2 : any +> : any +>MyClass : typeof MyClass +>pt : any +>{x: 4, y: 'oops'} : { x: number; y: string; } +>x : number +>4 : number +>y : string +>'oops' : string + + diff --git a/tests/cases/conformance/jsx/tsxElementResolution16.tsx b/tests/cases/conformance/jsx/tsxElementResolution16.tsx index 7d71b5f2b69..3b5b23d77f5 100644 --- a/tests/cases/conformance/jsx/tsxElementResolution16.tsx +++ b/tests/cases/conformance/jsx/tsxElementResolution16.tsx @@ -1,5 +1,6 @@ //@filename: file.tsx //@jsx: preserve +//@noImplicitAny: true declare module JSX { } @@ -7,4 +8,4 @@ interface Obj1 { new(n: string): {}; } var obj1: Obj1; -; // Error (JSX.Element is missing) +; // Error (JSX.Element is implicit any) diff --git a/tests/cases/conformance/jsx/tsxInArrowFunction.tsx b/tests/cases/conformance/jsx/tsxInArrowFunction.tsx new file mode 100644 index 00000000000..36951e0d092 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxInArrowFunction.tsx @@ -0,0 +1,23 @@ +// @jsx: preserve + +declare namespace JSX { + interface Element { } + interface IntrinsicElements { + div: { + text?: string; + } + } +} + + +// didn't work +
{() =>
}
; + +// didn't work +
{x =>
}
; + +// worked +
{() => (
)}
; + +// worked (!) +
{() =>
}
; From 627ebc86eb497691109cca25e19b58c47ffe265f Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 25 Jun 2015 20:47:40 +0200 Subject: [PATCH 238/309] Fixed formatting spaces on default keyword --- src/services/formatting/rules.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index 9897453e575..84d79be5c6e 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -318,7 +318,7 @@ namespace ts.formatting { this.NoSpaceAfterModuleImport = new Rule(RuleDescriptor.create2(Shared.TokenRange.FromTokens([SyntaxKind.ModuleKeyword, SyntaxKind.RequireKeyword]), SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete)); // Add a space around certain TypeScript keywords - this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); + this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.DefaultKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); this.SpaceBeforeCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.ExtendsKeyword, SyntaxKind.ImplementsKeyword])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { From de2d532b1f94a4c6980f8cded31516a028be5848 Mon Sep 17 00:00:00 2001 From: Dick van den Brink Date: Thu, 25 Jun 2015 20:49:25 +0200 Subject: [PATCH 239/309] Added test for formatting on default keyword --- tests/cases/fourslash/formattingOfExportDefault.ts | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 tests/cases/fourslash/formattingOfExportDefault.ts diff --git a/tests/cases/fourslash/formattingOfExportDefault.ts b/tests/cases/fourslash/formattingOfExportDefault.ts new file mode 100644 index 00000000000..ff69440b861 --- /dev/null +++ b/tests/cases/fourslash/formattingOfExportDefault.ts @@ -0,0 +1,12 @@ +/// + +////module Foo { +/////*1*/ export default class Test { } +////} +/////*2*/export default function bar() { } + +format.document(); +goTo.marker("1"); +verify.currentLineContentIs(" export default class Test { }") +goTo.marker("2"); +verify.currentLineContentIs("export default function bar() { }") From 46401483ce7e80383e504cca14fc2595c31b1d15 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 25 Jun 2015 11:50:14 -0700 Subject: [PATCH 240/309] added context flag --- src/compiler/checker.ts | 79 +++++++++++++++++++++++++---------------- 1 file changed, 48 insertions(+), 31 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index efee668a24b..26889c85233 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4263,27 +4263,27 @@ namespace ts { // TYPE CHECKING function isTypeIdenticalTo(source: Type, target: Type): boolean { - return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined); + return checkTypeRelatedTo(source, target, identityRelation, /*context*/ undefined, /*errorNode*/ undefined); } function compareTypes(source: Type, target: Type): Ternary { - return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined) ? Ternary.True : Ternary.False; + return checkTypeRelatedTo(source, target, identityRelation, /*context*/ undefined, /*errorNode*/ undefined) ? Ternary.True : Ternary.False; } function isTypeSubtypeOf(source: Type, target: Type): boolean { - return checkTypeSubtypeOf(source, target, /*errorNode*/ undefined); + return checkTypeSubtypeOf(source, target, /*context*/ undefined, /*errorNode*/ undefined); } function isTypeAssignableTo(source: Type, target: Type): boolean { - return checkTypeAssignableTo(source, target, /*errorNode*/ undefined); + return checkTypeAssignableTo(source, target, /*context*/ undefined, /*errorNode*/ undefined); } function checkTypeSubtypeOf(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { - return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); + return checkTypeRelatedTo(source, target, subtypeRelation, /*context*/ undefined, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { - return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); + function checkTypeAssignableTo(source: Type, target: Type, context?: SyntaxKind, errorNode?: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { + return checkTypeRelatedTo(source, target, assignableRelation, /*context*/ context, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source: Signature, target: Signature): boolean { @@ -4292,13 +4292,28 @@ namespace ts { return checkTypeRelatedTo(sourceType, targetType, assignableRelation, /*errorNode*/ undefined); } + /** + * Checks if 'source' is related to 'target' (e.g.: is a assignable to). + * @param source The left-hand-side of the relation. + * @param target The right-hand-side of the relation. + * @param relation The relation considered. One of 'identityRelation', 'assignableRelation', or 'subTypeRelation'. + * Used as both to determine which checks are performed and as a cache of previously computed results. + * @param The context in which the checking occurs. Currently used only for distinguishing extending classes from + * other assignability relations. + * @param errorNode The node upon which all errors will be reported, if defined. + * @param headMessage If the error chain should be prepended by a head message, then headMessage will be used. + * @param containingMessageChain A chain of errors to prepend any new errors found. + + */ function checkTypeRelatedTo( source: Type, target: Type, relation: Map, - errorNode: Node, + context?: SyntaxKind, + errorNode?: Node, headMessage?: DiagnosticMessage, - containingMessageChain?: DiagnosticMessageChain): boolean { + containingMessageChain?: DiagnosticMessageChain + ): boolean { let errorInfo: DiagnosticMessageChain; let sourceStack: ObjectType[]; @@ -7212,6 +7227,7 @@ namespace ts { typeArgumentsAreAssignable = checkTypeAssignableTo( typeArgument, constraint, + /*context */ undefined, reportErrors ? typeArgNode : undefined, typeArgumentHeadMessage, errorInfo); @@ -7243,7 +7259,7 @@ namespace ts { // Use argument expression as error location when reporting errors let errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; let headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; - if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) { + if (!checkTypeRelatedTo(argType, paramType, relation, /*context */ undefined, errorNode, headMessage)) { return false; } } @@ -8040,7 +8056,7 @@ namespace ts { if (produceDiagnostics && targetType !== unknownType) { let widenedType = getWidenedType(exprType); if (!(isTypeAssignableTo(targetType, widenedType))) { - checkTypeAssignableTo(exprType, targetType, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other); + checkTypeAssignableTo(exprType, targetType, /*context */ undefined, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other); } } return targetType; @@ -8274,7 +8290,7 @@ namespace ts { else { let exprType = checkExpression(node.body); if (node.type) { - checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, /*headMessage*/ undefined); + checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), /*context */ undefined, node.body, /*headMessage*/ undefined); } checkFunctionAndClassExpressionBodies(node.body); } @@ -8582,7 +8598,7 @@ namespace ts { function checkReferenceAssignment(target: Expression, sourceType: Type, contextualMapper?: TypeMapper): Type { let targetType = checkExpression(target, contextualMapper); if (checkReferenceExpression(target, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant)) { - checkTypeAssignableTo(sourceType, targetType, target, /*headMessage*/ undefined); + checkTypeAssignableTo(sourceType, targetType, /*context */ undefined, target, /*headMessage*/ undefined); } return sourceType; } @@ -8757,7 +8773,7 @@ namespace ts { // Use default messages if (ok) { // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported - checkTypeAssignableTo(valueType, leftType, node.left, /*headMessage*/ undefined); + checkTypeAssignableTo(valueType, leftType, /*context */ undefined, node.left, /*headMessage*/ undefined); } } } @@ -8808,10 +8824,10 @@ namespace ts { if (func.type) { let signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType; if (nodeIsYieldStar) { - checkTypeAssignableTo(expressionElementType, signatureElementType, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(expressionElementType, signatureElementType, /*context */ undefined, node.expression, /*headMessage*/ undefined); } else { - checkTypeAssignableTo(expressionType, signatureElementType, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(expressionType, signatureElementType, /*context */ undefined, node.expression, /*headMessage*/ undefined); } } } @@ -9119,7 +9135,7 @@ namespace ts { else { checkTypeAssignableTo(typePredicate.type, getTypeAtLocation(node.parameters[typePredicate.parameterIndex]), - typePredicateNode.type); + /*context */ undefined, typePredicateNode.type); } } else if (typePredicateNode.parameterName) { @@ -9197,7 +9213,7 @@ namespace ts { // interface BadGenerator extends Iterable, Iterator { } // function* g(): BadGenerator { } // Iterable and Iterator have different types! // - checkTypeAssignableTo(iterableIteratorInstantiation, returnType, node.type); + checkTypeAssignableTo(iterableIteratorInstantiation, returnType, /*context */ undefined, node.type); } } } @@ -9399,7 +9415,7 @@ namespace ts { let constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { let typeArgument = typeArguments[i]; - result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, /*context */ undefined, typeArgument, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); } } return result; @@ -9836,6 +9852,7 @@ namespace ts { checkTypeAssignableTo( returnType, expectedReturnType, + /*context */ undefined, node, headMessage, errorInfo); @@ -10257,7 +10274,7 @@ namespace ts { // For a binding pattern, validate the initializer and exit if (isBindingPattern(node.name)) { if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), /*context */ undefined, node, /*headMessage*/ undefined); checkParameterInitializer(node); } return; @@ -10267,7 +10284,7 @@ namespace ts { if (node === symbol.valueDeclaration) { // Node is the primary declaration of the symbol, just validate the initializer if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), type, node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), type, /*context */ undefined, node, /*headMessage*/ undefined); checkParameterInitializer(node); } } @@ -10279,7 +10296,7 @@ namespace ts { error(node.name, Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, declarationNameToString(node.name), typeToString(type), typeToString(declarationType)); } if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, /*context */ undefined, node, /*headMessage*/ undefined); } } if (node.kind !== SyntaxKind.PropertyDeclaration && node.kind !== SyntaxKind.PropertySignature) { @@ -10415,7 +10432,7 @@ namespace ts { // because we accessed properties from anyType, or it may have led to an error inside // getElementTypeOfIterable. if (iteratedType) { - checkTypeAssignableTo(iteratedType, leftType, varExpr, /*headMessage*/ undefined); + checkTypeAssignableTo(iteratedType, leftType, /*context */ undefined, varExpr, /*headMessage*/ undefined); } } } @@ -10515,7 +10532,7 @@ namespace ts { // Now even though we have extracted the iteratedType, we will have to validate that the type // passed in is actually an Iterable. if (errorNode && elementType) { - checkTypeAssignableTo(iterable, createIterableType(elementType), errorNode); + checkTypeAssignableTo(iterable, createIterableType(elementType), /*context */ undefined, errorNode); } return elementType || anyType; @@ -10759,7 +10776,7 @@ namespace ts { } } else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) { - checkTypeAssignableTo(exprType, returnType, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(exprType, returnType, /*context */ undefined, node.expression, /*headMessage*/ undefined); } } } @@ -10802,7 +10819,7 @@ namespace ts { let caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { // check 'expressionType isAssignableTo caseType' failed, try the reversed check and report errors if it fails - checkTypeAssignableTo(caseType, expressionType, caseClause.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(caseType, expressionType, /*context */ undefined, caseClause.expression, /*headMessage*/ undefined); } } forEach(clause.statements, checkSourceElement); @@ -11043,8 +11060,8 @@ namespace ts { } } } - checkTypeAssignableTo(type, baseType, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); - checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, + checkTypeAssignableTo(type, baseType, SyntaxKind.ExtendsKeyword, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), SyntaxKind.ExtendsKeyword, node.name || node, Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class)) { // When the static base type is a "class-like" constructor function (but not actually a class), we verify @@ -11072,7 +11089,7 @@ namespace ts { if (t !== unknownType) { let declaredType = (t.flags & TypeFlags.Reference) ? (t).target : t; if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) { - checkTypeAssignableTo(type, t, node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1); + checkTypeAssignableTo(type, t, /*context */ undefined, node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1); } else { error(typeRefNode, Diagnostics.A_class_may_only_implement_another_class_or_interface); @@ -11255,7 +11272,7 @@ namespace ts { // run subsequent checks only if first set succeeded if (checkInheritedPropertiesAreIdentical(type, node.name)) { forEach(getBaseTypes(type), baseType => { - checkTypeAssignableTo(type, baseType, node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1); + checkTypeAssignableTo(type, baseType, /*context */ undefined, node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1); }); checkIndexConstraints(type); } @@ -11308,7 +11325,7 @@ namespace ts { // If it is a constant value (not undefined), it is syntactically constrained to be a number. // Also, we do not need to check this for ambients because there is already // a syntax error if it is not a constant. - checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpression(initializer), enumType, /*context */ undefined, initializer, /*headMessage*/ undefined); } } else if (enumIsConst) { From 408538fd43a72976f96a4af3d9c7affb30792eb8 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 25 Jun 2015 13:31:14 -0700 Subject: [PATCH 241/309] Remove unreferenced errors --- .../diagnosticInformationMap.generated.ts | 14 ----- src/compiler/diagnosticMessages.json | 56 ------------------- 2 files changed, 70 deletions(-) diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 8ccc9d890e2..5ca747e4b62 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -20,22 +20,16 @@ module ts { An_index_signature_must_have_a_type_annotation: { code: 1021, category: DiagnosticCategory.Error, key: "An index signature must have a type annotation." }, An_index_signature_parameter_must_have_a_type_annotation: { code: 1022, category: DiagnosticCategory.Error, key: "An index signature parameter must have a type annotation." }, An_index_signature_parameter_type_must_be_string_or_number: { code: 1023, category: DiagnosticCategory.Error, key: "An index signature parameter type must be 'string' or 'number'." }, - A_class_or_interface_declaration_can_only_have_one_extends_clause: { code: 1024, category: DiagnosticCategory.Error, key: "A class or interface declaration can only have one 'extends' clause." }, - An_extends_clause_must_precede_an_implements_clause: { code: 1025, category: DiagnosticCategory.Error, key: "An 'extends' clause must precede an 'implements' clause." }, - A_class_can_only_extend_a_single_class: { code: 1026, category: DiagnosticCategory.Error, key: "A class can only extend a single class." }, - A_class_declaration_can_only_have_one_implements_clause: { code: 1027, category: DiagnosticCategory.Error, key: "A class declaration can only have one 'implements' clause." }, Accessibility_modifier_already_seen: { code: 1028, category: DiagnosticCategory.Error, key: "Accessibility modifier already seen." }, _0_modifier_must_precede_1_modifier: { code: 1029, category: DiagnosticCategory.Error, key: "'{0}' modifier must precede '{1}' modifier." }, _0_modifier_already_seen: { code: 1030, category: DiagnosticCategory.Error, key: "'{0}' modifier already seen." }, _0_modifier_cannot_appear_on_a_class_element: { code: 1031, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a class element." }, - An_interface_declaration_cannot_have_an_implements_clause: { code: 1032, category: DiagnosticCategory.Error, key: "An interface declaration cannot have an 'implements' clause." }, super_must_be_followed_by_an_argument_list_or_member_access: { code: 1034, category: DiagnosticCategory.Error, key: "'super' must be followed by an argument list or member access." }, Only_ambient_modules_can_use_quoted_names: { code: 1035, category: DiagnosticCategory.Error, key: "Only ambient modules can use quoted names." }, Statements_are_not_allowed_in_ambient_contexts: { code: 1036, category: DiagnosticCategory.Error, key: "Statements are not allowed in ambient contexts." }, A_declare_modifier_cannot_be_used_in_an_already_ambient_context: { code: 1038, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used in an already ambient context." }, Initializers_are_not_allowed_in_ambient_contexts: { code: 1039, category: DiagnosticCategory.Error, key: "Initializers are not allowed in ambient contexts." }, _0_modifier_cannot_appear_on_a_module_element: { code: 1044, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a module element." }, - A_declare_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an interface declaration." }, A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file: { code: 1046, category: DiagnosticCategory.Error, key: "A 'declare' modifier is required for a top level declaration in a .d.ts file." }, A_rest_parameter_cannot_be_optional: { code: 1047, category: DiagnosticCategory.Error, key: "A rest parameter cannot be optional." }, A_rest_parameter_cannot_have_an_initializer: { code: 1048, category: DiagnosticCategory.Error, key: "A rest parameter cannot have an initializer." }, @@ -94,7 +88,6 @@ module ts { case_or_default_expected: { code: 1130, category: DiagnosticCategory.Error, key: "'case' or 'default' expected." }, Property_or_signature_expected: { code: 1131, category: DiagnosticCategory.Error, key: "Property or signature expected." }, Enum_member_expected: { code: 1132, category: DiagnosticCategory.Error, key: "Enum member expected." }, - Type_reference_expected: { code: 1133, category: DiagnosticCategory.Error, key: "Type reference expected." }, Variable_declaration_expected: { code: 1134, category: DiagnosticCategory.Error, key: "Variable declaration expected." }, Argument_expression_expected: { code: 1135, category: DiagnosticCategory.Error, key: "Argument expression expected." }, Property_assignment_expected: { code: 1136, category: DiagnosticCategory.Error, key: "Property assignment expected." }, @@ -111,9 +104,6 @@ module ts { Cannot_compile_modules_unless_the_module_flag_is_provided: { code: 1148, category: DiagnosticCategory.Error, key: "Cannot compile modules unless the '--module' flag is provided." }, File_name_0_differs_from_already_included_file_name_1_only_in_casing: { code: 1149, category: DiagnosticCategory.Error, key: "File name '{0}' differs from already included file name '{1}' only in casing" }, new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: { code: 1150, category: DiagnosticCategory.Error, key: "'new T[]' cannot be used to create an array. Use 'new Array()' instead." }, - var_let_or_const_expected: { code: 1152, category: DiagnosticCategory.Error, key: "'var', 'let' or 'const' expected." }, - let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1153, category: DiagnosticCategory.Error, key: "'let' declarations are only available when targeting ECMAScript 6 and higher." }, - const_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1154, category: DiagnosticCategory.Error, key: "'const' declarations are only available when targeting ECMAScript 6 and higher." }, const_declarations_must_be_initialized: { code: 1155, category: DiagnosticCategory.Error, key: "'const' declarations must be initialized" }, const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: DiagnosticCategory.Error, key: "'const' declarations can only be declared inside a block." }, let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: DiagnosticCategory.Error, key: "'let' declarations can only be declared inside a block." }, @@ -124,7 +114,6 @@ module ts { Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in enums." }, A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol: { code: 1165, category: DiagnosticCategory.Error, key: "A computed property name in an ambient context must directly refer to a built-in symbol." }, A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol: { code: 1166, category: DiagnosticCategory.Error, key: "A computed property name in a class property declaration must directly refer to a built-in symbol." }, - Computed_property_names_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1167, category: DiagnosticCategory.Error, key: "Computed property names are only available when targeting ECMAScript 6 and higher." }, A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol: { code: 1168, category: DiagnosticCategory.Error, key: "A computed property name in a method overload must directly refer to a built-in symbol." }, A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol: { code: 1169, category: DiagnosticCategory.Error, key: "A computed property name in an interface must directly refer to a built-in symbol." }, A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol: { code: 1170, category: DiagnosticCategory.Error, key: "A computed property name in a type literal must directly refer to a built-in symbol." }, @@ -140,7 +129,6 @@ module ts { Property_destructuring_pattern_expected: { code: 1180, category: DiagnosticCategory.Error, key: "Property destructuring pattern expected." }, Array_element_destructuring_pattern_expected: { code: 1181, category: DiagnosticCategory.Error, key: "Array element destructuring pattern expected." }, A_destructuring_declaration_must_have_an_initializer: { code: 1182, category: DiagnosticCategory.Error, key: "A destructuring declaration must have an initializer." }, - Destructuring_declarations_are_not_allowed_in_ambient_contexts: { code: 1183, category: DiagnosticCategory.Error, key: "Destructuring declarations are not allowed in ambient contexts." }, An_implementation_cannot_be_declared_in_ambient_contexts: { code: 1184, category: DiagnosticCategory.Error, key: "An implementation cannot be declared in ambient contexts." }, Modifiers_cannot_appear_here: { code: 1184, category: DiagnosticCategory.Error, key: "Modifiers cannot appear here." }, Merge_conflict_marker_encountered: { code: 1185, category: DiagnosticCategory.Error, key: "Merge conflict marker encountered." }, @@ -187,7 +175,6 @@ module ts { Module_0_has_no_exported_member_1: { code: 2305, category: DiagnosticCategory.Error, key: "Module '{0}' has no exported member '{1}'." }, File_0_is_not_a_module: { code: 2306, category: DiagnosticCategory.Error, key: "File '{0}' is not a module." }, Cannot_find_module_0: { code: 2307, category: DiagnosticCategory.Error, key: "Cannot find module '{0}'." }, - A_module_cannot_have_more_than_one_export_assignment: { code: 2308, category: DiagnosticCategory.Error, key: "A module cannot have more than one export assignment." }, An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: { code: 2309, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a module with other exported elements." }, Type_0_recursively_references_itself_as_a_base_type: { code: 2310, category: DiagnosticCategory.Error, key: "Type '{0}' recursively references itself as a base type." }, A_class_may_only_extend_another_class: { code: 2311, category: DiagnosticCategory.Error, key: "A class may only extend another class." }, @@ -508,7 +495,6 @@ module ts { File_0_has_unsupported_extension_The_only_supported_extensions_are_1: { code: 6054, category: DiagnosticCategory.Error, key: "File '{0}' has unsupported extension. The only supported extensions are {1}." }, Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: DiagnosticCategory.Message, key: "Suppress noImplicitAny errors for indexing objects lacking index signatures." }, Do_not_emit_declarations_for_code_that_has_an_internal_annotation: { code: 6056, category: DiagnosticCategory.Message, key: "Do not emit declarations for code that has an '@internal' annotation." }, - Preserve_new_lines_when_emitting_code: { code: 6057, category: DiagnosticCategory.Message, key: "Preserve new-lines when emitting code." }, Specifies_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: { code: 6058, category: DiagnosticCategory.Message, key: "Specifies the root directory of input files. Use to control the output directory structure with --outDir." }, File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: { code: 6059, category: DiagnosticCategory.Error, key: "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files." }, Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index fb246955f73..4610f699a16 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -67,22 +67,6 @@ "category": "Error", "code": 1023 }, - "A class or interface declaration can only have one 'extends' clause.": { - "category": "Error", - "code": 1024 - }, - "An 'extends' clause must precede an 'implements' clause.": { - "category": "Error", - "code": 1025 - }, - "A class can only extend a single class.": { - "category": "Error", - "code": 1026 - }, - "A class declaration can only have one 'implements' clause.": { - "category": "Error", - "code": 1027 - }, "Accessibility modifier already seen.": { "category": "Error", "code": 1028 @@ -99,10 +83,6 @@ "category": "Error", "code": 1031 }, - "An interface declaration cannot have an 'implements' clause.": { - "category": "Error", - "code": 1032 - }, "'super' must be followed by an argument list or member access.": { "category": "Error", "code": 1034 @@ -127,10 +107,6 @@ "category": "Error", "code": 1044 }, - "A 'declare' modifier cannot be used with an interface declaration.": { - "category": "Error", - "code": 1045 - }, "A 'declare' modifier is required for a top level declaration in a .d.ts file.": { "category": "Error", "code": 1046 @@ -363,10 +339,6 @@ "category": "Error", "code": 1132 }, - "Type reference expected.": { - "category": "Error", - "code": 1133 - }, "Variable declaration expected.": { "category": "Error", "code": 1134 @@ -431,18 +403,6 @@ "category": "Error", "code": 1150 }, - "'var', 'let' or 'const' expected.": { - "category": "Error", - "code": 1152 - }, - "'let' declarations are only available when targeting ECMAScript 6 and higher.": { - "category": "Error", - "code": 1153 - }, - "'const' declarations are only available when targeting ECMAScript 6 and higher.": { - "category": "Error", - "code": 1154 - }, "'const' declarations must be initialized": { "category": "Error", "code": 1155 @@ -483,10 +443,6 @@ "category": "Error", "code": 1166 }, - "Computed property names are only available when targeting ECMAScript 6 and higher.": { - "category": "Error", - "code": 1167 - }, "A computed property name in a method overload must directly refer to a built-in symbol.": { "category": "Error", "code": 1168 @@ -547,10 +503,6 @@ "category": "Error", "code": 1182 }, - "Destructuring declarations are not allowed in ambient contexts.": { - "category": "Error", - "code": 1183 - }, "An implementation cannot be declared in ambient contexts.": { "category": "Error", "code": 1184 @@ -736,10 +688,6 @@ "category": "Error", "code": 2307 }, - "A module cannot have more than one export assignment.": { - "category": "Error", - "code": 2308 - }, "An export assignment cannot be used in a module with other exported elements.": { "category": "Error", "code": 2309 @@ -2022,10 +1970,6 @@ "category": "Message", "code": 6056 }, - "Preserve new-lines when emitting code.": { - "category": "Message", - "code": 6057 - }, "Specifies the root directory of input files. Use to control the output directory structure with --outDir.": { "category": "Message", "code": 6058 From b4b2a41bc079c9b25ae833d77102e747206a7dcc Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 25 Jun 2015 13:34:42 -0700 Subject: [PATCH 242/309] Error check script --- scripts/errorCheck.ts | 83 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 scripts/errorCheck.ts diff --git a/scripts/errorCheck.ts b/scripts/errorCheck.ts new file mode 100644 index 00000000000..d2eb5a9632e --- /dev/null +++ b/scripts/errorCheck.ts @@ -0,0 +1,83 @@ +declare var require: any; +let fs = require('fs'); +let async = require('async'); +let glob = require('glob'); + +fs.readFile('src/compiler/diagnosticMessages.json', 'utf-8', (err, data) => { + let messages = JSON.parse(data); + if (err) throw err; + let keys = Object.keys(messages); + console.log('Loaded ' + keys.length + ' errors'); + + for(let k of keys) { + messages[k]['seen'] = false; + } + + let errRegex = /\(\d+,\d+\): error TS([^:]+):/g; + + let baseDir = 'tests/baselines/reference/'; + fs.readdir(baseDir, (err, files) => { + files = files.filter(f => f.indexOf('.errors.txt') > 0); + console.log('Read ' + files.length + ' baselines'); + let tasks: Array<(callback: () => void) => void> = []; + files.forEach(f => tasks.push(done => { + fs.readFile(baseDir + f, 'utf-8', (err, baseline) => { + if (err) throw err; + + let g: string[]; + while(g = errRegex.exec(baseline)) { + var errCode = +g[1]; + let msg = keys.filter(k => messages[k].code === errCode)[0]; + messages[msg]['seen'] = true; + } + + done(); + }); + })); + + async.parallelLimit(tasks, 25, done => { + console.log('== List of errors not present in baselines =='); + let count = 0; + for(let k of keys) { + if(messages[k]['seen'] !== true) { + console.log(k); + count++; + } + } + console.log(count + ' of ' + keys.length + ' errors are not in baselines'); + }); + }); +}); + +fs.readFile('src/compiler/diagnosticInformationMap.generated.ts', 'utf-8', (err, data) => { + let errorRegexp = /\s(\w+): \{ code/g; + let errorNames: string[] = []; + let errMatch: string[]; + while(errMatch = errorRegexp.exec(data)) { + errorNames.push(errMatch[1]); + } + + let allSrc: string = ''; + glob('./src/**/*.ts', {}, (err, files) => { + console.log('Reading ' + files.length + ' source files'); + files.forEach(file => { + if (file.indexOf('diagnosticInformationMap.generated.ts') > 0) return; + + let src = fs.readFileSync(file, 'utf-8'); + allSrc = allSrc + src; + }); + + console.log('Consumed ' + allSrc.length + ' characters of source'); + + let count = 0; + console.log('== List of errors not used in source ==') + errorNames.forEach(errName => { + if(allSrc.indexOf(errName) < 0) { + console.log(errName); + count++; + } + }); + console.log(count + ' of ' + errorNames.length + ' errors are not used in source'); + }); +}); + From aa59753fe4103778ea5514da48f89cf84336eed1 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 25 Jun 2015 14:02:30 -0700 Subject: [PATCH 243/309] CR feedback --- scripts/errorCheck.ts | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/scripts/errorCheck.ts b/scripts/errorCheck.ts index d2eb5a9632e..77892cb8f0c 100644 --- a/scripts/errorCheck.ts +++ b/scripts/errorCheck.ts @@ -4,12 +4,15 @@ let async = require('async'); let glob = require('glob'); fs.readFile('src/compiler/diagnosticMessages.json', 'utf-8', (err, data) => { - let messages = JSON.parse(data); - if (err) throw err; + if (err) { + throw err; + } + + let messages = JSON.parse(data); let keys = Object.keys(messages); console.log('Loaded ' + keys.length + ' errors'); - for(let k of keys) { + for (let k of keys) { messages[k]['seen'] = false; } @@ -18,14 +21,13 @@ fs.readFile('src/compiler/diagnosticMessages.json', 'utf-8', (err, data) => { let baseDir = 'tests/baselines/reference/'; fs.readdir(baseDir, (err, files) => { files = files.filter(f => f.indexOf('.errors.txt') > 0); - console.log('Read ' + files.length + ' baselines'); let tasks: Array<(callback: () => void) => void> = []; files.forEach(f => tasks.push(done => { fs.readFile(baseDir + f, 'utf-8', (err, baseline) => { if (err) throw err; let g: string[]; - while(g = errRegex.exec(baseline)) { + while (g = errRegex.exec(baseline)) { var errCode = +g[1]; let msg = keys.filter(k => messages[k].code === errCode)[0]; messages[msg]['seen'] = true; @@ -38,8 +40,8 @@ fs.readFile('src/compiler/diagnosticMessages.json', 'utf-8', (err, data) => { async.parallelLimit(tasks, 25, done => { console.log('== List of errors not present in baselines =='); let count = 0; - for(let k of keys) { - if(messages[k]['seen'] !== true) { + for (let k of keys) { + if (messages[k]['seen'] !== true) { console.log(k); count++; } @@ -53,30 +55,32 @@ fs.readFile('src/compiler/diagnosticInformationMap.generated.ts', 'utf-8', (err, let errorRegexp = /\s(\w+): \{ code/g; let errorNames: string[] = []; let errMatch: string[]; - while(errMatch = errorRegexp.exec(data)) { + while (errMatch = errorRegexp.exec(data)) { errorNames.push(errMatch[1]); } let allSrc: string = ''; glob('./src/**/*.ts', {}, (err, files) => { console.log('Reading ' + files.length + ' source files'); - files.forEach(file => { - if (file.indexOf('diagnosticInformationMap.generated.ts') > 0) return; + for(let file of files) { + if (file.indexOf('diagnosticInformationMap.generated.ts') > 0) { + continue; + } let src = fs.readFileSync(file, 'utf-8'); allSrc = allSrc + src; - }); + } console.log('Consumed ' + allSrc.length + ' characters of source'); let count = 0; console.log('== List of errors not used in source ==') - errorNames.forEach(errName => { - if(allSrc.indexOf(errName) < 0) { + for(let errName of errorNames) { + if (allSrc.indexOf(errName) < 0) { console.log(errName); count++; } - }); + } console.log(count + ' of ' + errorNames.length + ' errors are not used in source'); }); }); From f9de30c72849eeea67a6b6dea1912a327526f1f6 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Thu, 25 Jun 2015 17:38:11 -0700 Subject: [PATCH 244/309] Fix assert with declaration emit for export specifier for a global --- src/compiler/checker.ts | 6 +++-- ...s6ExportClauseWithoutModuleSpecifier.types | 4 +-- ...ortClauseWithoutModuleSpecifierInEs5.types | 4 +-- .../reference/exportSpecifierForAGlobal.js | 25 +++++++++++++++++++ .../exportSpecifierForAGlobal.symbols | 20 +++++++++++++++ .../reference/exportSpecifierForAGlobal.types | 20 +++++++++++++++ .../reference/exportsAndImports3-amd.symbols | 12 ++++----- .../reference/exportsAndImports3.symbols | 12 ++++----- .../compiler/exportSpecifierForAGlobal.ts | 12 +++++++++ 9 files changed, 97 insertions(+), 18 deletions(-) create mode 100644 tests/baselines/reference/exportSpecifierForAGlobal.js create mode 100644 tests/baselines/reference/exportSpecifierForAGlobal.symbols create mode 100644 tests/baselines/reference/exportSpecifierForAGlobal.types create mode 100644 tests/cases/compiler/exportSpecifierForAGlobal.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index efee668a24b..8b59d1a2d37 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1165,7 +1165,9 @@ namespace ts { // Check if symbol is any of the alias return forEachValue(symbols, symbolFromSymbolTable => { - if (symbolFromSymbolTable.flags & SymbolFlags.Alias && symbolFromSymbolTable.name !== "export=") { + if (symbolFromSymbolTable.flags & SymbolFlags.Alias + && symbolFromSymbolTable.name !== "export=" + && !getDeclarationOfKind(symbolFromSymbolTable, SyntaxKind.ExportSpecifier)) { if (!useOnlyExternalAliasing || // We can use any type of alias to get the name // Is this external alias, then use it to name ts.forEach(symbolFromSymbolTable.declarations, isExternalModuleImportEqualsDeclaration)) { @@ -1207,7 +1209,7 @@ namespace ts { } // Qualify if the symbol from symbol table has same meaning as expected - symbolFromSymbolTable = (symbolFromSymbolTable.flags & SymbolFlags.Alias) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable; + symbolFromSymbolTable = (symbolFromSymbolTable.flags & SymbolFlags.Alias && !getDeclarationOfKind(symbolFromSymbolTable, SyntaxKind.ExportSpecifier)) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable; if (symbolFromSymbolTable.flags & meaning) { qualify = true; return true; diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types index 9d87ec9925d..6b621f4c777 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifier.types @@ -31,8 +31,8 @@ export { c as c2 } from "server"; export { i, m as instantiatedModule } from "server"; >i : any ->m : typeof instantiatedModule ->instantiatedModule : typeof instantiatedModule +>m : typeof m +>instantiatedModule : typeof m export { uninstantiated } from "server"; >uninstantiated : any diff --git a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types index 9d87ec9925d..6b621f4c777 100644 --- a/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types +++ b/tests/baselines/reference/es6ExportClauseWithoutModuleSpecifierInEs5.types @@ -31,8 +31,8 @@ export { c as c2 } from "server"; export { i, m as instantiatedModule } from "server"; >i : any ->m : typeof instantiatedModule ->instantiatedModule : typeof instantiatedModule +>m : typeof m +>instantiatedModule : typeof m export { uninstantiated } from "server"; >uninstantiated : any diff --git a/tests/baselines/reference/exportSpecifierForAGlobal.js b/tests/baselines/reference/exportSpecifierForAGlobal.js new file mode 100644 index 00000000000..6b4343a299b --- /dev/null +++ b/tests/baselines/reference/exportSpecifierForAGlobal.js @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/exportSpecifierForAGlobal.ts] //// + +//// [a.d.ts] + +declare class X { } + +//// [b.ts] +export {X}; +export function f() { + var x: X; + return x; +} + + +//// [b.js] +function f() { + var x; + return x; +} +exports.f = f; + + +//// [b.d.ts] +export { X }; +export declare function f(): X; diff --git a/tests/baselines/reference/exportSpecifierForAGlobal.symbols b/tests/baselines/reference/exportSpecifierForAGlobal.symbols new file mode 100644 index 00000000000..b38fc7be270 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierForAGlobal.symbols @@ -0,0 +1,20 @@ +=== tests/cases/compiler/a.d.ts === + +declare class X { } +>X : Symbol(X, Decl(a.d.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export {X}; +>X : Symbol(X, Decl(b.ts, 0, 8)) + +export function f() { +>f : Symbol(f, Decl(b.ts, 0, 11)) + + var x: X; +>x : Symbol(x, Decl(b.ts, 2, 7)) +>X : Symbol(X, Decl(a.d.ts, 0, 0)) + + return x; +>x : Symbol(x, Decl(b.ts, 2, 7)) +} + diff --git a/tests/baselines/reference/exportSpecifierForAGlobal.types b/tests/baselines/reference/exportSpecifierForAGlobal.types new file mode 100644 index 00000000000..e3d728ad0d0 --- /dev/null +++ b/tests/baselines/reference/exportSpecifierForAGlobal.types @@ -0,0 +1,20 @@ +=== tests/cases/compiler/a.d.ts === + +declare class X { } +>X : X + +=== tests/cases/compiler/b.ts === +export {X}; +>X : typeof X + +export function f() { +>f : () => X + + var x: X; +>x : X +>X : X + + return x; +>x : X +} + diff --git a/tests/baselines/reference/exportsAndImports3-amd.symbols b/tests/baselines/reference/exportsAndImports3-amd.symbols index 4ab418a9bef..a46d7df2a68 100644 --- a/tests/baselines/reference/exportsAndImports3-amd.symbols +++ b/tests/baselines/reference/exportsAndImports3-amd.symbols @@ -16,17 +16,17 @@ export enum E { >E : Symbol(E, Decl(t1.ts, 6, 1)) A, B, C ->A : Symbol(E1.A, Decl(t1.ts, 7, 15)) ->B : Symbol(E1.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E1.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 7, 15)) +>B : Symbol(E.B, Decl(t1.ts, 8, 6)) +>C : Symbol(E.C, Decl(t1.ts, 8, 9)) } export const enum D { >D : Symbol(D, Decl(t1.ts, 9, 1)) A, B, C ->A : Symbol(D1.A, Decl(t1.ts, 10, 21)) ->B : Symbol(D1.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D1.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 10, 21)) +>B : Symbol(D.B, Decl(t1.ts, 11, 6)) +>C : Symbol(D.C, Decl(t1.ts, 11, 9)) } export module M { >M : Symbol(M, Decl(t1.ts, 12, 1)) diff --git a/tests/baselines/reference/exportsAndImports3.symbols b/tests/baselines/reference/exportsAndImports3.symbols index 4ab418a9bef..a46d7df2a68 100644 --- a/tests/baselines/reference/exportsAndImports3.symbols +++ b/tests/baselines/reference/exportsAndImports3.symbols @@ -16,17 +16,17 @@ export enum E { >E : Symbol(E, Decl(t1.ts, 6, 1)) A, B, C ->A : Symbol(E1.A, Decl(t1.ts, 7, 15)) ->B : Symbol(E1.B, Decl(t1.ts, 8, 6)) ->C : Symbol(E1.C, Decl(t1.ts, 8, 9)) +>A : Symbol(E.A, Decl(t1.ts, 7, 15)) +>B : Symbol(E.B, Decl(t1.ts, 8, 6)) +>C : Symbol(E.C, Decl(t1.ts, 8, 9)) } export const enum D { >D : Symbol(D, Decl(t1.ts, 9, 1)) A, B, C ->A : Symbol(D1.A, Decl(t1.ts, 10, 21)) ->B : Symbol(D1.B, Decl(t1.ts, 11, 6)) ->C : Symbol(D1.C, Decl(t1.ts, 11, 9)) +>A : Symbol(D.A, Decl(t1.ts, 10, 21)) +>B : Symbol(D.B, Decl(t1.ts, 11, 6)) +>C : Symbol(D.C, Decl(t1.ts, 11, 9)) } export module M { >M : Symbol(M, Decl(t1.ts, 12, 1)) diff --git a/tests/cases/compiler/exportSpecifierForAGlobal.ts b/tests/cases/compiler/exportSpecifierForAGlobal.ts new file mode 100644 index 00000000000..c24ec0b086f --- /dev/null +++ b/tests/cases/compiler/exportSpecifierForAGlobal.ts @@ -0,0 +1,12 @@ +// @declaration: true +// @module: commonjs + +// @filename: a.d.ts +declare class X { } + +// @filename: b.ts +export {X}; +export function f() { + var x: X; + return x; +} From c3af662e324e34d29794f30a81d7e12b8b0a645d Mon Sep 17 00:00:00 2001 From: Yui T Date: Thu, 25 Jun 2015 18:39:29 -0700 Subject: [PATCH 245/309] Change var -> let and use destructuring --- src/services/services.ts | 46 ++++++++++++++++++++-------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index e11fb32c73b..e3d9480e062 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1797,7 +1797,7 @@ namespace ts { let outputText: string; // Create a compilerHost object to allow the compiler to read and write files - var compilerHost: CompilerHost = { + let compilerHost: CompilerHost = { getSourceFile: (fileName, target) => fileName === inputFileName ? sourceFile : undefined, writeFile: (name, text, writeByteOrderMark) => { Debug.assert(outputText === undefined, "Unexpected multiple outputs for the file: " + name); @@ -1810,7 +1810,7 @@ namespace ts { getNewLine: () => newLine }; - var program = createProgram([inputFileName], options, compilerHost); + let program = createProgram([inputFileName], options, compilerHost); addRange(/*to*/ diagnostics, /*from*/ program.getSyntacticDiagnostics(sourceFile)); addRange(/*to*/ diagnostics, /*from*/ program.getOptionsDiagnostics()); @@ -3084,7 +3084,7 @@ namespace ts { * accurately aggregate locals from the closest containing scope. */ function getScopeNode(initialToken: Node, position: number, sourceFile: SourceFile) { - var scope = initialToken; + let scope = initialToken; while (scope && !positionBelongsToNode(scope, position, sourceFile)) { scope = scope.parent; } @@ -3485,10 +3485,10 @@ namespace ts { function getCompletionEntriesFromSymbols(symbols: Symbol[]): CompletionEntry[] { let start = new Date().getTime(); - var entries: CompletionEntry[] = []; + let entries: CompletionEntry[] = []; if (symbols) { - var nameToSymbol: Map = {}; + let nameToSymbol: Map = {}; for (let symbol of symbols) { let entry = createCompletionEntry(symbol, location); if (entry) { @@ -3522,13 +3522,13 @@ namespace ts { let symbol = forEach(symbols, s => getCompletionEntryDisplayNameForSymbol(s, target, /*performCharacterChecks:*/ false) === entryName ? s : undefined); if (symbol) { - let displayPartsDocumentationsAndSymbolKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getValidSourceFile(fileName), location, location, SemanticMeaning.All); + let { displayParts, documentation, symbolKind } = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getValidSourceFile(fileName), location, location, SemanticMeaning.All); return { name: entryName, - kind: displayPartsDocumentationsAndSymbolKind.symbolKind, kindModifiers: getSymbolModifiers(symbol), - displayParts: displayPartsDocumentationsAndSymbolKind.displayParts, - documentation: displayPartsDocumentationsAndSymbolKind.documentation + kind: symbolKind, + displayParts, + documentation }; } } @@ -4203,7 +4203,7 @@ namespace ts { } if (type.flags & TypeFlags.Union) { - var result: DefinitionInfo[] = []; + let result: DefinitionInfo[] = []; forEach((type).types, t => { if (t.symbol) { addRange(/*to*/ result, /*from*/ getDefinitionFromSymbol(t.symbol, node)); @@ -4303,7 +4303,7 @@ namespace ts { function getSyntacticDocumentHighlights(node: Node): DocumentHighlights[] { let fileName = sourceFile.fileName; - var highlightSpans = getHighlightSpans(node); + let highlightSpans = getHighlightSpans(node); if (!highlightSpans || highlightSpans.length === 0) { return undefined; } @@ -4881,17 +4881,17 @@ namespace ts { } function findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[] { - var referencedSymbols = findReferencedSymbols(fileName, position, findInStrings, findInComments); + let referencedSymbols = findReferencedSymbols(fileName, position, findInStrings, findInComments); return convertReferences(referencedSymbols); } function getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] { - var referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings:*/ false, /*findInComments:*/ false); + let referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings:*/ false, /*findInComments:*/ false); return convertReferences(referencedSymbols); } function findReferences(fileName: string, position: number): ReferencedSymbol[]{ - var referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings:*/ false, /*findInComments:*/ false); + let referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings:*/ false, /*findInComments:*/ false); // Only include referenced symbols that have a valid definition. return filter(referencedSymbols, rs => !!rs.definition); @@ -5190,7 +5190,7 @@ namespace ts { } }); - var definition: DefinitionInfo = { + let definition: DefinitionInfo = { containerKind: "", containerName: "", fileName: targetLabel.getSourceFile().fileName, @@ -5286,10 +5286,10 @@ namespace ts { if (referenceSymbol) { let referenceSymbolDeclaration = referenceSymbol.valueDeclaration; let shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration); - var relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation); + let relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation); if (relatedSymbol) { - var referencedSymbol = getReferencedSymbol(relatedSymbol); + let referencedSymbol = getReferencedSymbol(relatedSymbol); referencedSymbol.references.push(getReferenceEntryFromNode(referenceLocation)); } /* Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment @@ -5299,7 +5299,7 @@ namespace ts { * position of property accessing, the referenceEntry of such position will be handled in the first case. */ else if (!(referenceSymbol.flags & SymbolFlags.Transient) && searchSymbols.indexOf(shorthandValueSymbol) >= 0) { - var referencedSymbol = getReferencedSymbol(shorthandValueSymbol); + let referencedSymbol = getReferencedSymbol(shorthandValueSymbol); referencedSymbol.references.push(getReferenceEntryFromNode(referenceSymbolDeclaration.name)); } } @@ -5309,8 +5309,8 @@ namespace ts { return; function getReferencedSymbol(symbol: Symbol): ReferencedSymbol { - var symbolId = getSymbolId(symbol); - var index = symbolToIndex[symbolId]; + let symbolId = getSymbolId(symbol); + let index = symbolToIndex[symbolId]; if (index === undefined) { index = result.length; symbolToIndex[symbolId] = index; @@ -5397,7 +5397,7 @@ namespace ts { } }); - var definition = getDefinition(searchSpaceNode.symbol); + let definition = getDefinition(searchSpaceNode.symbol); return [{ definition, references }]; } @@ -5592,7 +5592,7 @@ namespace ts { // If the reference symbol is an alias, check if what it is aliasing is one of the search // symbols. if (isImportOrExportSpecifierImportSymbol(referenceSymbol)) { - var aliasedSymbol = typeChecker.getAliasedSymbol(referenceSymbol); + let aliasedSymbol = typeChecker.getAliasedSymbol(referenceSymbol); if (searchSymbols.indexOf(aliasedSymbol) >= 0) { return aliasedSymbol; } @@ -6908,7 +6908,7 @@ namespace ts { } function convertClassifications(classifications: Classifications, text: string): ClassificationResult { - var entries: ClassificationInfo[] = []; + let entries: ClassificationInfo[] = []; let dense = classifications.spans; let lastEnd = 0; From 529fcfd4c94fe8165479925544ab870832fe2948 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 25 Jun 2015 18:44:30 -0700 Subject: [PATCH 246/309] Assignment compatibility fix / contextual intersection types --- src/compiler/checker.ts | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 109ad1cf29f..32e00af577d 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3160,8 +3160,8 @@ namespace ts { return emptyArray; } - // If the given type is an object type and that type has a property by the given name, return - // the symbol for that property. Otherwise return undefined. + // If the given type is an object type and that type has a property by the given name, + // return the symbol for that property.Otherwise return undefined. function getPropertyOfObjectType(type: Type, name: string): Symbol { if (type.flags & TypeFlags.ObjectType) { let resolved = resolveStructuredTypeMembers(type); @@ -4464,7 +4464,7 @@ namespace ts { let reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo; // identity relation does not use apparent type let sourceOrApparentType = relation === identityRelation ? source : getApparentType(source); - if (sourceOrApparentType.flags & TypeFlags.ObjectType && target.flags & TypeFlags.ObjectType) { + if (sourceOrApparentType.flags & (TypeFlags.ObjectType | TypeFlags.Intersection) && target.flags & TypeFlags.ObjectType) { if (result = objectTypeRelatedTo(sourceOrApparentType, target, reportStructuralErrors)) { errorInfo = saveErrorInfo; return result; @@ -4595,7 +4595,7 @@ namespace ts { // Third, check if both types are part of deeply nested chains of generic type instantiations and if so assume the types are // equal and infinitely expanding. Fourth, if we have reached a depth of 100 nested comparisons, assume we have runaway recursion // and issue an error. Otherwise, actually compare the structure of the two types. - function objectTypeRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary { + function objectTypeRelatedTo(source: Type, target: Type, reportErrors: boolean): Ternary { if (overflow) { return Ternary.False; } @@ -4670,7 +4670,7 @@ namespace ts { return result; } - function propertiesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary { + function propertiesRelatedTo(source: Type, target: Type, reportErrors: boolean): Ternary { if (relation === identityRelation) { return propertiesIdenticalTo(source, target); } @@ -4753,7 +4753,10 @@ namespace ts { return result; } - function propertiesIdenticalTo(source: ObjectType, target: ObjectType): Ternary { + function propertiesIdenticalTo(source: Type, target: Type): Ternary { + if (!(source.flags & TypeFlags.ObjectType && target.flags & TypeFlags.ObjectType)) { + return Ternary.False; + } let sourceProperties = getPropertiesOfObjectType(source); let targetProperties = getPropertiesOfObjectType(target); if (sourceProperties.length !== targetProperties.length) { @@ -4774,7 +4777,7 @@ namespace ts { return result; } - function signaturesRelatedTo(source: ObjectType, target: ObjectType, kind: SignatureKind, reportErrors: boolean): Ternary { + function signaturesRelatedTo(source: Type, target: Type, kind: SignatureKind, reportErrors: boolean): Ternary { if (relation === identityRelation) { return signaturesIdenticalTo(source, target, kind); } @@ -4900,7 +4903,7 @@ namespace ts { return result & isRelatedTo(s, t, reportErrors); } - function signaturesIdenticalTo(source: ObjectType, target: ObjectType, kind: SignatureKind): Ternary { + function signaturesIdenticalTo(source: Type, target: Type, kind: SignatureKind): Ternary { let sourceSignatures = getSignaturesOfType(source, kind); let targetSignatures = getSignaturesOfType(target, kind); if (sourceSignatures.length !== targetSignatures.length) { @@ -4917,7 +4920,7 @@ namespace ts { return result; } - function stringIndexTypesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary { + function stringIndexTypesRelatedTo(source: Type, target: Type, reportErrors: boolean): Ternary { if (relation === identityRelation) { return indexTypesIdenticalTo(IndexKind.String, source, target); } @@ -4942,7 +4945,7 @@ namespace ts { return Ternary.True; } - function numberIndexTypesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary { + function numberIndexTypesRelatedTo(source: Type, target: Type, reportErrors: boolean): Ternary { if (relation === identityRelation) { return indexTypesIdenticalTo(IndexKind.Number, source, target); } @@ -4975,7 +4978,7 @@ namespace ts { return Ternary.True; } - function indexTypesIdenticalTo(indexKind: IndexKind, source: ObjectType, target: ObjectType): Ternary { + function indexTypesIdenticalTo(indexKind: IndexKind, source: Type, target: Type): Ternary { let targetType = getIndexTypeOfType(target, indexKind); let sourceType = getIndexTypeOfType(source, indexKind); if (!sourceType && !targetType) { @@ -6335,7 +6338,7 @@ namespace ts { function getTypeOfPropertyOfContextualType(type: Type, name: string) { return applyToContextualType(type, t => { - let prop = getPropertyOfObjectType(t, name); + let prop = t.flags & TypeFlags.StructuredType ? getPropertyOfType(t, name) : undefined; return prop ? getTypeOfSymbol(prop) : undefined; }); } From c623e6cc642d37c355423ad3365bb67494bedb42 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 25 Jun 2015 18:45:03 -0700 Subject: [PATCH 247/309] Adding a few more tests --- .../reference/contextualIntersectionType.js | 14 ++++++ .../contextualIntersectionType.symbols | 23 ++++++++++ .../contextualIntersectionType.types | 27 +++++++++++ .../intersectionTypeAssignment.errors.txt | 45 +++++++++++++++++++ .../reference/intersectionTypeAssignment.js | 35 +++++++++++++++ .../contextualIntersectionType.ts | 5 +++ .../intersectionTypeAssignment.ts | 17 +++++++ 7 files changed, 166 insertions(+) create mode 100644 tests/baselines/reference/contextualIntersectionType.js create mode 100644 tests/baselines/reference/contextualIntersectionType.symbols create mode 100644 tests/baselines/reference/contextualIntersectionType.types create mode 100644 tests/baselines/reference/intersectionTypeAssignment.errors.txt create mode 100644 tests/baselines/reference/intersectionTypeAssignment.js create mode 100644 tests/cases/conformance/types/intersection/contextualIntersectionType.ts create mode 100644 tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts diff --git a/tests/baselines/reference/contextualIntersectionType.js b/tests/baselines/reference/contextualIntersectionType.js new file mode 100644 index 00000000000..d61fc52fce7 --- /dev/null +++ b/tests/baselines/reference/contextualIntersectionType.js @@ -0,0 +1,14 @@ +//// [contextualIntersectionType.ts] +var x: { a: (s: string) => string } & { b: (n: number) => number }; +x = { + a: s => s, + b: n => n +}; + + +//// [contextualIntersectionType.js] +var x; +x = { + a: function (s) { return s; }, + b: function (n) { return n; } +}; diff --git a/tests/baselines/reference/contextualIntersectionType.symbols b/tests/baselines/reference/contextualIntersectionType.symbols new file mode 100644 index 00000000000..cb7ac9f3d41 --- /dev/null +++ b/tests/baselines/reference/contextualIntersectionType.symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/types/intersection/contextualIntersectionType.ts === +var x: { a: (s: string) => string } & { b: (n: number) => number }; +>x : Symbol(x, Decl(contextualIntersectionType.ts, 0, 3)) +>a : Symbol(a, Decl(contextualIntersectionType.ts, 0, 8)) +>s : Symbol(s, Decl(contextualIntersectionType.ts, 0, 13)) +>b : Symbol(b, Decl(contextualIntersectionType.ts, 0, 39)) +>n : Symbol(n, Decl(contextualIntersectionType.ts, 0, 44)) + +x = { +>x : Symbol(x, Decl(contextualIntersectionType.ts, 0, 3)) + + a: s => s, +>a : Symbol(a, Decl(contextualIntersectionType.ts, 1, 5)) +>s : Symbol(s, Decl(contextualIntersectionType.ts, 2, 6)) +>s : Symbol(s, Decl(contextualIntersectionType.ts, 2, 6)) + + b: n => n +>b : Symbol(b, Decl(contextualIntersectionType.ts, 2, 14)) +>n : Symbol(n, Decl(contextualIntersectionType.ts, 3, 6)) +>n : Symbol(n, Decl(contextualIntersectionType.ts, 3, 6)) + +}; + diff --git a/tests/baselines/reference/contextualIntersectionType.types b/tests/baselines/reference/contextualIntersectionType.types new file mode 100644 index 00000000000..4967979d736 --- /dev/null +++ b/tests/baselines/reference/contextualIntersectionType.types @@ -0,0 +1,27 @@ +=== tests/cases/conformance/types/intersection/contextualIntersectionType.ts === +var x: { a: (s: string) => string } & { b: (n: number) => number }; +>x : { a: (s: string) => string; } & { b: (n: number) => number; } +>a : (s: string) => string +>s : string +>b : (n: number) => number +>n : number + +x = { +>x = { a: s => s, b: n => n} : { a: (s: string) => string; b: (n: number) => number; } +>x : { a: (s: string) => string; } & { b: (n: number) => number; } +>{ a: s => s, b: n => n} : { a: (s: string) => string; b: (n: number) => number; } + + a: s => s, +>a : (s: string) => string +>s => s : (s: string) => string +>s : string +>s : string + + b: n => n +>b : (n: number) => number +>n => n : (n: number) => number +>n : number +>n : number + +}; + diff --git a/tests/baselines/reference/intersectionTypeAssignment.errors.txt b/tests/baselines/reference/intersectionTypeAssignment.errors.txt new file mode 100644 index 00000000000..11ea91d8f0e --- /dev/null +++ b/tests/baselines/reference/intersectionTypeAssignment.errors.txt @@ -0,0 +1,45 @@ +tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts(8,1): error TS2322: Type '{ a: string; }' is not assignable to type '{ a: string; b: string; }'. + Property 'b' is missing in type '{ a: string; }'. +tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts(9,1): error TS2322: Type '{ a: string; }' is not assignable to type '{ a: string; } & { b: string; }'. + Type '{ a: string; }' is not assignable to type '{ b: string; }'. + Property 'b' is missing in type '{ a: string; }'. +tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts(13,1): error TS2322: Type '{ b: string; }' is not assignable to type '{ a: string; b: string; }'. + Property 'a' is missing in type '{ b: string; }'. +tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts(14,1): error TS2322: Type '{ b: string; }' is not assignable to type '{ a: string; } & { b: string; }'. + Type '{ b: string; }' is not assignable to type '{ a: string; }'. + Property 'a' is missing in type '{ b: string; }'. + + +==== tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts (4 errors) ==== + var a: { a: string }; + var b: { b: string }; + var x: { a: string, b: string }; + var y: { a: string } & { b: string }; + + a = x; + a = y; + x = a; // Error + ~ +!!! error TS2322: Type '{ a: string; }' is not assignable to type '{ a: string; b: string; }'. +!!! error TS2322: Property 'b' is missing in type '{ a: string; }'. + y = a; // Error + ~ +!!! error TS2322: Type '{ a: string; }' is not assignable to type '{ a: string; } & { b: string; }'. +!!! error TS2322: Type '{ a: string; }' is not assignable to type '{ b: string; }'. +!!! error TS2322: Property 'b' is missing in type '{ a: string; }'. + + b = x; + b = y; + x = b; // Error + ~ +!!! error TS2322: Type '{ b: string; }' is not assignable to type '{ a: string; b: string; }'. +!!! error TS2322: Property 'a' is missing in type '{ b: string; }'. + y = b; // Error + ~ +!!! error TS2322: Type '{ b: string; }' is not assignable to type '{ a: string; } & { b: string; }'. +!!! error TS2322: Type '{ b: string; }' is not assignable to type '{ a: string; }'. +!!! error TS2322: Property 'a' is missing in type '{ b: string; }'. + + x = y; + y = x; + \ No newline at end of file diff --git a/tests/baselines/reference/intersectionTypeAssignment.js b/tests/baselines/reference/intersectionTypeAssignment.js new file mode 100644 index 00000000000..f1cddbf3b2a --- /dev/null +++ b/tests/baselines/reference/intersectionTypeAssignment.js @@ -0,0 +1,35 @@ +//// [intersectionTypeAssignment.ts] +var a: { a: string }; +var b: { b: string }; +var x: { a: string, b: string }; +var y: { a: string } & { b: string }; + +a = x; +a = y; +x = a; // Error +y = a; // Error + +b = x; +b = y; +x = b; // Error +y = b; // Error + +x = y; +y = x; + + +//// [intersectionTypeAssignment.js] +var a; +var b; +var x; +var y; +a = x; +a = y; +x = a; // Error +y = a; // Error +b = x; +b = y; +x = b; // Error +y = b; // Error +x = y; +y = x; diff --git a/tests/cases/conformance/types/intersection/contextualIntersectionType.ts b/tests/cases/conformance/types/intersection/contextualIntersectionType.ts new file mode 100644 index 00000000000..580827992ac --- /dev/null +++ b/tests/cases/conformance/types/intersection/contextualIntersectionType.ts @@ -0,0 +1,5 @@ +var x: { a: (s: string) => string } & { b: (n: number) => number }; +x = { + a: s => s, + b: n => n +}; diff --git a/tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts b/tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts new file mode 100644 index 00000000000..00a299ea244 --- /dev/null +++ b/tests/cases/conformance/types/intersection/intersectionTypeAssignment.ts @@ -0,0 +1,17 @@ +var a: { a: string }; +var b: { b: string }; +var x: { a: string, b: string }; +var y: { a: string } & { b: string }; + +a = x; +a = y; +x = a; // Error +y = a; // Error + +b = x; +b = y; +x = b; // Error +y = b; // Error + +x = y; +y = x; From 133a86a3773868178d0aa6c53981f8b68087d7a1 Mon Sep 17 00:00:00 2001 From: mihailik Date: Fri, 26 Jun 2015 09:22:55 +0100 Subject: [PATCH 248/309] Conflict with Object.prototype.watch in FireFox/Gecko In Gecko engine `commandLine.options.watch` evaluates to a truthy value (a function). Adding an extra check to work around. [Definition of CompilerOptions.watch in compiler/types](https://github.com/Microsoft/TypeScript/blob/master/src/compiler/types.ts#L1860) ``` typescript export interface CompilerOptions { // . . . watch?: boolean; ``` [Object.prototype.watch on MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/watch) > Warning: Generally you should avoid using watch() and unwatch() when possible. These two methods are > implemented only in Gecko, and they're intended primarily for debugging use. In addition, using watchpoints > has a serious negative impact on performance, which is especially true when used on global objects, such > as window. You can usually use setters and getters or proxies instead. See Browser compatibility for details. > Also, do not confuse Object.watch with Object.observe. --- src/compiler/tsc.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index 2903c3a31f4..eada189d642 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -191,7 +191,7 @@ namespace ts { return sys.exit(ExitStatus.Success); } - if (commandLine.options.watch) { + if (commandLine.options.watch && commandLine.options.hasOwnProperty('watch')) { // FireFox has Object.prototype.watch if (!sys.watchFile) { reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch")); return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped); From e7e020e958bb4e9ec7942227be32092624a4ee99 Mon Sep 17 00:00:00 2001 From: mihailik Date: Fri, 26 Jun 2015 14:38:25 +0100 Subject: [PATCH 249/309] PR feedback - comments and whitespace adjustments --- src/compiler/tsc.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index eada189d642..1851e516abd 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -191,7 +191,8 @@ namespace ts { return sys.exit(ExitStatus.Success); } - if (commandLine.options.watch && commandLine.options.hasOwnProperty('watch')) { // FireFox has Object.prototype.watch + // Firefox has Object.prototype.watch + if (commandLine.options.watch && commandLine.options.hasOwnProperty('watch')) { if (!sys.watchFile) { reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch")); return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped); From b1a05b8d3ce6fb94ca8ea30a90ad5822e7efb421 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Fri, 26 Jun 2015 09:38:21 -0700 Subject: [PATCH 250/309] Improve commandline help for --jsx --- src/compiler/commandLineParser.ts | 2 +- src/compiler/diagnosticInformationMap.generated.ts | 2 +- src/compiler/diagnosticMessages.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index e635def2131..35c5bc14c84 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -45,7 +45,7 @@ namespace ts { "react": JsxEmit.React }, paramType: Diagnostics.KIND, - description: Diagnostics.Specifies_how_to_transform_JSX_syntax_during_compilation, + description: Diagnostics.Specify_JSX_code_generation_Colon_preserve_or_react, error: Diagnostics.Argument_for_jsx_must_be_preserve_or_react }, { diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 674d6831904..04db6f21048 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -541,7 +541,7 @@ namespace ts { Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." }, NEWLINE: { code: 6061, category: DiagnosticCategory.Message, key: "NEWLINE" }, Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." }, - Specifies_how_to_transform_JSX_syntax_during_compilation: { code: 6080, category: DiagnosticCategory.Message, key: "Specifies how to transform JSX syntax during compilation." }, + Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: DiagnosticCategory.Message, key: "Specify JSX code generation: 'preserve' or 'react'" }, Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: DiagnosticCategory.Message, key: "Argument for '--jsx' must be 'preserve' or 'react'." }, Option_experimentalDecorators_must_also_be_specified_when_option_emitDecoratorMetadata_is_specified: { code: 6064, category: DiagnosticCategory.Error, key: "Option 'experimentalDecorators' must also be specified when option 'emitDecoratorMetadata' is specified." }, Enables_experimental_support_for_ES7_decorators: { code: 6065, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 decorators." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 468f162ce3f..f21150d9323 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2156,7 +2156,7 @@ "category": "Error", "code": 6062 }, - "Specifies how to transform JSX syntax during compilation.": { + "Specify JSX code generation: 'preserve' or 'react'": { "category": "Message", "code": 6080 }, From 18588104dbd359e54eb4501988139554f58e56fc Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 26 Jun 2015 09:47:58 -0700 Subject: [PATCH 251/309] Preserve order in intersection types --- src/compiler/checker.ts | 76 ++++++++++++++++++++--------------------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 32e00af577d..186e35ccfe3 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1539,8 +1539,8 @@ namespace ts { else if (type.flags & TypeFlags.Tuple) { writeTupleType(type); } - else if (type.flags & (TypeFlags.Union | TypeFlags.Intersection)) { - writeUnionOrIntersectionType(type, flags); + else if (type.flags & TypeFlags.UnionOrIntersection) { + writeUnionOrIntersectionType(type, flags); } else if (type.flags & TypeFlags.Anonymous) { writeAnonymousType(type, flags); @@ -3143,7 +3143,7 @@ namespace ts { resolveUnionTypeMembers(type); } else if (type.flags & TypeFlags.Intersection) { - resolveIntersectionTypeMembers(type); + resolveIntersectionTypeMembers(type); } else { resolveTypeReferenceMembers(type); @@ -3299,7 +3299,7 @@ namespace ts { return getPropertyOfObjectType(globalObjectType, name); } if (type.flags & TypeFlags.UnionOrIntersection) { - return getPropertyOfUnionOrIntersectionType(type, name); + return getPropertyOfUnionOrIntersectionType(type, name); } return undefined; } @@ -3864,28 +3864,25 @@ namespace ts { return links.resolvedType; } - function addTypeToSortedSet(sortedSet: Type[], type: Type, typeKind: TypeFlags) { + function addTypeToSet(typeSet: Type[], type: Type, typeKind: TypeFlags) { if (type.flags & typeKind) { - addTypesToSortedSet(sortedSet, (type).types, typeKind); + addTypesToSet(typeSet, (type).types, typeKind); } - else { - let i = 0; - let id = type.id; - while (i < sortedSet.length && sortedSet[i].id < id) { - i++; - } - if (i === sortedSet.length || sortedSet[i].id !== id) { - sortedSet.splice(i, 0, type); - } + else if (!contains(typeSet, type)) { + typeSet.push(type); } } - function addTypesToSortedSet(sortedTypes: Type[], types: Type[], typeKind: TypeFlags) { + function addTypesToSet(typeSet: Type[], types: Type[], typeKind: TypeFlags) { for (let type of types) { - addTypeToSortedSet(sortedTypes, type, typeKind); + addTypeToSet(typeSet, type, typeKind); } } + function compareTypeIds(type1: Type, type2: Type): number { + return type1.id - type2.id; + } + function isSubtypeOfAny(candidate: Type, types: Type[]): boolean { for (let type of types) { if (candidate !== type && isTypeSubtypeOf(candidate, type)) { @@ -3932,26 +3929,27 @@ namespace ts { if (types.length === 0) { return emptyObjectType; } - let sortedTypes: Type[] = []; - addTypesToSortedSet(sortedTypes, types, TypeFlags.Union); + let typeSet: Type[] = []; + addTypesToSet(typeSet, types, TypeFlags.Union); + typeSet.sort(compareTypeIds); if (noSubtypeReduction) { - if (containsTypeAny(sortedTypes)) { + if (containsTypeAny(typeSet)) { return anyType; } - removeAllButLast(sortedTypes, undefinedType); - removeAllButLast(sortedTypes, nullType); + removeAllButLast(typeSet, undefinedType); + removeAllButLast(typeSet, nullType); } else { - removeSubtypes(sortedTypes); + removeSubtypes(typeSet); } - if (sortedTypes.length === 1) { - return sortedTypes[0]; + if (typeSet.length === 1) { + return typeSet[0]; } - let id = getTypeListId(sortedTypes); + let id = getTypeListId(typeSet); let type = unionTypes[id]; if (!type) { - type = unionTypes[id] = createObjectType(TypeFlags.Union | getWideningFlagsOfTypes(sortedTypes)); - type.types = sortedTypes; + type = unionTypes[id] = createObjectType(TypeFlags.Union | getWideningFlagsOfTypes(typeSet)); + type.types = typeSet; type.reducedType = noSubtypeReduction ? undefined : type; } return type; @@ -3986,20 +3984,22 @@ namespace ts { // We do not perform supertype reduction on intersection types. Intersection types are created only by the & // type operator and we can't reduce those because we want to support recursive intersection types. For example, // a type alias of the form "type List = T & { next: List }" cannot be reduced during its declaration. + // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution + // for intersections of types with signatues can be deterministic. function getIntersectionType(types: Type[]): Type { - let sortedTypes: Type[] = []; - addTypesToSortedSet(sortedTypes, types, TypeFlags.Intersection); - if (containsTypeAny(sortedTypes)) { + let typeSet: Type[] = []; + addTypesToSet(typeSet, types, TypeFlags.Intersection); + if (containsTypeAny(typeSet)) { return anyType; } - if (sortedTypes.length === 1) { - return sortedTypes[0]; + if (typeSet.length === 1) { + return typeSet[0]; } - let id = getTypeListId(sortedTypes); + let id = getTypeListId(typeSet); let type = intersectionTypes[id]; if (!type) { - type = intersectionTypes[id] = createObjectType(TypeFlags.Intersection | getWideningFlagsOfTypes(sortedTypes)); - type.types = sortedTypes; + type = intersectionTypes[id] = createObjectType(TypeFlags.Intersection | getWideningFlagsOfTypes(typeSet)); + type.types = typeSet; } return type; } @@ -8128,7 +8128,7 @@ namespace ts { return true; } if (type.flags & TypeFlags.UnionOrIntersection) { - let types = (type).types; + let types = (type).types; for (let current of types) { if (current.flags & kind) { return true; @@ -8145,7 +8145,7 @@ namespace ts { return true; } if (type.flags & TypeFlags.UnionOrIntersection) { - let types = (type).types; + let types = (type).types; for (let current of types) { if (!(current.flags & kind)) { return false; From 90ffdf77c9b78db2792212eed21647644119a654 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 26 Jun 2015 09:48:36 -0700 Subject: [PATCH 252/309] Adding test --- .../reference/intersectionTypeOverloading.js | 26 ++++++++++++ .../intersectionTypeOverloading.symbols | 36 +++++++++++++++++ .../intersectionTypeOverloading.types | 40 +++++++++++++++++++ .../intersectionTypeOverloading.ts | 14 +++++++ 4 files changed, 116 insertions(+) create mode 100644 tests/baselines/reference/intersectionTypeOverloading.js create mode 100644 tests/baselines/reference/intersectionTypeOverloading.symbols create mode 100644 tests/baselines/reference/intersectionTypeOverloading.types create mode 100644 tests/cases/conformance/types/intersection/intersectionTypeOverloading.ts diff --git a/tests/baselines/reference/intersectionTypeOverloading.js b/tests/baselines/reference/intersectionTypeOverloading.js new file mode 100644 index 00000000000..b7080e449b7 --- /dev/null +++ b/tests/baselines/reference/intersectionTypeOverloading.js @@ -0,0 +1,26 @@ +//// [intersectionTypeOverloading.ts] +// Check that order is preserved in intersection types for purposes of +// overload resolution + +type F = (s: string) => string; +type G = (x: any) => any; + +var fg: F & G; +var gf: G & F; + +var x = fg("abc"); +var x: string; + +var y = gf("abc"); +var y: any; + + +//// [intersectionTypeOverloading.js] +// Check that order is preserved in intersection types for purposes of +// overload resolution +var fg; +var gf; +var x = fg("abc"); +var x; +var y = gf("abc"); +var y; diff --git a/tests/baselines/reference/intersectionTypeOverloading.symbols b/tests/baselines/reference/intersectionTypeOverloading.symbols new file mode 100644 index 00000000000..c8503345041 --- /dev/null +++ b/tests/baselines/reference/intersectionTypeOverloading.symbols @@ -0,0 +1,36 @@ +=== tests/cases/conformance/types/intersection/intersectionTypeOverloading.ts === +// Check that order is preserved in intersection types for purposes of +// overload resolution + +type F = (s: string) => string; +>F : Symbol(F, Decl(intersectionTypeOverloading.ts, 0, 0)) +>s : Symbol(s, Decl(intersectionTypeOverloading.ts, 3, 10)) + +type G = (x: any) => any; +>G : Symbol(G, Decl(intersectionTypeOverloading.ts, 3, 31)) +>x : Symbol(x, Decl(intersectionTypeOverloading.ts, 4, 10)) + +var fg: F & G; +>fg : Symbol(fg, Decl(intersectionTypeOverloading.ts, 6, 3)) +>F : Symbol(F, Decl(intersectionTypeOverloading.ts, 0, 0)) +>G : Symbol(G, Decl(intersectionTypeOverloading.ts, 3, 31)) + +var gf: G & F; +>gf : Symbol(gf, Decl(intersectionTypeOverloading.ts, 7, 3)) +>G : Symbol(G, Decl(intersectionTypeOverloading.ts, 3, 31)) +>F : Symbol(F, Decl(intersectionTypeOverloading.ts, 0, 0)) + +var x = fg("abc"); +>x : Symbol(x, Decl(intersectionTypeOverloading.ts, 9, 3), Decl(intersectionTypeOverloading.ts, 10, 3)) +>fg : Symbol(fg, Decl(intersectionTypeOverloading.ts, 6, 3)) + +var x: string; +>x : Symbol(x, Decl(intersectionTypeOverloading.ts, 9, 3), Decl(intersectionTypeOverloading.ts, 10, 3)) + +var y = gf("abc"); +>y : Symbol(y, Decl(intersectionTypeOverloading.ts, 12, 3), Decl(intersectionTypeOverloading.ts, 13, 3)) +>gf : Symbol(gf, Decl(intersectionTypeOverloading.ts, 7, 3)) + +var y: any; +>y : Symbol(y, Decl(intersectionTypeOverloading.ts, 12, 3), Decl(intersectionTypeOverloading.ts, 13, 3)) + diff --git a/tests/baselines/reference/intersectionTypeOverloading.types b/tests/baselines/reference/intersectionTypeOverloading.types new file mode 100644 index 00000000000..c478b6a08cb --- /dev/null +++ b/tests/baselines/reference/intersectionTypeOverloading.types @@ -0,0 +1,40 @@ +=== tests/cases/conformance/types/intersection/intersectionTypeOverloading.ts === +// Check that order is preserved in intersection types for purposes of +// overload resolution + +type F = (s: string) => string; +>F : (s: string) => string +>s : string + +type G = (x: any) => any; +>G : (x: any) => any +>x : any + +var fg: F & G; +>fg : ((s: string) => string) & ((x: any) => any) +>F : (s: string) => string +>G : (x: any) => any + +var gf: G & F; +>gf : ((x: any) => any) & ((s: string) => string) +>G : (x: any) => any +>F : (s: string) => string + +var x = fg("abc"); +>x : string +>fg("abc") : string +>fg : ((s: string) => string) & ((x: any) => any) +>"abc" : string + +var x: string; +>x : string + +var y = gf("abc"); +>y : any +>gf("abc") : any +>gf : ((x: any) => any) & ((s: string) => string) +>"abc" : string + +var y: any; +>y : any + diff --git a/tests/cases/conformance/types/intersection/intersectionTypeOverloading.ts b/tests/cases/conformance/types/intersection/intersectionTypeOverloading.ts new file mode 100644 index 00000000000..0a0d30d8dbb --- /dev/null +++ b/tests/cases/conformance/types/intersection/intersectionTypeOverloading.ts @@ -0,0 +1,14 @@ +// Check that order is preserved in intersection types for purposes of +// overload resolution + +type F = (s: string) => string; +type G = (x: any) => any; + +var fg: F & G; +var gf: G & F; + +var x = fg("abc"); +var x: string; + +var y = gf("abc"); +var y: any; From 72050073bc9d6448dc4c7114b53c4e7fcb9b6ed5 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Fri, 26 Jun 2015 10:25:58 -0700 Subject: [PATCH 253/309] use double quotes --- src/compiler/tsc.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index 1851e516abd..2a01774fbca 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -192,7 +192,7 @@ namespace ts { } // Firefox has Object.prototype.watch - if (commandLine.options.watch && commandLine.options.hasOwnProperty('watch')) { + if (commandLine.options.watch && commandLine.options.hasOwnProperty("watch")) { if (!sys.watchFile) { reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch")); return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped); From 306de4d6816d6b365a1f7d4f2040d5f10ce30f2f Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Fri, 26 Jun 2015 14:18:51 -0700 Subject: [PATCH 254/309] CR feedback --- src/compiler/checker.ts | 33 ++++---- src/compiler/emitter.ts | 60 +++++++------- src/compiler/parser.ts | 6 +- src/compiler/types.ts | 2 - src/compiler/utilities.ts | 5 ++ src/services/services.ts | 2 +- .../jsxEsprimaFbTestSuite.errors.txt | 81 +++++++++++++++++++ .../reference/jsxEsprimaFbTestSuite.js | 5 +- .../jsxInvalidEsprimaTestSuite.errors.txt | 9 ++- .../reference/jsxInvalidEsprimaTestSuite.js | 4 +- 10 files changed, 145 insertions(+), 62 deletions(-) create mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 101b8ceb23c..f3f87f05c0e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -165,7 +165,7 @@ namespace ts { } }; - let JsxNames = { + const JsxNames = { JSX: "JSX", IntrinsicElements: "IntrinsicElements", ElementClass: "ElementClass", @@ -5578,6 +5578,7 @@ namespace ts { case SyntaxKind.JsxAttribute: case SyntaxKind.JsxSpreadAttribute: case SyntaxKind.JsxOpeningElement: + case SyntaxKind.JsxExpression: return forEachChild(node, isAssignedIn); } return false; @@ -6774,8 +6775,7 @@ namespace ts { return false; } else { - let firstChar = (tagName).text.charAt(0); - return firstChar.toLowerCase() === firstChar; + return isIntrinsicJsxName((tagName).text); } } @@ -6836,10 +6836,7 @@ namespace ts { /// Returns the type JSX.IntrinsicElements. May return `unknownType` if that type is not present. function getJsxIntrinsicElementsType() { if (!jsxIntrinsicElementsType) { - let jsxNamespace = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, undefined); - let intrinsicsSymbol = jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.IntrinsicElements, SymbolFlags.Type); - let intrinsicsType = intrinsicsSymbol && getDeclaredTypeOfSymbol(intrinsicsSymbol); - jsxIntrinsicElementsType = intrinsicsType || unknownType; + jsxIntrinsicElementsType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.IntrinsicElements) || unknownType; } return jsxIntrinsicElementsType; } @@ -6977,18 +6974,23 @@ namespace ts { let attribProperties = attribPropType && getPropertiesOfType(attribPropType); if (attribProperties) { + // Element Attributes has zero properties, so the element attributes type will be the class instance type if (attribProperties.length === 0) { return ''; } + // Element Attributes has one property, so the element attributes type will be the type of the corresponding + // property of the class instance type else if (attribProperties.length === 1) { return attribProperties[0].name; } + // More than one property on ElementAttributesProperty is an error else { error(attribsPropTypeSym.declarations[0], Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, JsxNames.ElementAttributesPropertyNameContainer); return undefined; } } else { + // No interface exists, so the element attributes type will be an implicit any return undefined; } } @@ -7044,7 +7046,7 @@ namespace ts { return links.resolvedJsxType = getIndexTypeOfSymbol(sym, IndexKind.String); } else { - // Resolution failed + // Resolution failed, so we don't know return links.resolvedJsxType = anyType; } } @@ -7063,16 +7065,12 @@ namespace ts { return prop || unknownSymbol; } + let jsxElementClassType: Type = undefined; function getJsxGlobalElementClassType(): Type { - let jsxNS = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined); - if (jsxNS) { - let sym = getSymbol(jsxNS.exports, JsxNames.ElementClass, SymbolFlags.Type); - let elemClassType = sym && getDeclaredTypeOfSymbol(sym); - return elemClassType; - } - else { - return undefined; + if(!jsxElementClassType) { + jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass); } + return jsxElementClassType; } /// Returns all the properties of the Jsx.IntrinsicElements interface @@ -7137,8 +7135,7 @@ namespace ts { return checkExpression(node.expression); } else { - /// is shorthand for - return booleanType; + return unknownType; } } diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 2764ae8e86a..3b1a1609c39 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1113,20 +1113,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { /// Emit a tag name, which is either '"div"' for lower-cased names, or /// 'Div' for upper-cased or dotted names function emitTagName(name: Identifier|QualifiedName) { - if (name.kind === SyntaxKind.Identifier) { - var ch = (name).text.charAt(0); - if (ch.toUpperCase() === ch) { - emit(name); - } - else { - write('"'); - emit(name); - write('"'); - } - return ch.toUpperCase() !== ch; + if (name.kind === SyntaxKind.Identifier && isIntrinsicJsxName((name).text)) { + write('"'); + emit(name); + write('"'); } else { - Debug.assert(name.kind === SyntaxKind.QualifiedName); emit(name); } } @@ -1234,12 +1226,19 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } // Don't emit empty strings - if (children[i].kind === SyntaxKind.JsxText && !shouldEmitJsxText(children[i])) { - continue; + if (children[i].kind === SyntaxKind.JsxText) { + let text = getTextToEmit(children[i]); + if(text !== undefined) { + write(', "'); + write(text); + write('"'); + } + } + else { + write(', '); + emit(children[i]); } - write(', '); - emit(children[i]); } } @@ -5895,12 +5894,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } function trimReactWhitespace(node: JsxText): string { - // Could be empty string, do not use !node.formattedReactText - if (node.formattedReactText !== undefined) { - return node.formattedReactText; - } - - let lines: string[] = []; + let result: string = undefined; let text = getTextOfNode(node); let firstNonWhitespace = 0; let lastNonWhitespace = -1; @@ -5910,9 +5904,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { // on the same line as the closing tag. See examples in tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx for (let i = 0; i < text.length; i++) { let c = text.charCodeAt(i); - if (c === CharacterCodes.lineFeed || c === CharacterCodes.carriageReturn) { + if (isLineBreak(c)) { if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) { - lines.push(text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1)); + let part = text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1); + result = (result ? result + '" + \' \' + "' : '') + part; } firstNonWhitespace = -1; } @@ -5924,19 +5919,26 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } } if (firstNonWhitespace !== -1) { - lines.push(text.substr(firstNonWhitespace)); + let part = text.substr(firstNonWhitespace); + result = (result ? result + '" + \' \' + "' : '') + part; } - return node.formattedReactText = lines.join('" + \' \' + "'); + return result; } - function shouldEmitJsxText(node: JsxText) { + function getTextToEmit(node: JsxText) { switch (compilerOptions.jsx) { case JsxEmit.React: - return trimReactWhitespace(node).length > 0; + let text = trimReactWhitespace(node); + if (text.length === 0) { + return undefined; + } + else { + return text; + } case JsxEmit.Preserve: default: - return true; + return getTextOfNode(node, true); } } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index af2e6b98547..84f05719151 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -657,7 +657,7 @@ namespace ts { sourceFile.languageVersion = languageVersion; sourceFile.fileName = normalizePath(fileName); sourceFile.flags = fileExtensionIs(sourceFile.fileName, ".d.ts") ? NodeFlags.DeclarationFile : 0; - sourceFile.languageVariant = fileExtensionIs(sourceFile.fileName, ".tsx") ? LanguageVariant.JSX : LanguageVariant.Standard; + sourceFile.languageVariant = isTsx(sourceFile.fileName) ? LanguageVariant.JSX : LanguageVariant.Standard; return sourceFile; } @@ -1298,7 +1298,6 @@ namespace ts { case ParsingContext.HeritageClauses: return token === SyntaxKind.OpenBraceToken || token === SyntaxKind.CloseBraceToken; case ParsingContext.JsxAttributes: - // REMOVE -> // For error recovery, include } here (otherwise an over-braced {expr}} will close the surrounding statement block and mess up the entire file). return token === SyntaxKind.GreaterThanToken || token === SyntaxKind.SlashToken; case ParsingContext.JsxChildren: return token === SyntaxKind.LessThanToken && lookAhead(nextTokenIsSlash); @@ -3377,9 +3376,6 @@ namespace ts { node.name = parseIdentifierName(); if (parseOptional(SyntaxKind.EqualsToken)) { switch (token) { - case SyntaxKind.LessThanToken: - node.initializer = parseJsxElementOrSelfClosingElement(); - break; case SyntaxKind.StringLiteral: node.initializer = parseLiteralNode(); break; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 7f45138bf7d..0b7605ef77f 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -877,8 +877,6 @@ namespace ts { export interface JsxText extends Node { _jsxTextExpressionBrand: any; - /// Used by the emitter to avoid recomputation - formattedReactText?: string; } export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 29f91e8c502..b326d5256f0 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -1535,6 +1535,11 @@ namespace ts { } } + export function isIntrinsicJsxName(name: string) { + let ch = name.substr(0, 1); + return ch.toLowerCase() === ch; + } + function get16BitUnicodeEscapeSequence(charCode: number): string { let hexCharCode = charCode.toString(16).toUpperCase(); let paddedHexCode = ("0000" + hexCharCode).slice(-4); diff --git a/src/services/services.ts b/src/services/services.ts index 7b9de36e33c..d2229bdbf91 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -2934,7 +2934,7 @@ namespace ts { getTypeScriptMemberSymbols(); } else if (isRightOfOpenTag) { - let tagSymbols = typeChecker.getJsxIntrinsicTagNames();; + let tagSymbols = typeChecker.getJsxIntrinsicTagNames(); if (tryGetGlobalSymbols()) { symbols = tagSymbols.concat(symbols.filter(s => !!(s.flags & SymbolFlags.Value))); } diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt b/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt new file mode 100644 index 00000000000..5758db36960 --- /dev/null +++ b/tests/baselines/reference/jsxEsprimaFbTestSuite.errors.txt @@ -0,0 +1,81 @@ +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,17): error TS1005: '{' expected. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,23): error TS1005: '}' expected. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,29): error TS1005: '{' expected. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,57): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(39,58): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(41,1): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(41,6): error TS1109: Expression expected. +tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx(41,12): error TS1109: Expression expected. + + +==== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx (8 errors) ==== + declare var React: any; + declare var 日本語; + declare var AbC_def; + declare var LeftRight; + declare var x; + declare var a; + declare var props; + + ; + + //; Namespace unsuported + + // {value} ; Namespace unsuported + + ; + + ; + ; + + <日本語>; + + + bar + baz + ; + + : } />; + + {}; + + {/* this is a comment */}; + +
@test content
; + +

7x invalid-js-identifier
; + + right=monkeys /> gorillas />; + ~ +!!! error TS1005: '{' expected. + ~~~~~ +!!! error TS1005: '}' expected. + ~ +!!! error TS1005: '{' expected. + ~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1109: Expression expected. + + ; + ~ +!!! error TS1003: Identifier expected. + ~~ +!!! error TS1109: Expression expected. + ~ +!!! error TS1109: Expression expected. + + ; + + (
) < x; + +
; + +
; + +
; + + ; + \ No newline at end of file diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.js b/tests/baselines/reference/jsxEsprimaFbTestSuite.js index 2050c39972c..1e22826f440 100644 --- a/tests/baselines/reference/jsxEsprimaFbTestSuite.js +++ b/tests/baselines/reference/jsxEsprimaFbTestSuite.js @@ -71,8 +71,9 @@ baz ;
@test content
;

7x invalid-js-identifier
; - right=monkeys /> gorillas/>; -; +} right={monkeys /> gorillas / > }/> + < a.b > ; +a.b > ; ; (
) < x;
; diff --git a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt index e63809913f2..3e2a10e9931 100644 --- a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt +++ b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.errors.txt @@ -65,12 +65,13 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,10): error TS2304: tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,28): error TS1005: '>' expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(28,29): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(32,6): error TS1005: '{' expected. -tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,7): error TS1003: Identifier expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,6): error TS1005: '{' expected. +tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(33,7): error TS1109: Expression expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,4): error TS1003: Identifier expected. tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002: Expected corresponding JSX closing tag for 'a'. -==== tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx (70 errors) ==== +==== tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx (71 errors) ==== declare var React: any; ; @@ -238,8 +239,10 @@ tests/cases/conformance/jsx/jsxInvalidEsprimaTestSuite.tsx(35,21): error TS17002 ~ !!! error TS1005: '{' expected. ; + ~ +!!! error TS1005: '{' expected. ~ -!!! error TS1003: Identifier expected. +!!! error TS1109: Expression expected. }; ; ~~~ diff --git a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.js b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.js index a53cf33410d..13808cc29e0 100644 --- a/tests/baselines/reference/jsxInvalidEsprimaTestSuite.js +++ b/tests/baselines/reference/jsxInvalidEsprimaTestSuite.js @@ -76,6 +76,6 @@ var x =
one
/* intervening comment */ /* intervening comment */
>; >; ; -/>}>; +; }; - .../*hai*/asdf/>;; + .../*hai*/asdf/>;; From ce6f39edca289fe0a6b246fbce87010d0e4f7529 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Fri, 26 Jun 2015 14:21:29 -0700 Subject: [PATCH 255/309] Move token scan to inside `if` --- src/compiler/parser.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 84f05719151..b5cba38f39f 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2850,8 +2850,8 @@ namespace ts { if (sourceFile.languageVariant === LanguageVariant.JSX) { let isArrowFunctionInJsx = lookAhead(() => { let third = nextToken(); - let fourth = nextToken(); if (third === SyntaxKind.ExtendsKeyword) { + let fourth = nextToken(); switch (fourth) { case SyntaxKind.EqualsToken: case SyntaxKind.GreaterThanToken: From 83163697864611d81c74f98115e4f03b5641865c Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 29 Jun 2015 09:46:41 -0400 Subject: [PATCH 256/309] Added tests. --- .../renameLocationsForClassExpression01.ts | 34 +++++++++++++++++++ .../renameLocationsForFunctionExpression01.ts | 10 +++--- .../renameLocationsForFunctionExpression02.ts | 18 ++++++++++ 3 files changed, 57 insertions(+), 5 deletions(-) create mode 100644 tests/cases/fourslash/renameLocationsForClassExpression01.ts create mode 100644 tests/cases/fourslash/renameLocationsForFunctionExpression02.ts diff --git a/tests/cases/fourslash/renameLocationsForClassExpression01.ts b/tests/cases/fourslash/renameLocationsForClassExpression01.ts new file mode 100644 index 00000000000..a1174d503ed --- /dev/null +++ b/tests/cases/fourslash/renameLocationsForClassExpression01.ts @@ -0,0 +1,34 @@ +/// + +////class Foo { +////} +//// +////var x = class /**/Foo { +//// doIt() { +//// return Foo; +//// } +//// +//// static doItStatically() { +//// return Foo; +//// } +////} +//// +////var y = class { +//// getSomeName() { +//// return Foo +//// } +////} + + +// TODO (yuit): Fix up this test when class expressions are supported. +// Just uncomment the below, remove the marker, and add the +// appropriate ranges in the test itself. +goTo.marker(); +verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); + +////let ranges = test.ranges() +////for (let range of ranges) { +//// goTo.position(range.start); +//// +//// verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); +////} \ No newline at end of file diff --git a/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts b/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts index b2f54853c7b..e884783d960 100644 --- a/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts +++ b/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts @@ -1,12 +1,12 @@ /// -////var x = function /*1*/[|f|](g: any, h: any) { -//// /*2*/[|f|](/*3*/[|f|], g); +////var x = function [|f|](g: any, h: any) { +//// [|f|]([|f|], g); ////} -let markers = test.markers() -for (let marker of markers) { - goTo.position(marker.position); +let ranges = test.ranges() +for (let range of ranges) { + goTo.position(range.start); verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); } \ No newline at end of file diff --git a/tests/cases/fourslash/renameLocationsForFunctionExpression02.ts b/tests/cases/fourslash/renameLocationsForFunctionExpression02.ts new file mode 100644 index 00000000000..8186611cb64 --- /dev/null +++ b/tests/cases/fourslash/renameLocationsForFunctionExpression02.ts @@ -0,0 +1,18 @@ +/// + +////function f() { +//// +////} +////var x = function [|f|](g: any, h: any) { +//// +//// let helper = function f(): any { f(); } +//// +//// let foo = () => [|f|]([|f|], g); +////} + +let ranges = test.ranges() +for (let range of ranges) { + goTo.position(range.start); + + verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); +} \ No newline at end of file From 4143d1df7fc36410cd9323200765bc27a3f065b5 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 29 Jun 2015 10:29:23 -0400 Subject: [PATCH 257/309] Addressed CR feedback. --- src/services/services.ts | 9 ++++++--- src/services/utilities.ts | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 21537f0fa14..b0bf52291c0 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4965,7 +4965,8 @@ namespace ts { // Compute the meaning from the location and the symbol it references let searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations); - // Get the text to search for, we need to normalize it as external module names will have quotes + // Get the text to search for. + // Note: if this is an external module symbol, the name doesn't include quotes. let declaredName = getDeclaredName(typeChecker, symbol, node); // Try to get the smallest valid scope that we can limit our search to; @@ -5019,7 +5020,7 @@ namespace ts { }); } - function getInternedName(symbol: Symbol, location: Node, declarations: Declaration[]) { + function getInternedName(symbol: Symbol, location: Node, declarations: Declaration[]): string { // If this is an export or import specifier it could have been renamed using the 'as' syntax. // If so we want to search for whatever under the cursor. if (isImportOrExportSpecifierName(location)) { @@ -5036,8 +5037,10 @@ namespace ts { /** * Determines the smallest scope in which a symbol may have named references. + * Note that not every construct has been accounted for. This function can + * probably be improved. * - * Returns undefined if the scope cannot be determined, often implying that + * @returns undefined if the scope cannot be determined, implying that * a reference to a symbol can occur anywhere. */ function getSymbolScope(symbol: Symbol): Node { diff --git a/src/services/utilities.ts b/src/services/utilities.ts index a6834e1230d..0fd945caa7d 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -653,7 +653,7 @@ namespace ts { }); } - export function getDeclaredName(typeChecker: TypeChecker, symbol: Symbol, location: Node) { + export function getDeclaredName(typeChecker: TypeChecker, symbol: Symbol, location: Node): string { // If this is an export or import specifier it could have been renamed using the 'as' syntax. // If so we want to search for whatever is under the cursor. if (isImportOrExportSpecifierName(location)) { From cdc8c3b5fb10ae6cb9fa43045b4717b9b8593ad4 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 29 Jun 2015 11:09:40 -0400 Subject: [PATCH 258/309] Use full display name in tests. This is a modified revert of 33693e8 --- tests/cases/fourslash/renameForDefaultExport04.ts | 3 ++- tests/cases/fourslash/renameForDefaultExport05.ts | 3 ++- tests/cases/fourslash/renameForDefaultExport06.ts | 3 ++- tests/cases/fourslash/renameForDefaultExport07.ts | 3 ++- tests/cases/fourslash/renameForDefaultExport08.ts | 3 ++- tests/cases/fourslash/renameForDefaultExport09.ts | 1 + 6 files changed, 11 insertions(+), 5 deletions(-) diff --git a/tests/cases/fourslash/renameForDefaultExport04.ts b/tests/cases/fourslash/renameForDefaultExport04.ts index 8c4e2733e33..ba40374e262 100644 --- a/tests/cases/fourslash/renameForDefaultExport04.ts +++ b/tests/cases/fourslash/renameForDefaultExport04.ts @@ -1,5 +1,6 @@ /// +// @Filename: foo.ts ////export default class /**/[|DefaultExportedClass|] { ////} /////* @@ -11,4 +12,4 @@ ////var y = new DefaultExportedClass; goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedClass"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedClass", '"tests/cases/fourslash/foo".DefaultExportedClass'); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport05.ts b/tests/cases/fourslash/renameForDefaultExport05.ts index f6c87d936da..099f878bda1 100644 --- a/tests/cases/fourslash/renameForDefaultExport05.ts +++ b/tests/cases/fourslash/renameForDefaultExport05.ts @@ -1,5 +1,6 @@ /// +// @Filename: foo.ts ////export default class DefaultExportedClass { ////} /////* @@ -11,4 +12,4 @@ ////var y = new DefaultExportedClass; goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedClass"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedClass", '"tests/cases/fourslash/foo".DefaultExportedClass'); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport06.ts b/tests/cases/fourslash/renameForDefaultExport06.ts index 083fd29054a..3ec067b7029 100644 --- a/tests/cases/fourslash/renameForDefaultExport06.ts +++ b/tests/cases/fourslash/renameForDefaultExport06.ts @@ -1,5 +1,6 @@ /// +// @Filename: foo.ts ////export default class DefaultExportedClass { ////} /////* @@ -11,4 +12,4 @@ ////var y = new /**/[|DefaultExportedClass|]; goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedClass"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedClass", '"tests/cases/fourslash/foo".DefaultExportedClass'); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport07.ts b/tests/cases/fourslash/renameForDefaultExport07.ts index 2c718a1202b..b65f348f2a0 100644 --- a/tests/cases/fourslash/renameForDefaultExport07.ts +++ b/tests/cases/fourslash/renameForDefaultExport07.ts @@ -1,5 +1,6 @@ /// +// @Filename: foo.ts ////export default function /**/[|DefaultExportedFunction|]() { //// return DefaultExportedFunction ////} @@ -12,4 +13,4 @@ ////var y = DefaultExportedFunction(); goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedFunction"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedFunction", '"tests/cases/fourslash/foo".DefaultExportedFunction'); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport08.ts b/tests/cases/fourslash/renameForDefaultExport08.ts index 29064180d58..9b3f23db2c1 100644 --- a/tests/cases/fourslash/renameForDefaultExport08.ts +++ b/tests/cases/fourslash/renameForDefaultExport08.ts @@ -1,5 +1,6 @@ /// +// @Filename: foo.ts ////export default function DefaultExportedFunction() { //// return /**/[|DefaultExportedFunction|] ////} @@ -12,4 +13,4 @@ ////var y = DefaultExportedFunction(); goTo.marker(); -verify.renameInfoSucceeded("DefaultExportedFunction"); \ No newline at end of file +verify.renameInfoSucceeded("DefaultExportedFunction", '"tests/cases/fourslash/foo".DefaultExportedFunction'); \ No newline at end of file diff --git a/tests/cases/fourslash/renameForDefaultExport09.ts b/tests/cases/fourslash/renameForDefaultExport09.ts index 568eb18a84e..bba2e57f49e 100644 --- a/tests/cases/fourslash/renameForDefaultExport09.ts +++ b/tests/cases/fourslash/renameForDefaultExport09.ts @@ -1,5 +1,6 @@ /// +// @Filename: foo.ts ////function /**/[|f|]() { //// return 100; ////} From 042f1fc4a8ca9fa51c52480bb8f97025f689b913 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 29 Jun 2015 09:07:12 -0700 Subject: [PATCH 259/309] Update for style :tophat: --- src/compiler/checker.ts | 8 +++--- src/compiler/emitter.ts | 60 ++++++++++++++++++++--------------------- 2 files changed, 34 insertions(+), 34 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index f3f87f05c0e..019fd8faf36 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6764,7 +6764,7 @@ namespace ts { */ function isUnhyphenatedJsxName(name: string) { // - is the only character supported in JSX attribute names that isn't valid in JavaScript identifiers - return name.indexOf('-') < 0; + return name.indexOf("-") < 0; } /** @@ -6961,7 +6961,7 @@ namespace ts { /// e.g. "props" for React.d.ts, /// or 'undefined' if ElementAttributesPropery doesn't exist (which means all /// non-intrinsic elements' attributes type is 'any'), - /// or '' if it has 0 properties (which means all + /// or '' if it has 0 properties (which means every /// non-instrinsic elements' attributes type is the element instance type) function getJsxElementPropertiesName() { // JSX @@ -6976,7 +6976,7 @@ namespace ts { if (attribProperties) { // Element Attributes has zero properties, so the element attributes type will be the class instance type if (attribProperties.length === 0) { - return ''; + return ""; } // Element Attributes has one property, so the element attributes type will be the type of the corresponding // property of the class instance type @@ -7016,7 +7016,7 @@ namespace ts { // There is no type ElementAttributesProperty, return 'any' return links.resolvedJsxType = anyType; } - else if (propsName === '') { + else if (propsName === "") { // If there is no e.g. 'props' member in ElementAttributesProperty, use the element class type instead return links.resolvedJsxType = elemInstanceType; } diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 3b1a1609c39..4e6bc5f687d 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1140,80 +1140,80 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { /// Emit an name/value pair for an attribute (e.g. "x: 3") function emitJsxAttribute(node: JsxAttribute) { emitAttributeName(node.name); - write(': '); + write(": "); if (node.initializer) { emit(node.initializer); } else { - write('true'); + write("true"); } } function emitJsxElement(openingNode: JsxOpeningLikeElement, children?: JsxChild[]) { // Call React.createElement(tag, ... emitLeadingComments(openingNode); - write('React.createElement('); + write("React.createElement("); emitTagName(openingNode.tagName); - write(', '); + write(", "); // Attribute list if (openingNode.attributes.length === 0) { - // When there are no attributes, React wants 'null' - write('null'); + // When there are no attributes, React wants "null" + write("null"); } else { // Either emit one big object literal (no spread attribs), or // a call to React.__spread let attrs = openingNode.attributes; if (attrs.some(attr => attr.kind === SyntaxKind.JsxSpreadAttribute)) { - write('React.__spread('); + write("React.__spread("); let haveOpenedObjectLiteral = false; for (let i = 0; i < attrs.length; i++) { if (attrs[i].kind === SyntaxKind.JsxSpreadAttribute) { // If this is the first argument, we need to emit a {} as the first argument if (i === 0) { - write('{}, '); + write("{}, "); } if (haveOpenedObjectLiteral) { - write('}'); + write("}"); haveOpenedObjectLiteral = false; } if (i > 0) { - write(', '); + write(", "); } emit((attrs[i]).expression); } else { Debug.assert(attrs[i].kind === SyntaxKind.JsxAttribute); if (haveOpenedObjectLiteral) { - write(', '); + write(", "); } else { haveOpenedObjectLiteral = true; if (i > 0) { - write(', '); + write(", "); } - write('{'); + write("{"); } emitJsxAttribute(attrs[i]); } } - if (haveOpenedObjectLiteral) write('}'); + if (haveOpenedObjectLiteral) write("}"); - write(')'); // closing paren to React.__spread( + write(")"); // closing paren to React.__spread( } else { // One object literal with all the attributes in them - write('{'); + write("{"); for (var i = 0; i < attrs.length; i++) { if (i > 0) { - write(', '); + write(", "); } emitJsxAttribute(attrs[i]); } - write('}'); + write("}"); } } @@ -1235,7 +1235,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } } else { - write(', '); + write(", "); emit(children[i]); } @@ -1243,7 +1243,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } // Closing paren - write(')'); // closes 'React.createElement(' + write(")"); // closes "React.createElement(" emitTrailingComments(openingNode); } @@ -1259,20 +1259,20 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { function jsxEmitPreserve(node: JsxElement|JsxSelfClosingElement) { function emitJsxAttribute(node: JsxAttribute) { emit(node.name); - write('='); + write("="); emit(node.initializer); } function emitJsxSpreadAttribute(node: JsxSpreadAttribute) { - write('{...'); + write("{..."); emit(node.expression); - write('}'); + write("}"); } function emitAttributes(attribs: NodeArray) { for (let i = 0, n = attribs.length; i < n; i++) { if (i > 0) { - write(' '); + write(" "); } if (attribs[i].kind === SyntaxKind.JsxSpreadAttribute) { @@ -1286,26 +1286,26 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { } function emitJsxOpeningOrSelfClosingElement(node: JsxOpeningElement|JsxSelfClosingElement) { - write('<'); + write("<"); emit(node.tagName); if (node.attributes.length > 0 || (node.kind === SyntaxKind.JsxSelfClosingElement)) { - write(' '); + write(" "); } emitAttributes(node.attributes); if (node.kind === SyntaxKind.JsxSelfClosingElement) { - write('/>'); + write("/>"); } else { - write('>'); + write(">"); } } function emitJsxClosingElement(node: JsxClosingElement) { - write(''); + write(">"); } function emitJsxElement(node: JsxElement) { From 1d09c6e9c1416fbcd01905bc5f8ed5f8fe26677f Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 29 Jun 2015 09:37:40 -0700 Subject: [PATCH 260/309] Don't use ES5 array APIs --- src/compiler/emitter.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 451f32cc36b..32123c0a21f 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -71,7 +71,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { else { // targetSourceFile is specified (e.g calling emitter from language service or calling getSemanticDiagnostic from language service) if (shouldEmitToOwnFile(targetSourceFile, compilerOptions)) { - let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, host.getSourceFiles().some(shouldEmitJsx) ? ".jsx" : ".js"); + let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, forEach(host.getSourceFiles(), shouldEmitJsx) ? ".jsx" : ".js"); emitFile(jsFilePath, targetSourceFile); } else if (!isDeclarationFile(targetSourceFile) && compilerOptions.out) { @@ -1170,7 +1170,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) { // Either emit one big object literal (no spread attribs), or // a call to React.__spread let attrs = openingNode.attributes; - if (attrs.some(attr => attr.kind === SyntaxKind.JsxSpreadAttribute)) { + if (forEach(attrs, attr => attr.kind === SyntaxKind.JsxSpreadAttribute)) { write("React.__spread("); let haveOpenedObjectLiteral = false; From 3402f3556c3ceb12be8506116e15d65e5a761928 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 29 Jun 2015 10:39:52 -0700 Subject: [PATCH 261/309] Missed a file in merge; use Tristate.True in arrow fn check --- scripts/errorCheck.ts | 87 ++++++++++++++++++++++++++++++++++++++++++ src/compiler/parser.ts | 2 +- 2 files changed, 88 insertions(+), 1 deletion(-) create mode 100644 scripts/errorCheck.ts diff --git a/scripts/errorCheck.ts b/scripts/errorCheck.ts new file mode 100644 index 00000000000..77892cb8f0c --- /dev/null +++ b/scripts/errorCheck.ts @@ -0,0 +1,87 @@ +declare var require: any; +let fs = require('fs'); +let async = require('async'); +let glob = require('glob'); + +fs.readFile('src/compiler/diagnosticMessages.json', 'utf-8', (err, data) => { + if (err) { + throw err; + } + + let messages = JSON.parse(data); + let keys = Object.keys(messages); + console.log('Loaded ' + keys.length + ' errors'); + + for (let k of keys) { + messages[k]['seen'] = false; + } + + let errRegex = /\(\d+,\d+\): error TS([^:]+):/g; + + let baseDir = 'tests/baselines/reference/'; + fs.readdir(baseDir, (err, files) => { + files = files.filter(f => f.indexOf('.errors.txt') > 0); + let tasks: Array<(callback: () => void) => void> = []; + files.forEach(f => tasks.push(done => { + fs.readFile(baseDir + f, 'utf-8', (err, baseline) => { + if (err) throw err; + + let g: string[]; + while (g = errRegex.exec(baseline)) { + var errCode = +g[1]; + let msg = keys.filter(k => messages[k].code === errCode)[0]; + messages[msg]['seen'] = true; + } + + done(); + }); + })); + + async.parallelLimit(tasks, 25, done => { + console.log('== List of errors not present in baselines =='); + let count = 0; + for (let k of keys) { + if (messages[k]['seen'] !== true) { + console.log(k); + count++; + } + } + console.log(count + ' of ' + keys.length + ' errors are not in baselines'); + }); + }); +}); + +fs.readFile('src/compiler/diagnosticInformationMap.generated.ts', 'utf-8', (err, data) => { + let errorRegexp = /\s(\w+): \{ code/g; + let errorNames: string[] = []; + let errMatch: string[]; + while (errMatch = errorRegexp.exec(data)) { + errorNames.push(errMatch[1]); + } + + let allSrc: string = ''; + glob('./src/**/*.ts', {}, (err, files) => { + console.log('Reading ' + files.length + ' source files'); + for(let file of files) { + if (file.indexOf('diagnosticInformationMap.generated.ts') > 0) { + continue; + } + + let src = fs.readFileSync(file, 'utf-8'); + allSrc = allSrc + src; + } + + console.log('Consumed ' + allSrc.length + ' characters of source'); + + let count = 0; + console.log('== List of errors not used in source ==') + for(let errName of errorNames) { + if (allSrc.indexOf(errName) < 0) { + console.log(errName); + count++; + } + } + console.log(count + ' of ' + errorNames.length + ' errors are not used in source'); + }); +}); + diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 866d7d9b261..b43345bcbf5 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2867,7 +2867,7 @@ namespace ts { }); if (isArrowFunctionInJsx) { - return Tristate.Unknown; + return Tristate.True; } return Tristate.False; From 430c2c8721113989ea7efa9bbe71ed96db6c0639 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 29 Jun 2015 11:25:49 -0700 Subject: [PATCH 262/309] Correct flag JSX elements as being used for the purposes of module imports --- src/compiler/checker.ts | 9 +++ .../tsxExternalModuleEmit1.errors.txt | 35 +++++++++ .../reference/tsxExternalModuleEmit1.js | 71 +++++++++++++++++++ 3 files changed, 115 insertions(+) create mode 100644 tests/baselines/reference/tsxExternalModuleEmit1.errors.txt create mode 100644 tests/baselines/reference/tsxExternalModuleEmit1.js diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 7f65ed7d506..3e6ab5df572 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7117,6 +7117,15 @@ namespace ts { let targetAttributesType = getJsxElementAttributesType(node); + if(getNodeLinks(node).jsxFlags & JsxFlags.ClassElement) { + if(node.tagName.kind === SyntaxKind.Identifier) { + checkIdentifier(node.tagName); + } + else { + checkQualifiedName(node.tagName); + } + } + let nameTable: Map = {}; // Process this array in right-to-left order so we know which // attributes (mostly from spreads) are being overwritten and diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.errors.txt b/tests/baselines/reference/tsxExternalModuleEmit1.errors.txt new file mode 100644 index 00000000000..7342aaa0f6f --- /dev/null +++ b/tests/baselines/reference/tsxExternalModuleEmit1.errors.txt @@ -0,0 +1,35 @@ +tests/cases/conformance/jsx/button.tsx(1,1): error TS1148: Cannot compile modules unless the '--module' flag is provided. + + +==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== + + declare module 'react' { + class Component { } + } + +==== tests/cases/conformance/jsx/app.tsx (0 errors) ==== + import * as React from 'react'; + + // Should see var button_1 = require('./button') here + import { Button } from './button'; + + export class App extends React.Component { + + render() { + return ; + } + + } \ No newline at end of file diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.js b/tests/baselines/reference/tsxExternalModuleEmit1.js new file mode 100644 index 00000000000..3e486eacef8 --- /dev/null +++ b/tests/baselines/reference/tsxExternalModuleEmit1.js @@ -0,0 +1,71 @@ +//// [tests/cases/conformance/jsx/tsxExternalModuleEmit1.tsx] //// + +//// [react.d.ts] + +declare module 'react' { + class Component { } +} + +//// [app.tsx] +import * as React from 'react'; + +// Should see var button_1 = require('./button') here +import { Button } from './button'; + +export class App extends React.Component { + + render() { + return ; + } + +} + +//// [button.jsx] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var React = require('react'); +var Button = (function (_super) { + __extends(Button, _super); + function Button() { + _super.apply(this, arguments); + } + Button.prototype.render = function () { + return ; + }; + return Button; +})(React.Component); +exports.Button = Button; +//// [app.jsx] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var React = require('react'); +// Should see var button_1 = require('./button') here +var button_1 = require('./button'); +var App = (function (_super) { + __extends(App, _super); + function App() { + _super.apply(this, arguments); + } + App.prototype.render = function () { + return ; + }; + return App; +})(React.Component); +exports.App = App; From 8da353e169de5a9658049d4af9dce1570b7b4a21 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 29 Jun 2015 11:39:10 -0700 Subject: [PATCH 263/309] Add spaces between if and ( --- src/compiler/checker.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3e6ab5df572..dbc49a9fd3f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7086,7 +7086,7 @@ namespace ts { let jsxElementClassType: Type = undefined; function getJsxGlobalElementClassType(): Type { - if(!jsxElementClassType) { + if (!jsxElementClassType) { jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass); } return jsxElementClassType; @@ -7105,7 +7105,7 @@ namespace ts { } if (jsxElementType === undefined) { - if(compilerOptions.noImplicitAny) { + if (compilerOptions.noImplicitAny) { error(errorNode, Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist); } } @@ -7117,8 +7117,8 @@ namespace ts { let targetAttributesType = getJsxElementAttributesType(node); - if(getNodeLinks(node).jsxFlags & JsxFlags.ClassElement) { - if(node.tagName.kind === SyntaxKind.Identifier) { + if (getNodeLinks(node).jsxFlags & JsxFlags.ClassElement) { + if (node.tagName.kind === SyntaxKind.Identifier) { checkIdentifier(node.tagName); } else { @@ -7138,7 +7138,7 @@ namespace ts { else { Debug.assert(node.attributes[i].kind === SyntaxKind.JsxSpreadAttribute); let spreadType = checkJsxSpreadAttribute((node.attributes[i]), targetAttributesType, nameTable); - if(isTypeAny(spreadType)) { + if (isTypeAny(spreadType)) { sawSpreadedAny = true; } } @@ -12343,7 +12343,7 @@ namespace ts { } function checkTypePredicate(node: TypePredicateNode) { - if(!isInLegalTypePredicatePosition(node)) { + if (!isInLegalTypePredicatePosition(node)) { error(node, Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); } } From 40d1719eb7527288799eea6c8424e66dcfa6b752 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 29 Jun 2015 11:41:40 -0700 Subject: [PATCH 264/309] Add module setting + test files --- .../reference/tsxExternalModuleEmit1.symbols | 49 +++++++++++++++++ .../reference/tsxExternalModuleEmit1.types | 53 +++++++++++++++++++ .../jsx/tsxExternalModuleEmit1.tsx | 32 +++++++++++ 3 files changed, 134 insertions(+) create mode 100644 tests/baselines/reference/tsxExternalModuleEmit1.symbols create mode 100644 tests/baselines/reference/tsxExternalModuleEmit1.types create mode 100644 tests/cases/conformance/jsx/tsxExternalModuleEmit1.tsx diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.symbols b/tests/baselines/reference/tsxExternalModuleEmit1.symbols new file mode 100644 index 00000000000..5e8eb2fed4e --- /dev/null +++ b/tests/baselines/reference/tsxExternalModuleEmit1.symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/jsx/react.d.ts === + +declare module 'react' { + class Component { } +>Component : Symbol(Component, Decl(react.d.ts, 1, 24)) +>T : Symbol(T, Decl(react.d.ts, 2, 17)) +>U : Symbol(U, Decl(react.d.ts, 2, 19)) +} + +=== tests/cases/conformance/jsx/app.tsx === +import * as React from 'react'; +>React : Symbol(React, Decl(app.tsx, 0, 6)) + +// Should see var button_1 = require('./button') here +import { Button } from './button'; +>Button : Symbol(Button, Decl(app.tsx, 3, 8)) + +export class App extends React.Component { +>App : Symbol(App, Decl(app.tsx, 3, 34)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) +>React : Symbol(React, Decl(app.tsx, 0, 6)) +>Component : Symbol(React.Component, Decl(react.d.ts, 1, 24)) + + render() { +>render : Symbol(render, Decl(app.tsx, 5, 52)) + + return ; + } + +} diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.types b/tests/baselines/reference/tsxExternalModuleEmit1.types new file mode 100644 index 00000000000..7e28c35dd13 --- /dev/null +++ b/tests/baselines/reference/tsxExternalModuleEmit1.types @@ -0,0 +1,53 @@ +=== tests/cases/conformance/jsx/react.d.ts === + +declare module 'react' { + class Component { } +>Component : Component +>T : T +>U : U +} + +=== tests/cases/conformance/jsx/app.tsx === +import * as React from 'react'; +>React : typeof React + +// Should see var button_1 = require('./button') here +import { Button } from './button'; +>Button : typeof Button + +export class App extends React.Component { +>App : App +>React.Component : React.Component +>React : typeof React +>Component : typeof React.Component + + render() { +>render : () => any + + return ; +> : any +>button : any +>button : any + } + +} diff --git a/tests/cases/conformance/jsx/tsxExternalModuleEmit1.tsx b/tests/cases/conformance/jsx/tsxExternalModuleEmit1.tsx new file mode 100644 index 00000000000..bb7f5c3f361 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxExternalModuleEmit1.tsx @@ -0,0 +1,32 @@ +//@jsx: preserve +//@module: commonjs + +//@filename: react.d.ts +declare module 'react' { + class Component { } +} + +//@filename: app.tsx +import * as React from 'react'; + +// Should see var button_1 = require('./button') here +import { Button } from './button'; + +export class App extends React.Component { + + render() { + return ; + } + +} \ No newline at end of file From 7b80001968fdcaf87fea0b50f17c1f8251b9f3db Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 29 Jun 2015 12:03:13 -0700 Subject: [PATCH 265/309] Delete some files --- .../reference/jsxEsprimaFbTestSuite.symbols | 92 ---------- .../reference/jsxEsprimaFbTestSuite.types | 160 ------------------ .../reference/tsxElementResolution16.symbols | 18 -- .../reference/tsxElementResolution16.types | 20 --- .../tsxExternalModuleEmit1.errors.txt | 35 ---- 5 files changed, 325 deletions(-) delete mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.symbols delete mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.types delete mode 100644 tests/baselines/reference/tsxElementResolution16.symbols delete mode 100644 tests/baselines/reference/tsxElementResolution16.types delete mode 100644 tests/baselines/reference/tsxExternalModuleEmit1.errors.txt diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols b/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols deleted file mode 100644 index 570bf89f0a4..00000000000 --- a/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols +++ /dev/null @@ -1,92 +0,0 @@ -=== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx === -declare var React: any; ->React : Symbol(React, Decl(jsxEsprimaFbTestSuite.tsx, 0, 11)) - -declare var 日本語; ->日本語 : Symbol(日本語, Decl(jsxEsprimaFbTestSuite.tsx, 1, 11)) - -declare var AbC_def; ->AbC_def : Symbol(AbC_def, Decl(jsxEsprimaFbTestSuite.tsx, 2, 11)) - -declare var LeftRight; ->LeftRight : Symbol(LeftRight, Decl(jsxEsprimaFbTestSuite.tsx, 3, 11)) - -declare var x; ->x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) - -declare var a; ->a : Symbol(a, Decl(jsxEsprimaFbTestSuite.tsx, 5, 11)) - -declare var props; ->props : Symbol(props, Decl(jsxEsprimaFbTestSuite.tsx, 6, 11)) - -; - -//; Namespace unsuported - -// {value} ; Namespace unsuported - -; ->b : Symbol(unknown) ->c : Symbol(unknown) ->d : Symbol(unknown) ->e : Symbol(unknown) ->f : Symbol(unknown) ->g : Symbol(unknown) ->h : Symbol(unknown) - -; ->b : Symbol(unknown) - -; - -<日本語>; - -AbC_def : Symbol(AbC_def, Decl(jsxEsprimaFbTestSuite.tsx, 2, 11)) - - test="&&"> ->test : Symbol(unknown) - -bar -baz -; - - : } />; ->b : Symbol(unknown) ->x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) - -{}; - -{/* this is a comment */}; - -
@test content
; - -

7x invalid-js-identifier
; - - right=monkeys /> gorillas />; ->LeftRight : Symbol(LeftRight, Decl(jsxEsprimaFbTestSuite.tsx, 3, 11)) ->left : Symbol(unknown) ->right : Symbol(unknown) - -; ->b : Symbol(unknown) - -; ->c : Symbol(unknown) - -(
) < x; ->x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) - -
; - -
; ->post : Symbol(unknown) - -
; ->pre : Symbol(unknown) ->pre2 : Symbol(unknown) - - ; - diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.types b/tests/baselines/reference/jsxEsprimaFbTestSuite.types deleted file mode 100644 index f32d62fd03f..00000000000 --- a/tests/baselines/reference/jsxEsprimaFbTestSuite.types +++ /dev/null @@ -1,160 +0,0 @@ -=== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx === -declare var React: any; ->React : any - -declare var 日本語; ->日本語 : any - -declare var AbC_def; ->AbC_def : any - -declare var LeftRight; ->LeftRight : any - -declare var x; ->x : any - -declare var a; ->a : any - -declare var props; ->props : any - -; -> : any ->a : any - -//; Namespace unsuported - -// {value} ; Namespace unsuported - -; -> : any ->a : any ->b : any ->c : any ->d : any ->e : any ->f : any ->g : any ->h : any - -; -> : any ->a : any ->b : any - - : any ->a : any - -/>; - -<日本語>; -><日本語> : any ->日本語 : any ->日本語 : any - -barbaz : any ->AbC_def : any - - test="&&"> ->test : any - -bar -baz -; ->AbC_def : any - - : } />; -> : } /> : any ->a : any ->b : any ->x ? : : any ->x : any -> : any ->c : any -> : any ->d : any - -{}; ->{} : any ->a : any ->a : any - -{/* this is a comment */}; ->{/* this is a comment */} : any ->a : any ->a : any - -
@test content
; ->
@test content
: any ->div : any ->div : any - -

7x invalid-js-identifier
; ->

7x invalid-js-identifier
: any ->div : any ->
: any ->br : any ->div : any - - right=monkeys /> gorillas />; -> right=monkeys /> gorillas /> : any ->LeftRight : any ->left : any -> : any ->a : any ->right : any ->monkeys /> gorillas : any ->b : any ->b : any - -; -> : any ->a : any ->b : any ->a : any ->b : any - -; -> : any ->a : any ->b : any ->c : any ->a : any ->b : any ->c : any - -(
) < x; ->(
) < x : boolean ->(
) : any ->
: any ->div : any ->x : any - -
; ->
: any ->div : any ->props : any - -
; ->
: any ->div : any ->props : any ->post : any - -
; ->
: any ->div : any ->pre : any ->pre2 : any ->props : any ->div : any - - ; -> : any ->a : any ->a : any - diff --git a/tests/baselines/reference/tsxElementResolution16.symbols b/tests/baselines/reference/tsxElementResolution16.symbols deleted file mode 100644 index e01f19b991f..00000000000 --- a/tests/baselines/reference/tsxElementResolution16.symbols +++ /dev/null @@ -1,18 +0,0 @@ -=== tests/cases/conformance/jsx/tsxElementResolution16.tsx === -declare module JSX { ->JSX : Symbol(JSX, Decl(tsxElementResolution16.tsx, 0, 0)) -} - -interface Obj1 { ->Obj1 : Symbol(Obj1, Decl(tsxElementResolution16.tsx, 1, 1)) - - new(n: string): {}; ->n : Symbol(n, Decl(tsxElementResolution16.tsx, 4, 5)) -} -var obj1: Obj1; ->obj1 : Symbol(obj1, Decl(tsxElementResolution16.tsx, 6, 3)) ->Obj1 : Symbol(Obj1, Decl(tsxElementResolution16.tsx, 1, 1)) - -; // Error (JSX.Element is missing) ->x : Symbol(unknown) - diff --git a/tests/baselines/reference/tsxElementResolution16.types b/tests/baselines/reference/tsxElementResolution16.types deleted file mode 100644 index 3b8604e737d..00000000000 --- a/tests/baselines/reference/tsxElementResolution16.types +++ /dev/null @@ -1,20 +0,0 @@ -=== tests/cases/conformance/jsx/tsxElementResolution16.tsx === -declare module JSX { ->JSX : any -} - -interface Obj1 { ->Obj1 : Obj1 - - new(n: string): {}; ->n : string -} -var obj1: Obj1; ->obj1 : Obj1 ->Obj1 : Obj1 - -; // Error (JSX.Element is missing) -> : any ->obj1 : Obj1 ->x : any - diff --git a/tests/baselines/reference/tsxExternalModuleEmit1.errors.txt b/tests/baselines/reference/tsxExternalModuleEmit1.errors.txt deleted file mode 100644 index 7342aaa0f6f..00000000000 --- a/tests/baselines/reference/tsxExternalModuleEmit1.errors.txt +++ /dev/null @@ -1,35 +0,0 @@ -tests/cases/conformance/jsx/button.tsx(1,1): error TS1148: Cannot compile modules unless the '--module' flag is provided. - - -==== tests/cases/conformance/jsx/react.d.ts (0 errors) ==== - - declare module 'react' { - class Component { } - } - -==== tests/cases/conformance/jsx/app.tsx (0 errors) ==== - import * as React from 'react'; - - // Should see var button_1 = require('./button') here - import { Button } from './button'; - - export class App extends React.Component { - - render() { - return ; - } - - } \ No newline at end of file From a183ba902016ad19929546593ffc85676e05ab90 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 29 Jun 2015 14:02:01 -0700 Subject: [PATCH 266/309] added flag as argument to checkTypeRelatedTo --- src/compiler/checker.ts | 81 +++++++++++++++++++++++++---------------- src/compiler/types.ts | 6 +++ 2 files changed, 56 insertions(+), 31 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index efee668a24b..d9accf474dc 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4263,11 +4263,11 @@ namespace ts { // TYPE CHECKING function isTypeIdenticalTo(source: Type, target: Type): boolean { - return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined); + return checkTypeRelatedTo(source, target, identityRelation, RelationComparisonFlags.None, /*errorNode*/ undefined); } function compareTypes(source: Type, target: Type): Ternary { - return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined) ? Ternary.True : Ternary.False; + return checkTypeRelatedTo(source, target, identityRelation, RelationComparisonFlags.None, /*errorNode*/ undefined) ? Ternary.True : Ternary.False; } function isTypeSubtypeOf(source: Type, target: Type): boolean { @@ -4275,15 +4275,15 @@ namespace ts { } function isTypeAssignableTo(source: Type, target: Type): boolean { - return checkTypeAssignableTo(source, target, /*errorNode*/ undefined); + return checkTypeAssignableTo(source, target, RelationComparisonFlags.None, /*errorNode*/ undefined); } function checkTypeSubtypeOf(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { - return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); + return checkTypeRelatedTo(source, target, subtypeRelation, RelationComparisonFlags.None, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { - return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); + function checkTypeAssignableTo(source: Type, target: Type, relationFlags: RelationComparisonFlags, errorNode?: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { + return checkTypeRelatedTo(source, target, assignableRelation, relationFlags, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source: Signature, target: Signature): boolean { @@ -4292,13 +4292,30 @@ namespace ts { return checkTypeRelatedTo(sourceType, targetType, assignableRelation, /*errorNode*/ undefined); } + /** + * Checks if 'source' is related to 'target' (e.g.: is a assignable to). + * @param source The left-hand-side of the relation. + * @param target The right-hand-side of the relation. + * @param relation The relation considered. One of 'identityRelation', 'assignableRelation', or 'subTypeRelation'. + * Used as both to determine which checks are performed and as a cache of previously computed results. + * @param relationFlags Additional information affecting whether the relation holds. Currently used only for distinguishing + * between a type comparison when extending classes from other comparisons of the constructor types. + * + * Caution: checks triggered by these flags should NOT affect the result re + * @param errorNode The node upon which all errors will be reported, if defined. + * @param headMessage If the error chain should be prepended by a head message, then headMessage will be used. + * @param containingMessageChain A chain of errors to prepend any new errors found. + + */ function checkTypeRelatedTo( source: Type, target: Type, relation: Map, - errorNode: Node, + relationFlags: RelationComparisonFlags, + errorNode?: Node, headMessage?: DiagnosticMessage, - containingMessageChain?: DiagnosticMessageChain): boolean { + containingMessageChain?: DiagnosticMessageChain + ): boolean { let errorInfo: DiagnosticMessageChain; let sourceStack: ObjectType[]; @@ -7212,6 +7229,7 @@ namespace ts { typeArgumentsAreAssignable = checkTypeAssignableTo( typeArgument, constraint, + RelationComparisonFlags.None, reportErrors ? typeArgNode : undefined, typeArgumentHeadMessage, errorInfo); @@ -7243,7 +7261,7 @@ namespace ts { // Use argument expression as error location when reporting errors let errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; let headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; - if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) { + if (!checkTypeRelatedTo(argType, paramType, relation, RelationComparisonFlags.None, errorNode, headMessage)) { return false; } } @@ -8040,7 +8058,7 @@ namespace ts { if (produceDiagnostics && targetType !== unknownType) { let widenedType = getWidenedType(exprType); if (!(isTypeAssignableTo(targetType, widenedType))) { - checkTypeAssignableTo(exprType, targetType, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other); + checkTypeAssignableTo(exprType, targetType, RelationComparisonFlags.None, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other); } } return targetType; @@ -8274,7 +8292,7 @@ namespace ts { else { let exprType = checkExpression(node.body); if (node.type) { - checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, /*headMessage*/ undefined); + checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), RelationComparisonFlags.None, node.body, /*headMessage*/ undefined); } checkFunctionAndClassExpressionBodies(node.body); } @@ -8582,7 +8600,7 @@ namespace ts { function checkReferenceAssignment(target: Expression, sourceType: Type, contextualMapper?: TypeMapper): Type { let targetType = checkExpression(target, contextualMapper); if (checkReferenceExpression(target, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant)) { - checkTypeAssignableTo(sourceType, targetType, target, /*headMessage*/ undefined); + checkTypeAssignableTo(sourceType, targetType, RelationComparisonFlags.None, target, /*headMessage*/ undefined); } return sourceType; } @@ -8757,7 +8775,7 @@ namespace ts { // Use default messages if (ok) { // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported - checkTypeAssignableTo(valueType, leftType, node.left, /*headMessage*/ undefined); + checkTypeAssignableTo(valueType, leftType, RelationComparisonFlags.None, node.left, /*headMessage*/ undefined); } } } @@ -8808,10 +8826,10 @@ namespace ts { if (func.type) { let signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType; if (nodeIsYieldStar) { - checkTypeAssignableTo(expressionElementType, signatureElementType, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(expressionElementType, signatureElementType, RelationComparisonFlags.None, node.expression, /*headMessage*/ undefined); } else { - checkTypeAssignableTo(expressionType, signatureElementType, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(expressionType, signatureElementType, RelationComparisonFlags.None, node.expression, /*headMessage*/ undefined); } } } @@ -9119,7 +9137,7 @@ namespace ts { else { checkTypeAssignableTo(typePredicate.type, getTypeAtLocation(node.parameters[typePredicate.parameterIndex]), - typePredicateNode.type); + RelationComparisonFlags.None, typePredicateNode.type); } } else if (typePredicateNode.parameterName) { @@ -9197,7 +9215,7 @@ namespace ts { // interface BadGenerator extends Iterable, Iterator { } // function* g(): BadGenerator { } // Iterable and Iterator have different types! // - checkTypeAssignableTo(iterableIteratorInstantiation, returnType, node.type); + checkTypeAssignableTo(iterableIteratorInstantiation, returnType, RelationComparisonFlags.None, node.type); } } } @@ -9399,7 +9417,7 @@ namespace ts { let constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { let typeArgument = typeArguments[i]; - result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, RelationComparisonFlags.None, typeArgument, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); } } return result; @@ -9836,6 +9854,7 @@ namespace ts { checkTypeAssignableTo( returnType, expectedReturnType, + RelationComparisonFlags.None, node, headMessage, errorInfo); @@ -10257,7 +10276,7 @@ namespace ts { // For a binding pattern, validate the initializer and exit if (isBindingPattern(node.name)) { if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), RelationComparisonFlags.None, node, /*headMessage*/ undefined); checkParameterInitializer(node); } return; @@ -10267,7 +10286,7 @@ namespace ts { if (node === symbol.valueDeclaration) { // Node is the primary declaration of the symbol, just validate the initializer if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), type, node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), type, RelationComparisonFlags.None, node, /*headMessage*/ undefined); checkParameterInitializer(node); } } @@ -10279,7 +10298,7 @@ namespace ts { error(node.name, Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, declarationNameToString(node.name), typeToString(type), typeToString(declarationType)); } if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, RelationComparisonFlags.None, node, /*headMessage*/ undefined); } } if (node.kind !== SyntaxKind.PropertyDeclaration && node.kind !== SyntaxKind.PropertySignature) { @@ -10331,7 +10350,7 @@ namespace ts { function checkExpressionStatement(node: ExpressionStatement) { // Grammar checking - checkGrammarStatementInAmbientContext(node) + checkGrammarStatementInAmbientContext(node); checkExpression(node.expression); } @@ -10415,7 +10434,7 @@ namespace ts { // because we accessed properties from anyType, or it may have led to an error inside // getElementTypeOfIterable. if (iteratedType) { - checkTypeAssignableTo(iteratedType, leftType, varExpr, /*headMessage*/ undefined); + checkTypeAssignableTo(iteratedType, leftType, RelationComparisonFlags.None, varExpr, /*headMessage*/ undefined); } } } @@ -10515,7 +10534,7 @@ namespace ts { // Now even though we have extracted the iteratedType, we will have to validate that the type // passed in is actually an Iterable. if (errorNode && elementType) { - checkTypeAssignableTo(iterable, createIterableType(elementType), errorNode); + checkTypeAssignableTo(iterable, createIterableType(elementType), RelationComparisonFlags.None, errorNode); } return elementType || anyType; @@ -10759,7 +10778,7 @@ namespace ts { } } else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) { - checkTypeAssignableTo(exprType, returnType, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(exprType, returnType, RelationComparisonFlags.None, node.expression, /*headMessage*/ undefined); } } } @@ -10802,7 +10821,7 @@ namespace ts { let caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { // check 'expressionType isAssignableTo caseType' failed, try the reversed check and report errors if it fails - checkTypeAssignableTo(caseType, expressionType, caseClause.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(caseType, expressionType, RelationComparisonFlags.None, caseClause.expression, /*headMessage*/ undefined); } } forEach(clause.statements, checkSourceElement); @@ -11043,8 +11062,8 @@ namespace ts { } } } - checkTypeAssignableTo(type, baseType, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); - checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, + checkTypeAssignableTo(type, baseType, RelationComparisonFlags.None, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), RelationComparisonFlags.ExtendingClass, node.name || node, Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class)) { // When the static base type is a "class-like" constructor function (but not actually a class), we verify @@ -11072,7 +11091,7 @@ namespace ts { if (t !== unknownType) { let declaredType = (t.flags & TypeFlags.Reference) ? (t).target : t; if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) { - checkTypeAssignableTo(type, t, node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1); + checkTypeAssignableTo(type, t, RelationComparisonFlags.None, node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1); } else { error(typeRefNode, Diagnostics.A_class_may_only_implement_another_class_or_interface); @@ -11255,7 +11274,7 @@ namespace ts { // run subsequent checks only if first set succeeded if (checkInheritedPropertiesAreIdentical(type, node.name)) { forEach(getBaseTypes(type), baseType => { - checkTypeAssignableTo(type, baseType, node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1); + checkTypeAssignableTo(type, baseType, RelationComparisonFlags.None, node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1); }); checkIndexConstraints(type); } @@ -11308,7 +11327,7 @@ namespace ts { // If it is a constant value (not undefined), it is syntactically constrained to be a number. // Also, we do not need to check this for ambients because there is already // a syntax error if it is not a constant. - checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpression(initializer), enumType, RelationComparisonFlags.None, initializer, /*headMessage*/ undefined); } } else if (enumIsConst) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index f3f203d4e86..e588e1b1dea 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -403,6 +403,12 @@ namespace ts { FailedAndReported = 3 } + /* @internal */ + export const enum RelationComparisonFlags { + None = 0, + ExtendingClass = 0x00000001 + } + export interface Node extends TextRange { kind: SyntaxKind; flags: NodeFlags; From 342ae9614e62efa0da77ef194f1539682d7fe7de Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Mon, 29 Jun 2015 14:30:11 -0700 Subject: [PATCH 267/309] Fix tabbing --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index dbc49a9fd3f..34c19c763de 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7119,10 +7119,10 @@ namespace ts { if (getNodeLinks(node).jsxFlags & JsxFlags.ClassElement) { if (node.tagName.kind === SyntaxKind.Identifier) { - checkIdentifier(node.tagName); + checkIdentifier(node.tagName); } else { - checkQualifiedName(node.tagName); + checkQualifiedName(node.tagName); } } From ded24410e6dbd86e9854530c6ea9a0f39a2e7976 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 29 Jun 2015 14:39:09 -0700 Subject: [PATCH 268/309] fixed a conflict --- src/compiler/checker.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3b9da04a427..590eceeb302 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6843,7 +6843,7 @@ namespace ts { } if (correspondingPropType) { - checkTypeAssignableTo(exprType, correspondingPropType, node); + checkTypeAssignableTo(exprType, correspondingPropType, RelationComparisonFlags.None, node); } nameTable[node.name.text] = true; @@ -6860,7 +6860,7 @@ namespace ts { let targetPropSym = getPropertyOfType(elementAttributesType, prop.name); if (targetPropSym) { let msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, prop.name); - checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(targetPropSym), node, undefined, msg); + checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(targetPropSym), RelationComparisonFlags.None, node, undefined, msg); } nameTable[prop.name] = true; @@ -6988,7 +6988,7 @@ namespace ts { // Issue an error if this return type isn't assignable to JSX.ElementClass let elemClassType = getJsxGlobalElementClassType(); if (elemClassType) { - checkTypeRelatedTo(returnType, elemClassType, assignableRelation, node, Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements); + checkTypeRelatedTo(returnType, elemClassType, assignableRelation, RelationComparisonFlags.None, node, Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements); } return returnType; From e47e5bcbcd5e662cb00bff95a4edf62a6c78ac7d Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 29 Jun 2015 15:08:22 -0700 Subject: [PATCH 269/309] fixed a comment --- src/compiler/checker.ts | 3 ++- src/compiler/core.ts | 18 ++++++++++-------- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 590eceeb302..c3edfed4804 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4329,7 +4329,7 @@ namespace ts { * @param relationFlags Additional information affecting whether the relation holds. Currently used only for distinguishing * between a type comparison when extending classes from other comparisons of the constructor types. * - * Caution: checks triggered by these flags should NOT affect the result re + * Caution: checks triggered by these flags should NOT affect the result cached. * @param errorNode The node upon which all errors will be reported, if defined. * @param headMessage If the error chain should be prepended by a head message, then headMessage will be used. * @param containingMessageChain A chain of errors to prepend any new errors found. @@ -4388,6 +4388,7 @@ namespace ts { // Ternary.False if they are not related. function isRelatedTo(source: Type, target: Type, reportErrors?: boolean, headMessage?: DiagnosticMessage): Ternary { let result: Ternary; + let relationFlagCheckResult: Ternary; // both types are the same - covers 'they are the same primitive type or both are Any' or the same type parameter cases if (source === target) return Ternary.True; if (relation !== identityRelation) { diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 7b35c5e0d65..c3d2a00eba5 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -2,17 +2,19 @@ /* @internal */ namespace ts { - // Ternary values are defined such that - // x & y is False if either x or y is False. - // x & y is Maybe if either x or y is Maybe, but neither x or y is False. - // x & y is True if both x and y are True. - // x | y is False if both x and y are False. - // x | y is Maybe if either x or y is Maybe, but neither x or y is True. - // x | y is True if either x or y is True. + /** + * Ternary values are defined such that + * x & y is False if either x or y is False. + * x & y is Maybe if either x or y is Maybe, but neither x or y is False. + * x & y is True if both x and y are True. + * x | y is False if both x and y are False. + * x | y is Maybe if either x or y is Maybe, but neither x or y is True. + * x | y is True if either x or y is True. + */ export const enum Ternary { False = 0, Maybe = 1, - True = -1 + True = -1 } export function createFileMap(getCanonicalFileName: (fileName: string) => string): FileMap { From 12383af2259e96c0f8795d10e4681a34f7363046 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Mon, 29 Jun 2015 17:20:10 -0700 Subject: [PATCH 270/309] Responding to Jason --- src/compiler/checker.ts | 132 ++++++++---------- src/compiler/core.ts | 6 +- .../diagnosticInformationMap.generated.ts | 2 +- src/compiler/diagnosticMessages.json | 2 +- 4 files changed, 66 insertions(+), 76 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b2b44f98887..27e500bc3f8 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4615,9 +4615,6 @@ namespace ts { result &= stringIndexTypesRelatedTo(source, target, reportErrors); if (result) { result &= numberIndexTypesRelatedTo(source, target, reportErrors); - // if(relation == subtypeRelation && result) { - // result &= abstractnessRelatedTo(source, target, reportErrors); - // } } } } @@ -4639,17 +4636,6 @@ namespace ts { return result; } - function abstractnessRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary { - if ( source.symbol && target.symbol && getDeclarationFlagsFromSymbol(source.symbol) & NodeFlags.Abstract && - !(getDeclarationFlagsFromSymbol(target.symbol) & NodeFlags.Abstract)) { - if (reportErrors) { - reportError(Diagnostics.Constructor_objects_of_abstract_type_cannot_be_assigned_to_constructor_objects_of_non_abstract_type); - } - return Ternary.False; - } - return Ternary.True; - } - function propertiesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary { if (relation === identityRelation) { return propertiesIdenticalTo(source, target); @@ -7320,7 +7306,6 @@ namespace ts { return unknownType; } - // TODO: Why is this line here? getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & SymbolFlags.Class) { @@ -11609,16 +11594,18 @@ namespace ts { } checkClassLikeDeclaration(node); - forEach(node.members, node.flags & NodeFlags.Abstract ? - checkSourceElement : - element => { - checkSourceElement(element); + forEach(node.members, checkSourceElement); - // Classes containing abstract methods must be marked abstract - if (element.flags & NodeFlags.Abstract) { - error(node, Diagnostics.Classes_containing_abstract_methods_must_be_marked_abstract); - } - }); + // forEach(node.members, node.flags & NodeFlags.Abstract ? + // checkSourceElement : + // element => { + // checkSourceElement(element); + + // // Classes containing abstract methods must be marked abstract + // if (element.flags & NodeFlags.Abstract) { + // error(node, Diagnostics.Classes_containing_abstract_methods_must_be_marked_abstract); + // } + // }); } function checkClassLikeDeclaration(node: ClassLikeDeclaration) { @@ -11732,57 +11719,59 @@ namespace ts { Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration."); - if (derived === base) { - // derived class inherits base without override/redeclaration + if (derived) { + if (derived === base) { + // derived class inherits base without override/redeclaration - let derivedClassDecl = getDeclarationOfKind(type.symbol, SyntaxKind.ClassDeclaration); - Debug.assert(derivedClassDecl !== undefined); + let derivedClassDecl = getDeclarationOfKind(type.symbol, SyntaxKind.ClassDeclaration); + Debug.assert(derivedClassDecl !== undefined); - // It is an error to inherit an abstract member without implementing it or being declared abstract. - if ((baseDeclarationFlags & NodeFlags.Abstract) && !(derivedClassDecl.flags & NodeFlags.Abstract)) { - error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, - typeToString(type), symbolToString(baseProperty), typeToString(baseType)); - } - } - else { - // derived overrides base. - let derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived); - if ((baseDeclarationFlags & NodeFlags.Private) || (derivedDeclarationFlags & NodeFlags.Private)) { - // either base or derived property is private - not override, skip it - continue; + // It is an error to inherit an abstract member without implementing it or being declared abstract. + if ((baseDeclarationFlags & NodeFlags.Abstract) && !(derivedClassDecl.flags & NodeFlags.Abstract)) { + error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, + typeToString(type), symbolToString(baseProperty), typeToString(baseType)); + } } + else { + // derived overrides base. + let derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived); + if ((baseDeclarationFlags & NodeFlags.Private) || (derivedDeclarationFlags & NodeFlags.Private)) { + // either base or derived property is private - not override, skip it + continue; + } - if ((baseDeclarationFlags & NodeFlags.Static) !== (derivedDeclarationFlags & NodeFlags.Static)) { - // value of 'static' is not the same for properties - not override, skip it - continue; - } + if ((baseDeclarationFlags & NodeFlags.Static) !== (derivedDeclarationFlags & NodeFlags.Static)) { + // value of 'static' is not the same for properties - not override, skip it + continue; + } - if ((base.flags & derived.flags & SymbolFlags.Method) || ((base.flags & SymbolFlags.PropertyOrAccessor) && (derived.flags & SymbolFlags.PropertyOrAccessor))) { - // method is overridden with method or property/accessor is overridden with property/accessor - correct case - continue; - } + if ((base.flags & derived.flags & SymbolFlags.Method) || ((base.flags & SymbolFlags.PropertyOrAccessor) && (derived.flags & SymbolFlags.PropertyOrAccessor))) { + // method is overridden with method or property/accessor is overridden with property/accessor - correct case + continue; + } - let errorMessage: DiagnosticMessage; - if (base.flags & SymbolFlags.Method) { - if (derived.flags & SymbolFlags.Accessor) { - errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; + let errorMessage: DiagnosticMessage; + if (base.flags & SymbolFlags.Method) { + if (derived.flags & SymbolFlags.Accessor) { + errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; + } + else { + Debug.assert((derived.flags & SymbolFlags.Property) !== 0); + errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property; + } + } + else if (base.flags & SymbolFlags.Property) { + Debug.assert((derived.flags & SymbolFlags.Method) !== 0); + errorMessage = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; } else { - Debug.assert((derived.flags & SymbolFlags.Property) !== 0); - errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property; + Debug.assert((base.flags & SymbolFlags.Accessor) !== 0); + Debug.assert((derived.flags & SymbolFlags.Method) !== 0); + errorMessage = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function; } - } - else if (base.flags & SymbolFlags.Property) { - Debug.assert((derived.flags & SymbolFlags.Method) !== 0); - errorMessage = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; - } - else { - Debug.assert((base.flags & SymbolFlags.Accessor) !== 0); - Debug.assert((derived.flags & SymbolFlags.Method) !== 0); - errorMessage = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function; - } - error(derived.valueDeclaration.name, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type)); + error(derived.valueDeclaration.name, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type)); + } } } } @@ -13854,13 +13843,14 @@ namespace ts { if (!(node.parent.kind === SyntaxKind.ClassDeclaration && node.parent.flags & NodeFlags.Abstract)) { return grammarErrorOnNode(modifier, Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class); } + if (flags & NodeFlags.Static) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + } + if (flags & NodeFlags.Private) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract"); + } } - if (flags & NodeFlags.Static) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); - } - if (flags & NodeFlags.Private) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract"); - } + flags |= NodeFlags.Abstract; break; } diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 6ae06ba428f..ec4c777852b 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -62,9 +62,9 @@ namespace ts { export interface StringSet extends Map { } /** - * Iterates through 'array' by index and performs the callback on each element of array - * until the callback returns a truthy value, then returns that value. - * If no such value is found, the callback is applied to each element of array. + * Iterates through 'array' by index and performs the callback on each element of array until the callback + * returns a truthy value, then returns that value. + * If no such value is found, the callback is applied to each element of array and undefined is returned. */ export function forEach(array: T[], callback: (element: T, index: number) => U): U { if (array) { diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index d5109e40d56..b5da91f199d 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -387,7 +387,7 @@ namespace ts { Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." }, Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, - Overload_signatures_must_all_be_abstract_or_not_abstract: { code: 2512, category: DiagnosticCategory.Error, key: "Overload signatures must all be `abstract` or not `abstract." }, + Overload_signatures_must_all_be_abstract_or_not_abstract: { code: 2512, category: DiagnosticCategory.Error, key: "Overload signatures must all be abstract or not abstract." }, Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}' in class '{1}' cannot be accessed via super expression." }, Classes_containing_abstract_methods_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract methods must be marked abstract." }, Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 9bbd298c7cd..82d900056d1 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1535,7 +1535,7 @@ "category": "Error", "code": 2511 }, - "Overload signatures must all be `abstract` or not `abstract.": { + "Overload signatures must all be abstract or not abstract.": { "category": "Error", "code": 2512 }, From c517a6341eebc2cec794e4b4fd46b541c90a73ed Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 30 Jun 2015 12:02:23 -0700 Subject: [PATCH 271/309] Accepting new baselines --- .../reference/jsxEsprimaFbTestSuite.symbols | 92 ---------- .../reference/jsxEsprimaFbTestSuite.types | 160 ------------------ .../reference/tsxElementResolution16.symbols | 18 -- .../reference/tsxElementResolution16.types | 20 --- 4 files changed, 290 deletions(-) delete mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.symbols delete mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.types delete mode 100644 tests/baselines/reference/tsxElementResolution16.symbols delete mode 100644 tests/baselines/reference/tsxElementResolution16.types diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols b/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols deleted file mode 100644 index 570bf89f0a4..00000000000 --- a/tests/baselines/reference/jsxEsprimaFbTestSuite.symbols +++ /dev/null @@ -1,92 +0,0 @@ -=== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx === -declare var React: any; ->React : Symbol(React, Decl(jsxEsprimaFbTestSuite.tsx, 0, 11)) - -declare var 日本語; ->日本語 : Symbol(日本語, Decl(jsxEsprimaFbTestSuite.tsx, 1, 11)) - -declare var AbC_def; ->AbC_def : Symbol(AbC_def, Decl(jsxEsprimaFbTestSuite.tsx, 2, 11)) - -declare var LeftRight; ->LeftRight : Symbol(LeftRight, Decl(jsxEsprimaFbTestSuite.tsx, 3, 11)) - -declare var x; ->x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) - -declare var a; ->a : Symbol(a, Decl(jsxEsprimaFbTestSuite.tsx, 5, 11)) - -declare var props; ->props : Symbol(props, Decl(jsxEsprimaFbTestSuite.tsx, 6, 11)) - -; - -//; Namespace unsuported - -// {value} ; Namespace unsuported - -; ->b : Symbol(unknown) ->c : Symbol(unknown) ->d : Symbol(unknown) ->e : Symbol(unknown) ->f : Symbol(unknown) ->g : Symbol(unknown) ->h : Symbol(unknown) - -; ->b : Symbol(unknown) - -; - -<日本語>; - -AbC_def : Symbol(AbC_def, Decl(jsxEsprimaFbTestSuite.tsx, 2, 11)) - - test="&&"> ->test : Symbol(unknown) - -bar -baz -; - - : } />; ->b : Symbol(unknown) ->x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) - -{}; - -{/* this is a comment */}; - -
@test content
; - -

7x invalid-js-identifier
; - - right=monkeys /> gorillas />; ->LeftRight : Symbol(LeftRight, Decl(jsxEsprimaFbTestSuite.tsx, 3, 11)) ->left : Symbol(unknown) ->right : Symbol(unknown) - -; ->b : Symbol(unknown) - -; ->c : Symbol(unknown) - -(
) < x; ->x : Symbol(x, Decl(jsxEsprimaFbTestSuite.tsx, 4, 11)) - -
; - -
; ->post : Symbol(unknown) - -
; ->pre : Symbol(unknown) ->pre2 : Symbol(unknown) - - ; - diff --git a/tests/baselines/reference/jsxEsprimaFbTestSuite.types b/tests/baselines/reference/jsxEsprimaFbTestSuite.types deleted file mode 100644 index f32d62fd03f..00000000000 --- a/tests/baselines/reference/jsxEsprimaFbTestSuite.types +++ /dev/null @@ -1,160 +0,0 @@ -=== tests/cases/conformance/jsx/jsxEsprimaFbTestSuite.tsx === -declare var React: any; ->React : any - -declare var 日本語; ->日本語 : any - -declare var AbC_def; ->AbC_def : any - -declare var LeftRight; ->LeftRight : any - -declare var x; ->x : any - -declare var a; ->a : any - -declare var props; ->props : any - -; -> : any ->a : any - -//; Namespace unsuported - -// {value} ; Namespace unsuported - -; -> : any ->a : any ->b : any ->c : any ->d : any ->e : any ->f : any ->g : any ->h : any - -; -> : any ->a : any ->b : any - - : any ->a : any - -/>; - -<日本語>; -><日本語> : any ->日本語 : any ->日本語 : any - -barbaz : any ->AbC_def : any - - test="&&"> ->test : any - -bar -baz -; ->AbC_def : any - - : } />; -> : } /> : any ->a : any ->b : any ->x ? : : any ->x : any -> : any ->c : any -> : any ->d : any - -{}; ->{} : any ->a : any ->a : any - -{/* this is a comment */}; ->{/* this is a comment */} : any ->a : any ->a : any - -
@test content
; ->
@test content
: any ->div : any ->div : any - -

7x invalid-js-identifier
; ->

7x invalid-js-identifier
: any ->div : any ->
: any ->br : any ->div : any - - right=monkeys /> gorillas />; -> right=monkeys /> gorillas /> : any ->LeftRight : any ->left : any -> : any ->a : any ->right : any ->monkeys /> gorillas : any ->b : any ->b : any - -; -> : any ->a : any ->b : any ->a : any ->b : any - -; -> : any ->a : any ->b : any ->c : any ->a : any ->b : any ->c : any - -(
) < x; ->(
) < x : boolean ->(
) : any ->
: any ->div : any ->x : any - -
; ->
: any ->div : any ->props : any - -
; ->
: any ->div : any ->props : any ->post : any - -
; ->
: any ->div : any ->pre : any ->pre2 : any ->props : any ->div : any - - ; -> : any ->a : any ->a : any - diff --git a/tests/baselines/reference/tsxElementResolution16.symbols b/tests/baselines/reference/tsxElementResolution16.symbols deleted file mode 100644 index e01f19b991f..00000000000 --- a/tests/baselines/reference/tsxElementResolution16.symbols +++ /dev/null @@ -1,18 +0,0 @@ -=== tests/cases/conformance/jsx/tsxElementResolution16.tsx === -declare module JSX { ->JSX : Symbol(JSX, Decl(tsxElementResolution16.tsx, 0, 0)) -} - -interface Obj1 { ->Obj1 : Symbol(Obj1, Decl(tsxElementResolution16.tsx, 1, 1)) - - new(n: string): {}; ->n : Symbol(n, Decl(tsxElementResolution16.tsx, 4, 5)) -} -var obj1: Obj1; ->obj1 : Symbol(obj1, Decl(tsxElementResolution16.tsx, 6, 3)) ->Obj1 : Symbol(Obj1, Decl(tsxElementResolution16.tsx, 1, 1)) - -; // Error (JSX.Element is missing) ->x : Symbol(unknown) - diff --git a/tests/baselines/reference/tsxElementResolution16.types b/tests/baselines/reference/tsxElementResolution16.types deleted file mode 100644 index 3b8604e737d..00000000000 --- a/tests/baselines/reference/tsxElementResolution16.types +++ /dev/null @@ -1,20 +0,0 @@ -=== tests/cases/conformance/jsx/tsxElementResolution16.tsx === -declare module JSX { ->JSX : any -} - -interface Obj1 { ->Obj1 : Obj1 - - new(n: string): {}; ->n : string -} -var obj1: Obj1; ->obj1 : Obj1 ->Obj1 : Obj1 - -; // Error (JSX.Element is missing) -> : any ->obj1 : Obj1 ->x : any - From 6ae775b4ff43b075e158014aaf54dc0fdf7414fe Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 30 Jun 2015 12:23:21 -0700 Subject: [PATCH 272/309] Support intersection types as target in type inference --- src/compiler/checker.ts | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d90275a4eb1..10f7b530330 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5408,11 +5408,11 @@ namespace ts { inferFromTypes(sourceTypes[i], targetTypes[i]); } } - else if (target.flags & TypeFlags.Union) { - let targetTypes = (target).types; + else if (target.flags & TypeFlags.UnionOrIntersection) { + let targetTypes = (target).types; let typeParameterCount = 0; let typeParameter: TypeParameter; - // First infer to each type in union that isn't a type parameter + // First infer to each type in union or intersection that isn't a type parameter for (let t of targetTypes) { if (t.flags & TypeFlags.TypeParameter && contains(context.typeParameters, t)) { typeParameter = t; @@ -5422,8 +5422,9 @@ namespace ts { inferFromTypes(source, t); } } - // If union contains a single naked type parameter, make a secondary inference to that type parameter - if (typeParameterCount === 1) { + // Next, if target is a union type containing a single naked type parameter, make a + // secondary inference to that type parameter + if (target.flags & TypeFlags.Union && typeParameterCount === 1) { inferiority++; inferFromTypes(source, typeParameter); inferiority--; From fb1bf420b4ca1847330a0af894406c769322bf31 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 30 Jun 2015 12:41:03 -0700 Subject: [PATCH 273/309] Adding test for inference with intersection type as target --- .../intersectionTypeInference.errors.txt | 20 +++++++++++++++--- .../reference/intersectionTypeInference.js | 21 ++++++++++++++++++- .../intersection/intersectionTypeInference.ts | 16 +++++++++++++- 3 files changed, 52 insertions(+), 5 deletions(-) diff --git a/tests/baselines/reference/intersectionTypeInference.errors.txt b/tests/baselines/reference/intersectionTypeInference.errors.txt index 33c24e111dc..af0b1b447bc 100644 --- a/tests/baselines/reference/intersectionTypeInference.errors.txt +++ b/tests/baselines/reference/intersectionTypeInference.errors.txt @@ -1,11 +1,10 @@ -tests/cases/conformance/types/intersection/intersectionTypeInference.ts(6,5): error TS2322: Type 'T' is not assignable to type 'T & U'. +tests/cases/conformance/types/intersection/intersectionTypeInference.ts(5,5): error TS2322: Type 'T' is not assignable to type 'T & U'. Type 'T' is not assignable to type 'U'. -tests/cases/conformance/types/intersection/intersectionTypeInference.ts(7,5): error TS2322: Type 'U' is not assignable to type 'T & U'. +tests/cases/conformance/types/intersection/intersectionTypeInference.ts(6,5): error TS2322: Type 'U' is not assignable to type 'T & U'. Type 'U' is not assignable to type 'T'. ==== tests/cases/conformance/types/intersection/intersectionTypeInference.ts (2 errors) ==== - function extend(obj1: T, obj2: U): T & U { var result: T & U; obj1 = result; @@ -24,4 +23,19 @@ tests/cases/conformance/types/intersection/intersectionTypeInference.ts(7,5): er var x = extend({ a: "hello" }, { b: 42 }); var s = x.a; var n = x.b; + + interface A { + a: T; + } + + interface B { + b: U; + } + + function foo(obj: A & B): T | U { + return undefined; + } + + var z = foo({ a: "hello", b: 42 }); + var z: string | number; \ No newline at end of file diff --git a/tests/baselines/reference/intersectionTypeInference.js b/tests/baselines/reference/intersectionTypeInference.js index 0b95879a6c0..8e7f1238c07 100644 --- a/tests/baselines/reference/intersectionTypeInference.js +++ b/tests/baselines/reference/intersectionTypeInference.js @@ -1,5 +1,4 @@ //// [intersectionTypeInference.ts] - function extend(obj1: T, obj2: U): T & U { var result: T & U; obj1 = result; @@ -12,6 +11,21 @@ function extend(obj1: T, obj2: U): T & U { var x = extend({ a: "hello" }, { b: 42 }); var s = x.a; var n = x.b; + +interface A { + a: T; +} + +interface B { + b: U; +} + +function foo(obj: A & B): T | U { + return undefined; +} + +var z = foo({ a: "hello", b: 42 }); +var z: string | number; //// [intersectionTypeInference.js] @@ -26,3 +40,8 @@ function extend(obj1, obj2) { var x = extend({ a: "hello" }, { b: 42 }); var s = x.a; var n = x.b; +function foo(obj) { + return undefined; +} +var z = foo({ a: "hello", b: 42 }); +var z; diff --git a/tests/cases/conformance/types/intersection/intersectionTypeInference.ts b/tests/cases/conformance/types/intersection/intersectionTypeInference.ts index 3126ce09448..32a419ff03a 100644 --- a/tests/cases/conformance/types/intersection/intersectionTypeInference.ts +++ b/tests/cases/conformance/types/intersection/intersectionTypeInference.ts @@ -1,4 +1,3 @@ - function extend(obj1: T, obj2: U): T & U { var result: T & U; obj1 = result; @@ -11,3 +10,18 @@ function extend(obj1: T, obj2: U): T & U { var x = extend({ a: "hello" }, { b: 42 }); var s = x.a; var n = x.b; + +interface A { + a: T; +} + +interface B { + b: U; +} + +function foo(obj: A & B): T | U { + return undefined; +} + +var z = foo({ a: "hello", b: 42 }); +var z: string | number; From 18d6e73aa0d8724516be86bf9cf28d2f96261cf2 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 30 Jun 2015 14:33:13 -0700 Subject: [PATCH 274/309] Revert isRelatedFlags changes --- src/compiler/checker.ts | 221 ++++++++++++--------------- src/compiler/diagnosticMessages.json | 2 +- src/compiler/types.ts | 8 +- 3 files changed, 102 insertions(+), 129 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 27e500bc3f8..0a46e279a75 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2221,8 +2221,8 @@ namespace ts { // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature, // or otherwise the type of the string index signature. type = getTypeOfPropertyOfType(parentType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) || - getIndexTypeOfType(parentType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) || + getIndexTypeOfType(parentType, IndexKind.String); if (!type) { error(name, Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(parentType), declarationNameToString(name)); return unknownType; @@ -3822,8 +3822,8 @@ namespace ts { */ function createTypedPropertyDescriptorType(propertyType: Type): Type { let globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType(); - return globalTypedPropertyDescriptorType !== emptyObjectType - ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) + return globalTypedPropertyDescriptorType !== emptyObjectType + ? createTypeReference(globalTypedPropertyDescriptorType, [propertyType]) : emptyObjectType; } @@ -4291,27 +4291,27 @@ namespace ts { // TYPE CHECKING function isTypeIdenticalTo(source: Type, target: Type): boolean { - return checkTypeRelatedTo(source, target, identityRelation, RelationComparisonFlags.None, /*errorNode*/ undefined); + return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined); } function compareTypes(source: Type, target: Type): Ternary { - return checkTypeRelatedTo(source, target, identityRelation, RelationComparisonFlags.None, /*errorNode*/ undefined) ? Ternary.True : Ternary.False; + return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined) ? Ternary.True : Ternary.False; } function isTypeSubtypeOf(source: Type, target: Type): boolean { - return checkTypeSubtypeOf(source, target, /*context*/ undefined, /*errorNode*/ undefined); + return checkTypeSubtypeOf(source, target, /*errorNode*/ undefined); } function isTypeAssignableTo(source: Type, target: Type): boolean { - return checkTypeAssignableTo(source, target, RelationComparisonFlags.None, /*errorNode*/ undefined); + return checkTypeAssignableTo(source, target, /*errorNode*/ undefined); } function checkTypeSubtypeOf(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { - return checkTypeRelatedTo(source, target, subtypeRelation, RelationComparisonFlags.None, errorNode, headMessage, containingMessageChain); + return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain); } - function checkTypeAssignableTo(source: Type, target: Type, relationFlags: RelationComparisonFlags, errorNode?: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { - return checkTypeRelatedTo(source, target, assignableRelation, relationFlags, errorNode, headMessage, containingMessageChain); + function checkTypeAssignableTo(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain); } function isSignatureAssignableTo(source: Signature, target: Signature): boolean { @@ -4326,24 +4326,17 @@ namespace ts { * @param target The right-hand-side of the relation. * @param relation The relation considered. One of 'identityRelation', 'assignableRelation', or 'subTypeRelation'. * Used as both to determine which checks are performed and as a cache of previously computed results. - * @param relationFlags Additional information affecting whether the relation holds. Currently used only for distinguishing - * between a type comparison when extending classes from other comparisons of the constructor types. - * - * Caution: checks triggered by these flags should NOT affect the result cached. * @param errorNode The node upon which all errors will be reported, if defined. * @param headMessage If the error chain should be prepended by a head message, then headMessage will be used. * @param containingMessageChain A chain of errors to prepend any new errors found. - */ function checkTypeRelatedTo( source: Type, target: Type, relation: Map, - relationFlags: RelationComparisonFlags, - errorNode?: Node, + errorNode: Node, headMessage?: DiagnosticMessage, - containingMessageChain?: DiagnosticMessageChain - ): boolean { + containingMessageChain?: DiagnosticMessageChain): boolean { let errorInfo: DiagnosticMessageChain; let sourceStack: ObjectType[]; @@ -4388,7 +4381,6 @@ namespace ts { // Ternary.False if they are not related. function isRelatedTo(source: Type, target: Type, reportErrors?: boolean, headMessage?: DiagnosticMessage): Ternary { let result: Ternary; - let relationFlagCheckResult: Ternary; // both types are the same - covers 'they are the same primitive type or both are Any' or the same type parameter cases if (source === target) return Ternary.True; if (relation !== identityRelation) { @@ -6089,20 +6081,20 @@ namespace ts { if (container && isClassLike(container.parent)) { if (container.flags & NodeFlags.Static) { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor; } else { canUseSuperExpression = - container.kind === SyntaxKind.MethodDeclaration || - container.kind === SyntaxKind.MethodSignature || - container.kind === SyntaxKind.GetAccessor || - container.kind === SyntaxKind.SetAccessor || - container.kind === SyntaxKind.PropertyDeclaration || - container.kind === SyntaxKind.PropertySignature || - container.kind === SyntaxKind.Constructor; + container.kind === SyntaxKind.MethodDeclaration || + container.kind === SyntaxKind.MethodSignature || + container.kind === SyntaxKind.GetAccessor || + container.kind === SyntaxKind.SetAccessor || + container.kind === SyntaxKind.PropertyDeclaration || + container.kind === SyntaxKind.PropertySignature || + container.kind === SyntaxKind.Constructor; } } } @@ -6779,7 +6771,7 @@ namespace ts { checkJsxOpeningLikeElement(node.openingElement); // Check children - for(let child of node.children) { + for (let child of node.children) { switch (child.kind) { case SyntaxKind.JsxExpression: checkJsxExpression(child); @@ -6830,7 +6822,7 @@ namespace ts { else if (elementAttributesType && !isTypeAny(elementAttributesType)) { let correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text); correspondingPropType = correspondingPropSymbol && getTypeOfSymbol(correspondingPropSymbol); - // If there's no corresponding property with this name, error + // If there's no corresponding property with this name, error if (!correspondingPropType && isUnhyphenatedJsxName(node.name.text)) { error(node.name, Diagnostics.Property_0_does_not_exist_on_type_1, node.name.text, typeToString(elementAttributesType)); return unknownType; @@ -6847,7 +6839,7 @@ namespace ts { } if (correspondingPropType) { - checkTypeAssignableTo(exprType, correspondingPropType, RelationComparisonFlags.None, node); + checkTypeAssignableTo(exprType, correspondingPropType, node); } nameTable[node.name.text] = true; @@ -6857,14 +6849,14 @@ namespace ts { function checkJsxSpreadAttribute(node: JsxSpreadAttribute, elementAttributesType: Type, nameTable: Map) { let type = checkExpression(node.expression); let props = getPropertiesOfType(type); - for(let prop of props) { + for (let prop of props) { // Is there a corresponding property in the element attributes type? Skip checking of properties // that have already been assigned to, as these are not actually pushed into the resulting type if (!nameTable[prop.name]) { let targetPropSym = getPropertyOfType(elementAttributesType, prop.name); if (targetPropSym) { let msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, prop.name); - checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(targetPropSym), RelationComparisonFlags.None, node, undefined, msg); + checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(targetPropSym), node, undefined, msg); } nameTable[prop.name] = true; @@ -6937,7 +6929,7 @@ namespace ts { else { valueSymbol = checkQualifiedName(node.tagName).symbol; } - + if (valueSymbol !== unknownSymbol) { links.jsxFlags |= JsxFlags.ClassElement; } @@ -6992,7 +6984,7 @@ namespace ts { // Issue an error if this return type isn't assignable to JSX.ElementClass let elemClassType = getJsxGlobalElementClassType(); if (elemClassType) { - checkTypeRelatedTo(returnType, elemClassType, assignableRelation, RelationComparisonFlags.None, node, Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements); + checkTypeRelatedTo(returnType, elemClassType, assignableRelation, node, Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements); } return returnType; @@ -7107,7 +7099,7 @@ namespace ts { let jsxElementClassType: Type = undefined; function getJsxGlobalElementClassType(): Type { - if(!jsxElementClassType) { + if (!jsxElementClassType) { jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass); } return jsxElementClassType; @@ -7126,7 +7118,7 @@ namespace ts { } if (jsxElementType === undefined) { - if(compilerOptions.noImplicitAny) { + if (compilerOptions.noImplicitAny) { error(errorNode, Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist); } } @@ -7150,7 +7142,7 @@ namespace ts { else { Debug.assert(node.attributes[i].kind === SyntaxKind.JsxSpreadAttribute); let spreadType = checkJsxSpreadAttribute((node.attributes[i]), targetAttributesType, nameTable); - if(isTypeAny(spreadType)) { + if (isTypeAny(spreadType)) { sawSpreadedAny = true; } } @@ -7305,7 +7297,7 @@ namespace ts { } return unknownType; } - + getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & SymbolFlags.Class) { @@ -7570,7 +7562,7 @@ namespace ts { let callIsIncomplete: boolean; // In incomplete call we want to be lenient when we have too few arguments let isDecorator: boolean; let spreadArgIndex = -1; - + if (node.kind === SyntaxKind.TaggedTemplateExpression) { let tagExpression = node; @@ -7751,18 +7743,17 @@ namespace ts { errorInfo = chainDiagnosticMessages(errorInfo, typeArgumentHeadMessage); typeArgumentHeadMessage = headMessage; } - + typeArgumentsAreAssignable = checkTypeAssignableTo( - typeArgument, - constraint, - RelationComparisonFlags.None, + typeArgument, + constraint, reportErrors ? typeArgNode : undefined, - typeArgumentHeadMessage, + typeArgumentHeadMessage, errorInfo); } } } - + return typeArgumentsAreAssignable; } @@ -7787,12 +7778,12 @@ namespace ts { // Use argument expression as error location when reporting errors let errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined; let headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; - if (!checkTypeRelatedTo(argType, paramType, relation, RelationComparisonFlags.None, errorNode, headMessage)) { + if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) { return false; } } } - + return true; } @@ -7898,7 +7889,7 @@ namespace ts { // "static" or "constructor" side of the class) let classSymbol = getSymbolOfNode(node); return getTypeOfSymbol(classSymbol); - + case SyntaxKind.Parameter: // For a parameter decorator, the `target` is the parent type of the // parameter's containing method. @@ -7908,7 +7899,7 @@ namespace ts { return getTypeOfSymbol(classSymbol); } - // fall-through + // fall-through case SyntaxKind.PropertyDeclaration: case SyntaxKind.MethodDeclaration: @@ -7919,7 +7910,7 @@ namespace ts { // declared "static"; otherwise, it is the "instance"-side type of the // parent of the member. return getParentTypeOfClassElement(node); - + default: Debug.fail("Unsupported decorator target."); return unknownType; @@ -7947,7 +7938,7 @@ namespace ts { case SyntaxKind.ClassDeclaration: Debug.fail("Class decorators should not have a second synthetic argument."); return unknownType; - + case SyntaxKind.Parameter: node = node.parent; if (node.kind === SyntaxKind.Constructor) { @@ -7955,10 +7946,10 @@ namespace ts { return anyType; } - // For a non-constructor parameter decorator, the `propertyKey` will be either - // a string or a symbol, based on the name of the parameter's containing method. + // For a non-constructor parameter decorator, the `propertyKey` will be either + // a string or a symbol, based on the name of the parameter's containing method. - // fall-through + // fall-through case SyntaxKind.PropertyDeclaration: case SyntaxKind.MethodDeclaration: @@ -7974,7 +7965,7 @@ namespace ts { case SyntaxKind.NumericLiteral: case SyntaxKind.StringLiteral: return getStringLiteralType(element.name); - + case SyntaxKind.ComputedPropertyName: let nameType = checkComputedPropertyName(element.name); if (allConstituentTypesHaveKind(nameType, TypeFlags.ESSymbol)) { @@ -7983,13 +7974,13 @@ namespace ts { else { return stringType; } - + default: Debug.fail("Unsupported property name."); return unknownType; } - + default: Debug.fail("Unsupported decorator target."); return unknownType; @@ -8026,7 +8017,7 @@ namespace ts { // for the type of the member. let propertyType = getTypeOfNode(node); return createTypedPropertyDescriptorType(propertyType); - + default: Debug.fail("Unsupported decorator target."); return unknownType; @@ -8079,7 +8070,7 @@ namespace ts { (argIndex === 0 && node.kind === SyntaxKind.TaggedTemplateExpression)) { return undefined; } - + return args[argIndex]; } @@ -8099,7 +8090,7 @@ namespace ts { return arg; } } - + function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[], headMessage?: DiagnosticMessage): Signature { let isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression; let isDecorator = node.kind === SyntaxKind.Decorator; @@ -8227,7 +8218,7 @@ namespace ts { let diagnosticChainHead = chainDiagnosticMessages(/*details*/ undefined, // details will be provided by call to reportNoCommonSupertypeError Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, typeToString(failedTypeParameter)); - + if (headMessage) { diagnosticChainHead = chainDiagnosticMessages(diagnosticChainHead, headMessage); } @@ -8253,7 +8244,7 @@ namespace ts { } return resolveErrorCall(node); - + function reportError(message: DiagnosticMessage, arg0?: string, arg1?: string, arg2?: string): void { let errorInfo: DiagnosticMessageChain; errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2); @@ -8484,13 +8475,13 @@ namespace ts { case SyntaxKind.ClassDeclaration: case SyntaxKind.ClassExpression: return Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; - + case SyntaxKind.Parameter: return Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; - + case SyntaxKind.PropertyDeclaration: return Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; - + case SyntaxKind.MethodDeclaration: case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: @@ -8507,12 +8498,12 @@ namespace ts { if (apparentType === unknownType) { return resolveErrorCall(node); } - + let callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call); if (funcType === anyType || (!callSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) { return resolveUntypedCall(node); } - + let headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); if (!callSignatures.length) { let errorInfo: DiagnosticMessageChain; @@ -8521,7 +8512,7 @@ namespace ts { diagnostics.add(createDiagnosticForNodeFromMessageChain(node, errorInfo)); return resolveErrorCall(node); } - + return resolveCall(node, callSignatures, candidatesOutArray, headMessage); } @@ -8596,7 +8587,7 @@ namespace ts { if (produceDiagnostics && targetType !== unknownType) { let widenedType = getWidenedType(exprType); if (!(isTypeAssignableTo(targetType, widenedType))) { - checkTypeAssignableTo(exprType, targetType, RelationComparisonFlags.None, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other); + checkTypeAssignableTo(exprType, targetType, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other); } } return targetType; @@ -8763,6 +8754,7 @@ namespace ts { function checkFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | MethodDeclaration, contextualMapper?: TypeMapper): Type { Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node)); + // Grammar checking let hasGrammarError = checkGrammarFunctionLikeDeclaration(node); if (!hasGrammarError && node.kind === SyntaxKind.FunctionExpression) { @@ -8829,7 +8821,7 @@ namespace ts { else { let exprType = checkExpression(node.body); if (node.type) { - checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), RelationComparisonFlags.None, node.body, /*headMessage*/ undefined); + checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, /*headMessage*/ undefined); } checkFunctionAndClassExpressionBodies(node.body); } @@ -9057,8 +9049,8 @@ namespace ts { let type = isTypeAny(sourceType) ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || - isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || - getIndexTypeOfType(sourceType, IndexKind.String); + isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || + getIndexTypeOfType(sourceType, IndexKind.String); if (type) { checkDestructuringAssignment((p).initializer || name, type); } @@ -9137,7 +9129,7 @@ namespace ts { function checkReferenceAssignment(target: Expression, sourceType: Type, contextualMapper?: TypeMapper): Type { let targetType = checkExpression(target, contextualMapper); if (checkReferenceExpression(target, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant)) { - checkTypeAssignableTo(sourceType, targetType, RelationComparisonFlags.None, target, /*headMessage*/ undefined); + checkTypeAssignableTo(sourceType, targetType, target, /*headMessage*/ undefined); } return sourceType; } @@ -9312,7 +9304,7 @@ namespace ts { // Use default messages if (ok) { // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported - checkTypeAssignableTo(valueType, leftType, RelationComparisonFlags.None, node.left, /*headMessage*/ undefined); + checkTypeAssignableTo(valueType, leftType, node.left, /*headMessage*/ undefined); } } } @@ -9363,10 +9355,10 @@ namespace ts { if (func.type) { let signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType; if (nodeIsYieldStar) { - checkTypeAssignableTo(expressionElementType, signatureElementType, RelationComparisonFlags.None, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(expressionElementType, signatureElementType, node.expression, /*headMessage*/ undefined); } else { - checkTypeAssignableTo(expressionType, signatureElementType, RelationComparisonFlags.None, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(expressionType, signatureElementType, node.expression, /*headMessage*/ undefined); } } } @@ -9683,7 +9675,7 @@ namespace ts { else { checkTypeAssignableTo(typePredicate.type, getTypeAtLocation(node.parameters[typePredicate.parameterIndex]), - RelationComparisonFlags.None, typePredicateNode.type); + typePredicateNode.type); } } else if (typePredicateNode.parameterName) { @@ -9761,7 +9753,7 @@ namespace ts { // interface BadGenerator extends Iterable, Iterator { } // function* g(): BadGenerator { } // Iterable and Iterator have different types! // - checkTypeAssignableTo(iterableIteratorInstantiation, returnType, RelationComparisonFlags.None, node.type); + checkTypeAssignableTo(iterableIteratorInstantiation, returnType, node.type); } } } @@ -9963,7 +9955,7 @@ namespace ts { let constraint = getConstraintOfTypeParameter(typeParameters[i]); if (constraint) { let typeArgument = typeArguments[i]; - result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, RelationComparisonFlags.None, typeArgument, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, Diagnostics.Type_0_does_not_satisfy_the_constraint_1); } } return result; @@ -10179,7 +10171,7 @@ namespace ts { // the node in question is abstract. if (node.flags & NodeFlags.Abstract) { error(errorNode, Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive); - } + } else { error(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); } @@ -10379,8 +10371,8 @@ namespace ts { if (returnType.flags & TypeFlags.Any) { return; } - - let expectedReturnType: Type; + + let expectedReturnType: Type; let headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); let errorInfo: DiagnosticMessageChain; switch (node.parent.kind) { @@ -10397,7 +10389,7 @@ namespace ts { Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any); break; - + case SyntaxKind.PropertyDeclaration: expectedReturnType = voidType; errorInfo = chainDiagnosticMessages( @@ -10413,13 +10405,12 @@ namespace ts { expectedReturnType = getUnionType([descriptorType, voidType]); break; } - + checkTypeAssignableTo( - returnType, - expectedReturnType, - RelationComparisonFlags.None, - node, - headMessage, + returnType, + expectedReturnType, + node, + headMessage, errorInfo); } @@ -10839,7 +10830,7 @@ namespace ts { // For a binding pattern, validate the initializer and exit if (isBindingPattern(node.name)) { if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), RelationComparisonFlags.None, node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), node, /*headMessage*/ undefined); checkParameterInitializer(node); } return; @@ -10849,7 +10840,7 @@ namespace ts { if (node === symbol.valueDeclaration) { // Node is the primary declaration of the symbol, just validate the initializer if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), type, RelationComparisonFlags.None, node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), type, node, /*headMessage*/ undefined); checkParameterInitializer(node); } } @@ -10861,7 +10852,7 @@ namespace ts { error(node.name, Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, declarationNameToString(node.name), typeToString(type), typeToString(declarationType)); } if (node.initializer) { - checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, RelationComparisonFlags.None, node, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, /*headMessage*/ undefined); } } if (node.kind !== SyntaxKind.PropertyDeclaration && node.kind !== SyntaxKind.PropertySignature) { @@ -10997,7 +10988,7 @@ namespace ts { // because we accessed properties from anyType, or it may have led to an error inside // getElementTypeOfIterable. if (iteratedType) { - checkTypeAssignableTo(iteratedType, leftType, RelationComparisonFlags.None, varExpr, /*headMessage*/ undefined); + checkTypeAssignableTo(iteratedType, leftType, varExpr, /*headMessage*/ undefined); } } } @@ -11097,7 +11088,7 @@ namespace ts { // Now even though we have extracted the iteratedType, we will have to validate that the type // passed in is actually an Iterable. if (errorNode && elementType) { - checkTypeAssignableTo(iterable, createIterableType(elementType), RelationComparisonFlags.None, errorNode); + checkTypeAssignableTo(iterable, createIterableType(elementType), errorNode); } return elementType || anyType; @@ -11341,7 +11332,7 @@ namespace ts { } } else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) { - checkTypeAssignableTo(exprType, returnType, RelationComparisonFlags.None, node.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(exprType, returnType, node.expression, /*headMessage*/ undefined); } } } @@ -11384,7 +11375,7 @@ namespace ts { let caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { // check 'expressionType isAssignableTo caseType' failed, try the reversed check and report errors if it fails - checkTypeAssignableTo(caseType, expressionType, RelationComparisonFlags.None, caseClause.expression, /*headMessage*/ undefined); + checkTypeAssignableTo(caseType, expressionType, caseClause.expression, /*headMessage*/ undefined); } } forEach(clause.statements, checkSourceElement); @@ -11593,19 +11584,7 @@ namespace ts { grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); } checkClassLikeDeclaration(node); - forEach(node.members, checkSourceElement); - - // forEach(node.members, node.flags & NodeFlags.Abstract ? - // checkSourceElement : - // element => { - // checkSourceElement(element); - - // // Classes containing abstract methods must be marked abstract - // if (element.flags & NodeFlags.Abstract) { - // error(node, Diagnostics.Classes_containing_abstract_methods_must_be_marked_abstract); - // } - // }); } function checkClassLikeDeclaration(node: ClassLikeDeclaration) { @@ -11637,8 +11616,8 @@ namespace ts { } } } - checkTypeAssignableTo(type, baseType, RelationComparisonFlags.None, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); - checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), RelationComparisonFlags.ExtendingClass, node.name || node, + checkTypeAssignableTo(type, baseType, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class)) { @@ -11667,7 +11646,7 @@ namespace ts { if (t !== unknownType) { let declaredType = (t.flags & TypeFlags.Reference) ? (t).target : t; if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) { - checkTypeAssignableTo(type, t, RelationComparisonFlags.None, node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1); + checkTypeAssignableTo(type, t, node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1); } else { error(typeRefNode, Diagnostics.A_class_may_only_implement_another_class_or_interface); @@ -11868,7 +11847,7 @@ namespace ts { // run subsequent checks only if first set succeeded if (checkInheritedPropertiesAreIdentical(type, node.name)) { forEach(getBaseTypes(type), baseType => { - checkTypeAssignableTo(type, baseType, RelationComparisonFlags.None, node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1); + checkTypeAssignableTo(type, baseType, node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1); }); checkIndexConstraints(type); } @@ -11921,7 +11900,7 @@ namespace ts { // If it is a constant value (not undefined), it is syntactically constrained to be a number. // Also, we do not need to check this for ambients because there is already // a syntax error if it is not a constant. - checkTypeAssignableTo(checkExpression(initializer), enumType, RelationComparisonFlags.None, initializer, /*headMessage*/ undefined); + checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, /*headMessage*/ undefined); } } else if (enumIsConst) { @@ -12794,7 +12773,7 @@ namespace ts { if ((location).name) { copySymbol(location.symbol, meaning); } - // Fall through + // Fall through case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: if (!(memberFlags & NodeFlags.Static)) { @@ -13106,7 +13085,7 @@ namespace ts { */ function getParentTypeOfClassElement(node: ClassElement) { let classSymbol = getSymbolOfNode(node.parent); - return node.flags & NodeFlags.Static + return node.flags & NodeFlags.Static ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol); } @@ -13200,7 +13179,7 @@ namespace ts { if (links.isNestedRedeclaration === undefined) { let container = getEnclosingBlockScopeContainer(symbol.valueDeclaration); links.isNestedRedeclaration = isStatementWithLocals(container) && - !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); + !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined); } return links.isNestedRedeclaration; } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 82d900056d1..d0b29a89317 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -727,7 +727,7 @@ "category": "Error", "code": 1241 }, - "'abstract' modifier can only appear on a class or method declaration.": { + "'abstract' modifier can only appear on a class or method declaration.": { "category": "Error", "code": 1242 }, diff --git a/src/compiler/types.ts b/src/compiler/types.ts index b269bbd9d68..b09adbf7cd0 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -357,7 +357,7 @@ namespace ts { Private = 0x00000020, // Property/Method Protected = 0x00000040, // Property/Method Static = 0x00000080, // Property/Method - Abstract = 0x00000100, + Abstract = 0x00000100, // Class/Method/Constructor Default = 0x00000200, // Function/Class (export default declaration) MultiLine = 0x00000400, // Multi-line array or object literal Synthetic = 0x00000800, // Synthetic node (for full fidelity) @@ -429,12 +429,6 @@ namespace ts { FailedAndReported = 3 } - /* @internal */ - export const enum RelationComparisonFlags { - None = 0, - ExtendingClass = 0x00000001 - } - export interface Node extends TextRange { kind: SyntaxKind; flags: NodeFlags; From 5864a66fbcc2af1d3fb4af6ad0d8ad047163dfba Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 30 Jun 2015 14:44:13 -0700 Subject: [PATCH 275/309] updated baselines on classAbstract tests --- tests/baselines/reference/APISample_linter.js | 146 +++++++++--------- .../classAbstractConstructor.errors.txt | 4 +- .../classAbstractDeclarations.d.errors.txt | 4 +- .../classAbstractInstantiations2.errors.txt | 13 +- ...bstractMethodWithImplementation.errors.txt | 4 +- ...classAbstractMixedWithModifiers.errors.txt | 16 +- .../classAbstractOverloads.errors.txt | 12 +- .../classAbstractProperties.errors.txt | 24 +-- ...ssAbstractUsingAbstractMethods2.errors.txt | 9 +- .../classAbstractWithInterface.errors.txt | 4 +- 10 files changed, 115 insertions(+), 121 deletions(-) diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js index 7cf6038cdb1..2eb3f924f70 100644 --- a/tests/baselines/reference/APISample_linter.js +++ b/tests/baselines/reference/APISample_linter.js @@ -1,67 +1,67 @@ //// [APISample_linter.ts] - -/* - * Note: This test is a public API sample. The sample sources can be found - at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter - * Please log a "breaking change" issue for any API breaking change affecting this issue - */ - -declare var process: any; -declare var console: any; -declare var readFileSync: any; - -import * as ts from "typescript"; - -export function delint(sourceFile: ts.SourceFile) { - delintNode(sourceFile); - - function delintNode(node: ts.Node) { - switch (node.kind) { - case ts.SyntaxKind.ForStatement: - case ts.SyntaxKind.ForInStatement: - case ts.SyntaxKind.WhileStatement: - case ts.SyntaxKind.DoStatement: - if ((node).statement.kind !== ts.SyntaxKind.Block) { - report(node, "A looping statement's contents should be wrapped in a block body."); - } - break; - - case ts.SyntaxKind.IfStatement: - let ifStatement = (node); - if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) { - report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); - } - if (ifStatement.elseStatement && - ifStatement.elseStatement.kind !== ts.SyntaxKind.Block && - ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) { - report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); - } - break; - - case ts.SyntaxKind.BinaryExpression: - let op = (node).operatorToken.kind; - if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) { - report(node, "Use '===' and '!=='.") - } - break; - } - - ts.forEachChild(node, delintNode); - } - - function report(node: ts.Node, message: string) { - let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart()); - console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`); - } -} - -const fileNames = process.argv.slice(2); -fileNames.forEach(fileName => { - // Parse a file - let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true); - - // delint it - delint(sourceFile); + +/* + * Note: This test is a public API sample. The sample sources can be found + at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter + * Please log a "breaking change" issue for any API breaking change affecting this issue + */ + +declare var process: any; +declare var console: any; +declare var readFileSync: any; + +import * as ts from "typescript"; + +export function delint(sourceFile: ts.SourceFile) { + delintNode(sourceFile); + + function delintNode(node: ts.Node) { + switch (node.kind) { + case ts.SyntaxKind.ForStatement: + case ts.SyntaxKind.ForInStatement: + case ts.SyntaxKind.WhileStatement: + case ts.SyntaxKind.DoStatement: + if ((node).statement.kind !== ts.SyntaxKind.Block) { + report(node, "A looping statement's contents should be wrapped in a block body."); + } + break; + + case ts.SyntaxKind.IfStatement: + let ifStatement = (node); + if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) { + report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); + } + if (ifStatement.elseStatement && + ifStatement.elseStatement.kind !== ts.SyntaxKind.Block && + ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) { + report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); + } + break; + + case ts.SyntaxKind.BinaryExpression: + let op = (node).operatorToken.kind; + if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) { + report(node, "Use '===' and '!=='.") + } + break; + } + + ts.forEachChild(node, delintNode); + } + + function report(node: ts.Node, message: string) { + let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart()); + console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`); + } +} + +const fileNames = process.argv.slice(2); +fileNames.forEach(fileName => { + // Parse a file + let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true); + + // delint it + delint(sourceFile); }); //// [APISample_linter.js] @@ -75,26 +75,26 @@ function delint(sourceFile) { delintNode(sourceFile); function delintNode(node) { switch (node.kind) { - case 191 /* ForStatement */: - case 192 /* ForInStatement */: - case 190 /* WhileStatement */: - case 189 /* DoStatement */: - if (node.statement.kind !== 184 /* Block */) { + case 192 /* ForStatement */: + case 193 /* ForInStatement */: + case 191 /* WhileStatement */: + case 190 /* DoStatement */: + if (node.statement.kind !== 185 /* Block */) { report(node, "A looping statement's contents should be wrapped in a block body."); } break; - case 188 /* IfStatement */: + case 189 /* IfStatement */: var ifStatement = node; - if (ifStatement.thenStatement.kind !== 184 /* Block */) { + if (ifStatement.thenStatement.kind !== 185 /* Block */) { report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body."); } if (ifStatement.elseStatement && - ifStatement.elseStatement.kind !== 184 /* Block */ && - ifStatement.elseStatement.kind !== 188 /* IfStatement */) { + ifStatement.elseStatement.kind !== 185 /* Block */ && + ifStatement.elseStatement.kind !== 189 /* IfStatement */) { report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body."); } break; - case 173 /* BinaryExpression */: + case 174 /* BinaryExpression */: var op = node.operatorToken.kind; if (op === 29 /* EqualsEqualsToken */ || op == 30 /* ExclamationEqualsToken */) { report(node, "Use '===' and '!=='."); diff --git a/tests/baselines/reference/classAbstractConstructor.errors.txt b/tests/baselines/reference/classAbstractConstructor.errors.txt index fbea6ef807f..fee9f4cefee 100644 --- a/tests/baselines/reference/classAbstractConstructor.errors.txt +++ b/tests/baselines/reference/classAbstractConstructor.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts(2,5): error TS1242: 'abstract' modifier can only appear on a class or method declaration. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractConstructor.ts (1 errors) ==== abstract class A { abstract constructor() {} ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. +!!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt index 33beb6d296b..20d5ca46933 100644 --- a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt +++ b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1242: 'abstract' modifier can only appear on a class or method declaration. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,28): error TS1184: An implementation cannot be declared in ambient contexts. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(11,15): error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'foo' from class 'AA'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(13,15): error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'foo' from class 'BB'. @@ -9,7 +9,7 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst declare abstract class A { abstract constructor() {} ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. +!!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. ~ !!! error TS1184: An implementation cannot be declared in ambient contexts. } diff --git a/tests/baselines/reference/classAbstractInstantiations2.errors.txt b/tests/baselines/reference/classAbstractInstantiations2.errors.txt index 1f64759f86d..b3b01fd656d 100644 --- a/tests/baselines/reference/classAbstractInstantiations2.errors.txt +++ b/tests/baselines/reference/classAbstractInstantiations2.errors.txt @@ -3,12 +3,11 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(21,1): error TS2511: Cannot create an instance of the abstract class 'B'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(26,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'B'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,5): error TS2391: Function implementation is missing or not immediately following the declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,5): error TS2512: Overload signatures must all be `abstract` or not `abstract. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(49,7): error TS2514: Classes containing abstract methods must be marked abstract. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(50,5): error TS1238: Abstract methods can only appear within an abstract class. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(46,5): error TS2512: Overload signatures must all be abstract or not abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts(50,5): error TS1244: Abstract methods can only appear within an abstract class. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts (8 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts (7 errors) ==== class A { // ... } @@ -66,13 +65,11 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst ~~~ !!! error TS2391: Function implementation is missing or not immediately following the declaration. ~~~ -!!! error TS2512: Overload signatures must all be `abstract` or not `abstract. +!!! error TS2512: Overload signatures must all be abstract or not abstract. } class H { // error -- not declared abstract - ~ -!!! error TS2514: Classes containing abstract methods must be marked abstract. abstract baz() : number; ~~~~~~~~ -!!! error TS1238: Abstract methods can only appear within an abstract class. +!!! error TS1244: Abstract methods can only appear within an abstract class. } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt b/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt index 2649c83f4e7..412378e267d 100644 --- a/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt +++ b/tests/baselines/reference/classAbstractMethodWithImplementation.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts(2,5): error TS1240: Method 'foo' cannot have an implementation because it is marked abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts(2,5): error TS1245: Method 'foo' cannot have an implementation because it is marked abstract. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMethodWithImplementation.ts (1 errors) ==== abstract class A { abstract foo() {} ~~~~~~~~~~~~~~~~~ -!!! error TS1240: Method 'foo' cannot have an implementation because it is marked abstract. +!!! error TS1245: Method 'foo' cannot have an implementation because it is marked abstract. } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt b/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt index 4b0870e6bc5..121c1739632 100644 --- a/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt +++ b/tests/baselines/reference/classAbstractMixedWithModifiers.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(6,13): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(6,13): error TS1243: 'private' modifier cannot be used with 'abstract' modifier. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(8,14): error TS1029: 'public' modifier must precede 'abstract' modifier. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(9,14): error TS1029: 'protected' modifier must precede 'abstract' modifier. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(10,14): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(12,14): error TS1237: 'static' modifier cannot be used with 'abstract' modifier. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(14,12): error TS1237: 'static' modifier cannot be used with 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(10,14): error TS1243: 'private' modifier cannot be used with 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(12,14): error TS1243: 'static' modifier cannot be used with 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts(14,12): error TS1243: 'static' modifier cannot be used with 'abstract' modifier. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMixedWithModifiers.ts (6 errors) ==== @@ -14,7 +14,7 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst protected abstract foo_c(); private abstract foo_d(); ~~~~~~~~ -!!! error TS1237: 'private' modifier cannot be used with 'abstract' modifier. +!!! error TS1243: 'private' modifier cannot be used with 'abstract' modifier. abstract public foo_bb(); ~~~~~~ @@ -24,13 +24,13 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst !!! error TS1029: 'protected' modifier must precede 'abstract' modifier. abstract private foo_dd(); ~~~~~~~ -!!! error TS1237: 'private' modifier cannot be used with 'abstract' modifier. +!!! error TS1243: 'private' modifier cannot be used with 'abstract' modifier. abstract static foo_d(); ~~~~~~ -!!! error TS1237: 'static' modifier cannot be used with 'abstract' modifier. +!!! error TS1243: 'static' modifier cannot be used with 'abstract' modifier. static abstract foo_e(); ~~~~~~~~ -!!! error TS1237: 'static' modifier cannot be used with 'abstract' modifier. +!!! error TS1243: 'static' modifier cannot be used with 'abstract' modifier. } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractOverloads.errors.txt b/tests/baselines/reference/classAbstractOverloads.errors.txt index 74463ca7fc0..0a1c96bd30a 100644 --- a/tests/baselines/reference/classAbstractOverloads.errors.txt +++ b/tests/baselines/reference/classAbstractOverloads.errors.txt @@ -1,6 +1,6 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(7,5): error TS2512: Overload signatures must all be `abstract` or not `abstract. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(10,14): error TS2512: Overload signatures must all be `abstract` or not `abstract. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(12,14): error TS2512: Overload signatures must all be `abstract` or not `abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(7,5): error TS2512: Overload signatures must all be abstract or not abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(10,14): error TS2512: Overload signatures must all be abstract or not abstract. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(12,14): error TS2512: Overload signatures must all be abstract or not abstract. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(15,5): error TS2391: Function implementation is missing or not immediately following the declaration. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractOverloads.ts(20,14): error TS2516: All declarations of an abstract method must be consecutive. @@ -14,16 +14,16 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst abstract bar(); bar(); ~~~ -!!! error TS2512: Overload signatures must all be `abstract` or not `abstract. +!!! error TS2512: Overload signatures must all be abstract or not abstract. abstract bar(); abstract baz(); ~~~ -!!! error TS2512: Overload signatures must all be `abstract` or not `abstract. +!!! error TS2512: Overload signatures must all be abstract or not abstract. baz(); abstract baz(); ~~~ -!!! error TS2512: Overload signatures must all be `abstract` or not `abstract. +!!! error TS2512: Overload signatures must all be abstract or not abstract. baz() {} qux(); diff --git a/tests/baselines/reference/classAbstractProperties.errors.txt b/tests/baselines/reference/classAbstractProperties.errors.txt index d3ee6308bc5..223a3049825 100644 --- a/tests/baselines/reference/classAbstractProperties.errors.txt +++ b/tests/baselines/reference/classAbstractProperties.errors.txt @@ -1,34 +1,34 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(2,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(3,12): error TS1236: 'abstract' modifier can only appear on a class or method declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(4,15): error TS1236: 'abstract' modifier can only appear on a class or method declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(5,13): error TS1236: 'abstract' modifier can only appear on a class or method declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(7,5): error TS1236: 'abstract' modifier can only appear on a class or method declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(12,13): error TS1237: 'private' modifier cannot be used with 'abstract' modifier. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(2,5): error TS1242: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(3,12): error TS1242: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(4,15): error TS1242: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(5,13): error TS1242: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(7,5): error TS1242: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts(12,13): error TS1243: 'private' modifier cannot be used with 'abstract' modifier. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractProperties.ts (6 errors) ==== abstract class A { abstract x : number; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. +!!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. public abstract y : number; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. +!!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. protected abstract z : number; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. +!!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. private abstract w : number; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. +!!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. abstract m: () => void; ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. +!!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. abstract foo_x() : number; public abstract foo_y() : number; protected abstract foo_z() : number; private abstract foo_w() : number; ~~~~~~~~ -!!! error TS1237: 'private' modifier cannot be used with 'abstract' modifier. +!!! error TS1243: 'private' modifier cannot be used with 'abstract' modifier. } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractUsingAbstractMethods2.errors.txt b/tests/baselines/reference/classAbstractUsingAbstractMethods2.errors.txt index 8a0e5735a25..e01b233a4c1 100644 --- a/tests/baselines/reference/classAbstractUsingAbstractMethods2.errors.txt +++ b/tests/baselines/reference/classAbstractUsingAbstractMethods2.errors.txt @@ -1,16 +1,13 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(1,7): error TS2514: Classes containing abstract methods must be marked abstract. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(2,5): error TS1238: Abstract methods can only appear within an abstract class. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(2,5): error TS1244: Abstract methods can only appear within an abstract class. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(5,7): error TS2515: Non-abstract class 'B' does not implement inherited abstract member 'foo' from class 'A'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts(21,7): error TS2515: Non-abstract class 'BB' does not implement inherited abstract member 'foo' from class 'AA'. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts (4 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractUsingAbstractMethods2.ts (3 errors) ==== class A { - ~ -!!! error TS2514: Classes containing abstract methods must be marked abstract. abstract foo(); ~~~~~~~~ -!!! error TS1238: Abstract methods can only appear within an abstract class. +!!! error TS1244: Abstract methods can only appear within an abstract class. } class B extends A {} diff --git a/tests/baselines/reference/classAbstractWithInterface.errors.txt b/tests/baselines/reference/classAbstractWithInterface.errors.txt index 7dc4dcd87c4..fa0a3d08957 100644 --- a/tests/baselines/reference/classAbstractWithInterface.errors.txt +++ b/tests/baselines/reference/classAbstractWithInterface.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts(1,1): error TS1236: 'abstract' modifier can only appear on a class or method declaration. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts(1,1): error TS1242: 'abstract' modifier can only appear on a class or method declaration. ==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractWithInterface.ts (1 errors) ==== abstract interface I {} ~~~~~~~~ -!!! error TS1236: 'abstract' modifier can only appear on a class or method declaration. \ No newline at end of file +!!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. \ No newline at end of file From 994b73f9cb703ced9ef255170b81adfe0a485a0b Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 30 Jun 2015 15:19:51 -0700 Subject: [PATCH 276/309] fixed an erroneous assertion --- src/compiler/checker.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 0a46e279a75..9a610a302f8 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11703,10 +11703,12 @@ namespace ts { // derived class inherits base without override/redeclaration let derivedClassDecl = getDeclarationOfKind(type.symbol, SyntaxKind.ClassDeclaration); - Debug.assert(derivedClassDecl !== undefined); + // Debug.assert(derivedClassDecl !== undefined); // It is an error to inherit an abstract member without implementing it or being declared abstract. - if ((baseDeclarationFlags & NodeFlags.Abstract) && !(derivedClassDecl.flags & NodeFlags.Abstract)) { + // If there is no declaration for the derived class (as in the case of class expressions), + // then the class cannot be declared abstract. + if ( baseDeclarationFlags & NodeFlags.Abstract && (!derivedClassDecl || !(derivedClassDecl.flags & NodeFlags.Abstract))) { error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, typeToString(type), symbolToString(baseProperty), typeToString(baseType)); } From feb7e1d10e079c25d238ca1395371d85f5ef3509 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Tue, 30 Jun 2015 16:13:09 -0700 Subject: [PATCH 277/309] Fixed generic abstract class inheritance and some comments --- src/compiler/checker.ts | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9a610a302f8..5bf0488e6a8 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3190,9 +3190,11 @@ namespace ts { return type.flags & TypeFlags.Union ? getPropertiesOfUnionType(type) : getPropertiesOfObjectType(type); } - // For a type parameter, return the base constraint of the type parameter. For the string, number, - // boolean, and symbol primitive types, return the corresponding object types. Otherwise return the - // type itself. Note that the apparent type of a union type is the union type itself. + /** + * For a type parameter, return the base constraint of the type parameter. For the string, number, + * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the + * type itself. Note that the apparent type of a union type is the union type itself. + */ function getApparentType(type: Type): Type { if (type.flags & TypeFlags.Union) { type = getReducedTypeOfUnionType(type); @@ -8403,7 +8405,10 @@ namespace ts { } // If the expression is of abstract type, then it cannot be instantiated. - let valueDecl = expressionType.symbol && expressionType.symbol.valueDeclaration; + // Note, only class declarations can be declared abstract. + // In the case of a merged class-module or class-interface declaration, + // only the class declaration node will have the Abstract flag set. + let valueDecl = expressionType.symbol && getDeclarationOfKind(expressionType.symbol, SyntaxKind.ClassDeclaration); if (valueDecl && valueDecl.flags & NodeFlags.Abstract) { error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declarationNameToString(valueDecl.name)); } @@ -10253,7 +10258,8 @@ namespace ts { } // Abstract methods can't have an implementation -- in particular, they don't need one. - if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract) ) { + if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && + !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract) ) { reportImplementationExpectedError(lastSeenNonAmbientDeclaration); } @@ -11699,6 +11705,9 @@ namespace ts { Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration."); if (derived) { + // In order to resolve whether the inherited method was overriden in the base class or not, + // we compare the Symbols obtained. Since getTargetSymbol returns the symbol on the *uninstantiated* + // type declaration, derived and base resolve to the same symbol even in the case of generic classes. if (derived === base) { // derived class inherits base without override/redeclaration From 30d15a8d7c933f9468313e4b27d099735907680c Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 30 Jun 2015 19:46:59 -0700 Subject: [PATCH 278/309] Addressing CR feedback --- src/compiler/checker.ts | 38 ++++++++++++++++++++++++++------------ 1 file changed, 26 insertions(+), 12 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 10f7b530330..be823989b82 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3910,25 +3910,23 @@ namespace ts { return links.resolvedType; } - function addTypeToSet(typeSet: Type[], type: Type, typeKind: TypeFlags) { - if (type.flags & typeKind) { - addTypesToSet(typeSet, (type).types, typeKind); + function addTypeToSet(typeSet: Type[], type: Type, typeSetKind: TypeFlags) { + if (type.flags & typeSetKind) { + addTypesToSet(typeSet, (type).types, typeSetKind); } else if (!contains(typeSet, type)) { typeSet.push(type); } } - function addTypesToSet(typeSet: Type[], types: Type[], typeKind: TypeFlags) { + // Add the given types to the given type set. Order is preserved, duplicates are removed, + // and nested types of the given kind are flattened into the set. + function addTypesToSet(typeSet: Type[], types: Type[], typeSetKind: TypeFlags) { for (let type of types) { - addTypeToSet(typeSet, type, typeKind); + addTypeToSet(typeSet, type, typeSetKind); } } - function compareTypeIds(type1: Type, type2: Type): number { - return type1.id - type2.id; - } - function isSubtypeOfAny(candidate: Type, types: Type[]): boolean { for (let type of types) { if (candidate !== type && isTypeSubtypeOf(candidate, type)) { @@ -3967,6 +3965,10 @@ namespace ts { } } + function compareTypeIds(type1: Type, type2: Type): number { + return type1.id - type2.id; + } + // The noSubtypeReduction flag is there because it isn't possible to always do subtype reduction. The flag // is true when creating a union type from a type node and when instantiating a union type. In both of those // cases subtype reduction has to be deferred to properly support recursive union types. For example, a @@ -4031,8 +4033,11 @@ namespace ts { // type operator and we can't reduce those because we want to support recursive intersection types. For example, // a type alias of the form "type List = T & { next: List }" cannot be reduced during its declaration. // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution - // for intersections of types with signatues can be deterministic. + // for intersections of types with signatures can be deterministic. function getIntersectionType(types: Type[]): Type { + if (types.length === 0) { + return emptyObjectType; + } let typeSet: Type[] = []; addTypesToSet(typeSet, types, TypeFlags.Intersection); if (containsTypeAny(typeSet)) { @@ -4469,6 +4474,7 @@ namespace ts { } } else if (relation !== identityRelation) { + // Note that the "each" checks must precede the "some" checks to produce the correct results if (source.flags & TypeFlags.Union) { if (result = eachTypeRelatedToType(source, target, reportErrors)) { return result; @@ -4480,6 +4486,9 @@ namespace ts { } } else { + // A check of the form A | B = C & D can be satisfied either by having C be related to A | B, + // D be related to A | B, C & D be related to A, or C & D be related to B. Thus, we need to + // check both sides here. if (source.flags & TypeFlags.Intersection) { // If target is a union type the following check will report errors so we suppress them here if (result = someTypeRelatedToType(source, target, reportErrors && !(target.flags & TypeFlags.Union))) { @@ -4508,8 +4517,11 @@ namespace ts { // it may hold in a structural comparison. // Report structural errors only if we haven't reported any errors yet let reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo; - // identity relation does not use apparent type + // Identity relation does not use apparent type let sourceOrApparentType = relation === identityRelation ? source : getApparentType(source); + // In a check of the form X = A & B, we will have previously checked if A relates to X or B relates + // to X. Failing both of those we want to check if the aggregation of A and B's members structurally + // relates to X. Thus, we include intersection types on the source side here. if (sourceOrApparentType.flags & (TypeFlags.ObjectType | TypeFlags.Intersection) && target.flags & TypeFlags.ObjectType) { if (result = objectTypeRelatedTo(sourceOrApparentType, target, reportStructuralErrors)) { errorInfo = saveErrorInfo; @@ -5423,7 +5435,9 @@ namespace ts { } } // Next, if target is a union type containing a single naked type parameter, make a - // secondary inference to that type parameter + // secondary inference to that type parameter. We don't do this for intersection types + // because in a target type like Foo & T we don't know how which parts of the source type + // should be matched by Foo and which should be inferred to T. if (target.flags & TypeFlags.Union && typeParameterCount === 1) { inferiority++; inferFromTypes(source, typeParameter); From a1877ef336c23459f6326f0f3e488820dc3ab571 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 10:46:10 -0700 Subject: [PATCH 279/309] fexed comment and initialization --- src/compiler/checker.ts | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 5bf0488e6a8..5c5cc36f5ce 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3734,12 +3734,12 @@ namespace ts { // We only support expressions that are simple qualified names. For other expressions this produces undefined. let typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (node).typeName : isSupportedExpressionWithTypeArguments(node) ? (node).expression : - undefined; + undefined; let symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol; let type = symbol === unknownSymbol ? unknownType : symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) : - symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : - getTypeFromNonGenericTypeReference(node, symbol); + symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the // type reference in checkTypeReferenceOrExpressionWithTypeArguments. links.resolvedSymbol = symbol; @@ -4641,8 +4641,6 @@ namespace ts { let sourceProp = getPropertyOfType(source, targetProp.name); if (sourceProp !== targetProp) { - // sourceProp !== targetProp -- ie: source and target have distinct declarations with the same name - if (!sourceProp) { if (!(targetProp.flags & SymbolFlags.Optional) || requireOptionalProperties) { if (reportErrors) { @@ -7216,7 +7214,7 @@ namespace ts { } if (flags & NodeFlags.Abstract) { - // A method cannot be accessed in a super call if the method is abstract. + // A method cannot be accessed in a super property access if the method is abstract. // This error could mask a private property access error. But, a member // cannot simultaneously be private and abstract, so this will trigger an // additional error elsewhere. From f7ba7188f3d9b54126605e4ae88105db702cbdd2 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 1 Jul 2015 13:02:59 -0700 Subject: [PATCH 280/309] Add test case for completion when destructuring from a union type. --- .../completionListInObjectBindingPattern13.ts | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 tests/cases/fourslash/completionListInObjectBindingPattern13.ts diff --git a/tests/cases/fourslash/completionListInObjectBindingPattern13.ts b/tests/cases/fourslash/completionListInObjectBindingPattern13.ts new file mode 100644 index 00000000000..f91f9fcceed --- /dev/null +++ b/tests/cases/fourslash/completionListInObjectBindingPattern13.ts @@ -0,0 +1,19 @@ +/// + +////interface I { +//// x: number; +//// y: string; +//// z: boolean; +////} +//// +////interface J { +//// x: string; +//// y: string; +////} +//// +////let { /**/ }: I | J = { x: 10 }; + +goTo.marker(); +verify.completionListContains("x"); +verify.completionListContains("y"); +verify.not.completionListContains("z"); \ No newline at end of file From 4dd369fe120d7de1a9210a9037459e72bc37e67b Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 13:37:41 -0700 Subject: [PATCH 281/309] moved initialization and changed a comment --- src/compiler/checker.ts | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 5c5cc36f5ce..bf6f7658f04 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7191,7 +7191,7 @@ namespace ts { */ function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol): boolean { let flags = getDeclarationFlagsFromSymbol(prop); - let declaringClass: InterfaceType; + let declaringClass = getDeclaredTypeOfSymbol(prop.parent);; if (left.kind === SyntaxKind.SuperKeyword) { let errorNode = (node).name ? @@ -7219,8 +7219,6 @@ namespace ts { // cannot simultaneously be private and abstract, so this will trigger an // additional error elsewhere. - declaringClass = getDeclaredTypeOfSymbol(prop.parent); - error(errorNode, Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(declaringClass)); return false; } @@ -7236,7 +7234,6 @@ namespace ts { let enclosingClassDeclaration = getContainingClass(node); let enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; - declaringClass = getDeclaredTypeOfSymbol(prop.parent); // Private property is accessible if declaring and enclosing class are the same if (flags & NodeFlags.Private) { @@ -8391,7 +8388,7 @@ namespace ts { let expressionType = checkExpression(node.expression); - // If ConstructExpr's apparent type(section 3.8.1) is an object type with one or + // If expressionType's apparent type(section 3.8.1) is an object type with one or // more construct signatures, the expression is processed in the same manner as a // function call, but using the construct signatures as the initial set of candidate // signatures for overload resolution. The result type of the function call becomes @@ -8402,7 +8399,7 @@ namespace ts { return resolveErrorCall(node); } - // If the expression is of abstract type, then it cannot be instantiated. + // If the expression is a class of abstract type, then it cannot be instantiated. // Note, only class declarations can be declared abstract. // In the case of a merged class-module or class-interface declaration, // only the class declaration node will have the Abstract flag set. @@ -8412,7 +8409,7 @@ namespace ts { } // TS 1.0 spec: 4.11 - // If ConstructExpr is of type Any, Args can be any argument + // If expressionType is of type Any, Args can be any argument // list and the result of the operation is of type Any. if (isTypeAny(expressionType)) { if (node.typeArguments) { @@ -8430,7 +8427,7 @@ namespace ts { return resolveCall(node, constructSignatures, candidatesOutArray); } - // If ConstructExpr's apparent type is an object type with no construct signatures but + // If expressionType's apparent type is an object type with no construct signatures but // one or more call signatures, the expression is processed as a function call. A compile-time // error occurs if the result of the function call is not Void. The type of the result of the // operation is Any. @@ -13838,6 +13835,12 @@ namespace ts { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract"); } } + else { + // mark the constructor abstract for static-side assignability restrictions. + + // (node).members.????; + + } flags |= NodeFlags.Abstract; break; From 1efff2857fa1c8fff2ac00443dc8fda8003c22a8 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 14:45:53 -0700 Subject: [PATCH 282/309] fixed union-type determination, moved abstract implementation test, and reformatted a line --- src/compiler/checker.ts | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 36981435828..54bdbe4c443 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7244,8 +7244,7 @@ namespace ts { let declaringClass = getDeclaredTypeOfSymbol(prop.parent);; if (left.kind === SyntaxKind.SuperKeyword) { - let errorNode = (node).name ? - (node).name : + let errorNode = node.kind === SyntaxKind.PropertyAccessExpression ? (node).name : (node).right; // TS 1.0 spec (April 2014): 4.8.2 @@ -9978,6 +9977,12 @@ namespace ts { // Grammar checking for modifiers is done inside the function checkGrammarFunctionLikeDeclaration checkFunctionLikeDeclaration(node); + + // Abstract methods cannot have an implementation. + // Extra checks are to avoid reporting multiple errors relating to the "abstractness" of the node. + if(node.flags & NodeFlags.Abstract && node.body) { + error(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name)); + } } function checkConstructorDeclaration(node: ConstructorDeclaration) { @@ -10381,12 +10386,6 @@ namespace ts { if (!bodyDeclaration) { bodyDeclaration = node; } - - // abstract functions cannot have an implementation. - // Extra checks are to avoid reporting multiple errors relating to the "abstractness" of the node. - if (currentNodeFlags & NodeFlags.Abstract && node.kind === SyntaxKind.MethodDeclaration && !isConstructor) { - error(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name)) - } } else { hasOverloads = true; @@ -14251,8 +14250,9 @@ namespace ts { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } else if (flags & NodeFlags.Abstract) { - if (modifier.kind === SyntaxKind.PrivateKeyword) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract")} + if (modifier.kind === SyntaxKind.PrivateKeyword) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract"); + } else { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract"); } From c93bde693ba45bbc8fa1813a553657b0a1e30494 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 14:46:18 -0700 Subject: [PATCH 283/309] added tests --- .../classAbstractGeneric.ts | 25 +++++++++++++++++++ .../classAbstractMergedDeclaration.ts | 24 ++++++++++++++++++ 2 files changed, 49 insertions(+) create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts create mode 100644 tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts new file mode 100644 index 00000000000..f69ea30d0d6 --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts @@ -0,0 +1,25 @@ +abstract class A { + t: T; + + abstract foo(): T; + abstract bar(t: T); +} + +abstract class B extends A {} + +class C extends A {} // error -- inherits abstract methods + +class D extends A {} // error -- inherits abstract methods + +class E extends A { // error -- doesn't implement bar + foo() { return this.t; } +} + +class F extends A { // error -- doesn't implement foo + bar(t : T) {} +} + +class G extends A { + foo() { return this.t; } + bar(t: T) { } +} \ No newline at end of file diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts new file mode 100644 index 00000000000..160c0de298b --- /dev/null +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts @@ -0,0 +1,24 @@ +abstract class CM {} +module CM {} + +module MC {} +abstract class MC {} + +abstract class CI {} +interface CI {} + +interface IC {} +abstract class IC {} + +abstract class CC1 {} +class CC1 {} + +class CC2 {} +abstract class CC2 {} + +new CM; +new MC; +new CI; +new IC; +new CC1; +new CC2; \ No newline at end of file From 139d0f46bc20170f8c4901650e3a0197a1bb285d Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 14:46:30 -0700 Subject: [PATCH 284/309] updated baselines --- .../reference/classAbstractGeneric.errors.txt | 46 ++++++++++ .../reference/classAbstractGeneric.js | 84 +++++++++++++++++++ .../classAbstractMergedDeclaration.errors.txt | 66 +++++++++++++++ .../classAbstractMergedDeclaration.js | 73 ++++++++++++++++ 4 files changed, 269 insertions(+) create mode 100644 tests/baselines/reference/classAbstractGeneric.errors.txt create mode 100644 tests/baselines/reference/classAbstractGeneric.js create mode 100644 tests/baselines/reference/classAbstractMergedDeclaration.errors.txt create mode 100644 tests/baselines/reference/classAbstractMergedDeclaration.js diff --git a/tests/baselines/reference/classAbstractGeneric.errors.txt b/tests/baselines/reference/classAbstractGeneric.errors.txt new file mode 100644 index 00000000000..fb5a4c32a39 --- /dev/null +++ b/tests/baselines/reference/classAbstractGeneric.errors.txt @@ -0,0 +1,46 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts(10,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts(10,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'foo' from class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts(12,7): error TS2515: Non-abstract class 'D' does not implement inherited abstract member 'bar' from class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts(12,7): error TS2515: Non-abstract class 'D' does not implement inherited abstract member 'foo' from class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts(14,7): error TS2515: Non-abstract class 'E' does not implement inherited abstract member 'bar' from class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts(18,7): error TS2515: Non-abstract class 'F' does not implement inherited abstract member 'foo' from class 'A'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractGeneric.ts (6 errors) ==== + abstract class A { + t: T; + + abstract foo(): T; + abstract bar(t: T); + } + + abstract class B extends A {} + + class C extends A {} // error -- inherits abstract methods + ~ +!!! error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'bar' from class 'A'. + ~ +!!! error TS2515: Non-abstract class 'C' does not implement inherited abstract member 'foo' from class 'A'. + + class D extends A {} // error -- inherits abstract methods + ~ +!!! error TS2515: Non-abstract class 'D' does not implement inherited abstract member 'bar' from class 'A'. + ~ +!!! error TS2515: Non-abstract class 'D' does not implement inherited abstract member 'foo' from class 'A'. + + class E extends A { // error -- doesn't implement bar + ~ +!!! error TS2515: Non-abstract class 'E' does not implement inherited abstract member 'bar' from class 'A'. + foo() { return this.t; } + } + + class F extends A { // error -- doesn't implement foo + ~ +!!! error TS2515: Non-abstract class 'F' does not implement inherited abstract member 'foo' from class 'A'. + bar(t : T) {} + } + + class G extends A { + foo() { return this.t; } + bar(t: T) { } + } \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractGeneric.js b/tests/baselines/reference/classAbstractGeneric.js new file mode 100644 index 00000000000..5af7da1601a --- /dev/null +++ b/tests/baselines/reference/classAbstractGeneric.js @@ -0,0 +1,84 @@ +//// [classAbstractGeneric.ts] +abstract class A { + t: T; + + abstract foo(): T; + abstract bar(t: T); +} + +abstract class B extends A {} + +class C extends A {} // error -- inherits abstract methods + +class D extends A {} // error -- inherits abstract methods + +class E extends A { // error -- doesn't implement bar + foo() { return this.t; } +} + +class F extends A { // error -- doesn't implement foo + bar(t : T) {} +} + +class G extends A { + foo() { return this.t; } + bar(t: T) { } +} + +//// [classAbstractGeneric.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var A = (function () { + function A() { + } + return A; +})(); +var B = (function (_super) { + __extends(B, _super); + function B() { + _super.apply(this, arguments); + } + return B; +})(A); +var C = (function (_super) { + __extends(C, _super); + function C() { + _super.apply(this, arguments); + } + return C; +})(A); // error -- inherits abstract methods +var D = (function (_super) { + __extends(D, _super); + function D() { + _super.apply(this, arguments); + } + return D; +})(A); // error -- inherits abstract methods +var E = (function (_super) { + __extends(E, _super); + function E() { + _super.apply(this, arguments); + } + E.prototype.foo = function () { return this.t; }; + return E; +})(A); +var F = (function (_super) { + __extends(F, _super); + function F() { + _super.apply(this, arguments); + } + F.prototype.bar = function (t) { }; + return F; +})(A); +var G = (function (_super) { + __extends(G, _super); + function G() { + _super.apply(this, arguments); + } + G.prototype.foo = function () { return this.t; }; + G.prototype.bar = function (t) { }; + return G; +})(A); diff --git a/tests/baselines/reference/classAbstractMergedDeclaration.errors.txt b/tests/baselines/reference/classAbstractMergedDeclaration.errors.txt new file mode 100644 index 00000000000..ca2cc3b8c2d --- /dev/null +++ b/tests/baselines/reference/classAbstractMergedDeclaration.errors.txt @@ -0,0 +1,66 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(7,16): error TS2300: Duplicate identifier 'CI'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(8,11): error TS2300: Duplicate identifier 'CI'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(10,11): error TS2300: Duplicate identifier 'IC'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(11,16): error TS2300: Duplicate identifier 'IC'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(13,16): error TS2300: Duplicate identifier 'CC1'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(14,7): error TS2300: Duplicate identifier 'CC1'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(16,7): error TS2300: Duplicate identifier 'CC2'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(17,16): error TS2300: Duplicate identifier 'CC2'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(19,1): error TS2511: Cannot create an instance of the abstract class 'CM'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(20,1): error TS2511: Cannot create an instance of the abstract class 'MC'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(21,1): error TS2511: Cannot create an instance of the abstract class 'CI'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(22,5): error TS2304: Cannot find name 'IC'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(23,1): error TS2511: Cannot create an instance of the abstract class 'CC1'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts (13 errors) ==== + abstract class CM {} + module CM {} + + module MC {} + abstract class MC {} + + abstract class CI {} + ~~ +!!! error TS2300: Duplicate identifier 'CI'. + interface CI {} + ~~ +!!! error TS2300: Duplicate identifier 'CI'. + + interface IC {} + ~~ +!!! error TS2300: Duplicate identifier 'IC'. + abstract class IC {} + ~~ +!!! error TS2300: Duplicate identifier 'IC'. + + abstract class CC1 {} + ~~~ +!!! error TS2300: Duplicate identifier 'CC1'. + class CC1 {} + ~~~ +!!! error TS2300: Duplicate identifier 'CC1'. + + class CC2 {} + ~~~ +!!! error TS2300: Duplicate identifier 'CC2'. + abstract class CC2 {} + ~~~ +!!! error TS2300: Duplicate identifier 'CC2'. + + new CM; + ~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'CM'. + new MC; + ~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'MC'. + new CI; + ~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'CI'. + new IC; + ~~ +!!! error TS2304: Cannot find name 'IC'. + new CC1; + ~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'CC1'. + new CC2; \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractMergedDeclaration.js b/tests/baselines/reference/classAbstractMergedDeclaration.js new file mode 100644 index 00000000000..1b4d6fea342 --- /dev/null +++ b/tests/baselines/reference/classAbstractMergedDeclaration.js @@ -0,0 +1,73 @@ +//// [classAbstractMergedDeclaration.ts] +abstract class CM {} +module CM {} + +module MC {} +abstract class MC {} + +abstract class CI {} +interface CI {} + +interface IC {} +abstract class IC {} + +abstract class CC1 {} +class CC1 {} + +class CC2 {} +abstract class CC2 {} + +new CM; +new MC; +new CI; +new IC; +new CC1; +new CC2; + +//// [classAbstractMergedDeclaration.js] +var CM = (function () { + function CM() { + } + return CM; +})(); +var MC = (function () { + function MC() { + } + return MC; +})(); +var CI = (function () { + function CI() { + } + return CI; +})(); +var IC = (function () { + function IC() { + } + return IC; +})(); +var CC1 = (function () { + function CC1() { + } + return CC1; +})(); +var CC1 = (function () { + function CC1() { + } + return CC1; +})(); +var CC2 = (function () { + function CC2() { + } + return CC2; +})(); +var CC2 = (function () { + function CC2() { + } + return CC2; +})(); +new CM; +new MC; +new CI; +new IC; +new CC1; +new CC2; From 27ebd5c74961fdb86582653d2648cc86becc09f9 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 14:47:56 -0700 Subject: [PATCH 285/309] removed a prototype --- src/compiler/checker.ts | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 54bdbe4c443..6110bcd4135 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -14340,12 +14340,6 @@ namespace ts { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract"); } } - else { - // mark the constructor abstract for static-side assignability restrictions. - - // (node).members.????; - - } flags |= NodeFlags.Abstract; break; From f465d99492db1d328a42a9b93c1e955cdaa540b3 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Wed, 1 Jul 2015 15:00:06 -0700 Subject: [PATCH 286/309] Fix attribute completion following JSX exprs --- src/services/services.ts | 69 ++++++++++++------- .../incrementalParsingInsertIntoMethod1.ts | 1 - ...yntacticClassificationsConflictMarkers1.ts | 2 +- tests/cases/fourslash/tsxCompletion3.ts | 13 ++++ 4 files changed, 60 insertions(+), 25 deletions(-) create mode 100644 tests/cases/fourslash/tsxCompletion3.ts diff --git a/src/services/services.ts b/src/services/services.ts index 018a11fc4bb..c193b53582b 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -3009,6 +3009,7 @@ namespace ts { function tryGetGlobalSymbols(): boolean { let objectLikeContainer = tryGetObjectLikeCompletionContainer(contextToken); + let jsxContainer = tryGetContainingJsxElement(contextToken); if (objectLikeContainer) { // Object literal expression, look up possible property names from contextual type isMemberCompletion = true; @@ -3059,30 +3060,22 @@ namespace ts { } return true; } - else if (getAncestor(contextToken, SyntaxKind.JsxElement) || getAncestor(contextToken, SyntaxKind.JsxSelfClosingElement)) { - // Go up until we hit either the element or expression - let jsxNode = contextToken; + else if(jsxContainer) { + let attrsType: Type; + if (jsxContainer.kind === SyntaxKind.JsxSelfClosingElement) { + // Cursor is inside a JSX self-closing element + attrsType = typeChecker.getJsxElementAttributesType(jsxContainer); + } + else if(jsxContainer.kind === SyntaxKind.JsxOpeningElement) { + // Cursor is inside a JSX element + attrsType = typeChecker.getJsxElementAttributesType(jsxContainer); + } - while (jsxNode) { - if (jsxNode.kind === SyntaxKind.JsxExpression) { - // Defer to global completion if we're inside an {expression} - break; - } else if (jsxNode.kind === SyntaxKind.JsxSelfClosingElement || jsxNode.kind === SyntaxKind.JsxElement) { - let attrsType: Type; - if (jsxNode.kind === SyntaxKind.JsxSelfClosingElement) { - // Cursor is inside a JSX self-closing element - attrsType = typeChecker.getJsxElementAttributesType(jsxNode); - } - else { - Debug.assert(jsxNode.kind === SyntaxKind.JsxElement); - // Cursor is inside a JSX element - attrsType = typeChecker.getJsxElementAttributesType((jsxNode).openingElement); - } - symbols = typeChecker.getPropertiesOfType(attrsType); - isMemberCompletion = true; - return true; - } - jsxNode = jsxNode.parent; + if (attrsType) { + symbols = typeChecker.getPropertiesOfType(attrsType); + isMemberCompletion = true; + isNewIdentifierLocation = false; + return true; } } @@ -3268,6 +3261,36 @@ namespace ts { return undefined; } + function tryGetContainingJsxElement(contextToken: Node): JsxOpeningLikeElement { + if (contextToken) { + let parent = contextToken.parent; + switch(contextToken.kind) { + case SyntaxKind.LessThanSlashToken: + case SyntaxKind.SlashToken: + case SyntaxKind.Identifier: + if(parent && (parent.kind === SyntaxKind.JsxSelfClosingElement || parent.kind === SyntaxKind.JsxOpeningElement)) { + return parent; + } + break; + + case SyntaxKind.CloseBraceToken: + // The context token is the closing } of an attribute, which means + // its parent is a JsxExpression, whose parent is a JsxAttribute, + // whose parent is a JsxOpeningLikeElement + if(parent && + parent.kind === SyntaxKind.JsxExpression && + parent.parent && + parent.parent.kind === SyntaxKind.JsxAttribute) { + + return parent.parent.parent; + } + + break; + } + } + return undefined; + } + function isFunction(kind: SyntaxKind): boolean { switch (kind) { case SyntaxKind.FunctionExpression: diff --git a/tests/cases/fourslash/incrementalParsingInsertIntoMethod1.ts b/tests/cases/fourslash/incrementalParsingInsertIntoMethod1.ts index 930c0511ffb..b5deb361056 100644 --- a/tests/cases/fourslash/incrementalParsingInsertIntoMethod1.ts +++ b/tests/cases/fourslash/incrementalParsingInsertIntoMethod1.ts @@ -8,6 +8,5 @@ //// public foo3() { } ////} -debugger; goTo.marker("1"); edit.insert(" + 1"); \ No newline at end of file diff --git a/tests/cases/fourslash/syntacticClassificationsConflictMarkers1.ts b/tests/cases/fourslash/syntacticClassificationsConflictMarkers1.ts index e381856c41e..7f26038c33e 100644 --- a/tests/cases/fourslash/syntacticClassificationsConflictMarkers1.ts +++ b/tests/cases/fourslash/syntacticClassificationsConflictMarkers1.ts @@ -7,7 +7,7 @@ //// v = 2; ////>>>>>>> Branch - a ////} -debugger; + var c = classification; verify.syntacticClassificationsAre( c.keyword("class"), c.className("C"), c.punctuation("{"), diff --git a/tests/cases/fourslash/tsxCompletion3.ts b/tests/cases/fourslash/tsxCompletion3.ts new file mode 100644 index 00000000000..2d87d7ed056 --- /dev/null +++ b/tests/cases/fourslash/tsxCompletion3.ts @@ -0,0 +1,13 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// div: { one; two; } +//// } +//// } +////
; + +goTo.marker(); +verify.completionListContains('two'); From a0bd465a7d2df6cc68f1d689a0bb6431563b4def Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 15:31:14 -0700 Subject: [PATCH 287/309] Appeasing Jason --- src/compiler/checker.ts | 127 ++++++++++++++++++++-------------------- 1 file changed, 64 insertions(+), 63 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6110bcd4135..c408b3efc28 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -106,7 +106,7 @@ namespace ts { let globals: SymbolTable = {}; let globalESSymbolConstructorSymbol: Symbol; - + let getGlobalPromiseConstructorSymbol: () => Symbol; let globalObjectType: ObjectType; @@ -137,7 +137,7 @@ namespace ts { let getInstantiatedGlobalPromiseLikeType: () => ObjectType; let getGlobalPromiseConstructorLikeType: () => ObjectType; let getGlobalThenableType: () => ObjectType; - + let tupleTypes: Map = {}; let unionTypes: Map = {}; let stringLiteralTypes: Map = {}; @@ -146,7 +146,7 @@ namespace ts { let emitParam = false; let emitAwaiter = false; let emitGenerator = false; - + let resolutionTargets: Object[] = []; let resolutionResults: boolean[] = []; @@ -3747,12 +3747,12 @@ namespace ts { // We only support expressions that are simple qualified names. For other expressions this produces undefined. let typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (node).typeName : isSupportedExpressionWithTypeArguments(node) ? (node).expression : - undefined; + undefined; let symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol; let type = symbol === unknownSymbol ? unknownType : symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) : - symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : - getTypeFromNonGenericTypeReference(node, symbol); + symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the // type reference in checkTypeReferenceOrExpressionWithTypeArguments. links.resolvedSymbol = symbol; @@ -3817,7 +3817,7 @@ namespace ts { function getGlobalType(name: string, arity = 0): ObjectType { return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), arity); } - + function tryGetGlobalType(name: string, arity = 0): ObjectType { return getTypeOfGlobalSymbol(getGlobalSymbol(name, SymbolFlags.Type, /*diagnostic*/ undefined), arity); } @@ -4036,7 +4036,7 @@ namespace ts { } return links.resolvedType; } - + function getTypeFromTypeNode(node: TypeNode): Type { switch (node.kind) { case SyntaxKind.AnyKeyword: @@ -5928,7 +5928,7 @@ namespace ts { error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); } } - + if (node.parserContextFlags & ParserContextFlags.Await) { getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments; getNodeLinks(node).flags |= NodeCheckFlags.LexicalArguments; @@ -7244,7 +7244,8 @@ namespace ts { let declaringClass = getDeclaredTypeOfSymbol(prop.parent);; if (left.kind === SyntaxKind.SuperKeyword) { - let errorNode = node.kind === SyntaxKind.PropertyAccessExpression ? (node).name : + let errorNode = node.kind === SyntaxKind.PropertyAccessExpression ? + (node).name : (node).right; // TS 1.0 spec (April 2014): 4.8.2 @@ -7343,7 +7344,7 @@ namespace ts { } return unknownType; } - + getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & SymbolFlags.Class) { @@ -8661,7 +8662,7 @@ namespace ts { links.type = instantiateType(getTypeOfSymbol(lastOrUndefined(context.parameters)), mapper); } } - + function createPromiseType(promisedType: Type): Type { // creates a `Promise` type where `T` is the promisedType argument let globalPromiseType = getGlobalPromiseType(); @@ -8670,7 +8671,7 @@ namespace ts { promisedType = getAwaitedType(promisedType); return createTypeReference(globalPromiseType, [promisedType]); } - + return emptyObjectType; } @@ -8679,11 +8680,11 @@ namespace ts { if (!func.body) { return unknownType; } - + let isAsync = isAsyncFunctionLike(func); let type: Type; if (func.body.kind !== SyntaxKind.Block) { - type = checkExpressionCached(func.body, contextualMapper); + type = checkExpressionCached(func.body, contextualMapper); if (isAsync) { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so the @@ -8716,13 +8717,13 @@ namespace ts { error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); return unknownType; } - + return promiseType; } else { return voidType; } - } + } } // When yield/return statements are contextually typed we allow the return type to be a union type. // Otherwise we require the yield/return expressions to have a best common supertype. @@ -8745,7 +8746,7 @@ namespace ts { if (!contextualSignature) { reportErrorsFromWidening(func, type); } - + let widenedType = getWidenedType(type); if (isAsync) { // From within an async function you can return either a non-promise value or a promise. Any @@ -8756,8 +8757,8 @@ namespace ts { error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); return unknownType; } - - return promiseType; + + return promiseType; } else { return widenedType; @@ -8792,13 +8793,13 @@ namespace ts { forEachReturnStatement(body, returnStatement => { let expr = returnStatement.expression; if (expr) { - let type = checkExpressionCached(expr, contextualMapper); + let type = checkExpressionCached(expr, contextualMapper); if (isAsync) { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so the // return type of the body should be unwrapped to its awaited type, which should be wrapped in // the native Promise type by the caller. - type = checkAwaitedType(type, body.parent, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + type = checkAwaitedType(type, body.parent, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); } if (!contains(aggregatedTypes, type)) { @@ -8870,12 +8871,12 @@ namespace ts { if (contextualMapper === identityMapper && isContextSensitive(node)) { return anyFunctionType; } - + let isAsync = isAsyncFunctionLike(node); if (isAsync) { emitAwaiter = true; } - + let links = getNodeLinks(node); let type = getTypeOfSymbol(node.symbol); // Check if function expression is contextually typed and assign parameter types if so @@ -8912,7 +8913,7 @@ namespace ts { function checkFunctionExpressionOrObjectLiteralMethodBody(node: FunctionExpression | MethodDeclaration) { Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node)); - + let isAsync = isAsyncFunctionLike(node); if (isAsync) { emitAwaiter = true; @@ -8923,7 +8924,7 @@ namespace ts { if (returnType && isAsync) { promisedType = checkAsyncFunctionReturnType(node); } - + if (returnType && !node.asteriskToken) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); } @@ -8957,7 +8958,7 @@ namespace ts { checkTypeAssignableTo(exprType, returnType, node.body); } } - + checkFunctionAndClassExpressionBodies(node.body); } } @@ -9079,7 +9080,7 @@ namespace ts { let operandType = checkExpression(node.expression); return checkAwaitedType(operandType, node); } - + function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type { let operandType = checkExpression(node.operand); switch (node.operator) { @@ -9552,7 +9553,7 @@ namespace ts { node.contextualType = saveContextualType; return result; } - + function checkExpressionCached(node: Expression, contextualMapper?: TypeMapper): Type { let links = getNodeLinks(node); if (!links.resolvedType) { @@ -9980,7 +9981,7 @@ namespace ts { // Abstract methods cannot have an implementation. // Extra checks are to avoid reporting multiple errors relating to the "abstractness" of the node. - if(node.flags & NodeFlags.Abstract && node.body) { + if (node.flags & NodeFlags.Abstract && node.body) { error(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name)); } } @@ -10412,8 +10413,8 @@ namespace ts { } // Abstract methods can't have an implementation -- in particular, they don't need one. - if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && - !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract) ) { + if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && + !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract)) { reportImplementationExpectedError(lastSeenNonAmbientDeclaration); } @@ -10530,13 +10531,13 @@ namespace ts { if (!message) { message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; } - + error(location, message); } - + return unknownType; } - + return type; } @@ -10559,11 +10560,11 @@ namespace ts { if (promise.flags & TypeFlags.Any) { return undefined; } - + if ((promise.flags & TypeFlags.Reference) && (promise).target === tryGetGlobalPromiseType()) { return (promise).typeArguments[0]; } - + let globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType(); if (globalPromiseLikeType === emptyObjectType || !isTypeAssignableTo(promise, globalPromiseLikeType)) { return undefined; @@ -10573,26 +10574,26 @@ namespace ts { if (thenFunction && (thenFunction.flags & TypeFlags.Any)) { return undefined; } - + let thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, SignatureKind.Call) : emptyArray; if (thenSignatures.length === 0) { return undefined; } - + let onfulfilledParameterType = getUnionType(map(thenSignatures, getTypeOfFirstParameterOfSignature)); if (onfulfilledParameterType.flags & TypeFlags.Any) { return undefined; } - + let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call); if (onfulfilledParameterSignatures.length === 0) { return undefined; } - + let valueParameterType = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature)); return valueParameterType; } - + function getTypeOfFirstParameterOfSignature(signature: Signature) { return getTypeAtPosition(signature, 0); } @@ -10607,17 +10608,17 @@ namespace ts { function getAwaitedType(type: Type) { return checkAwaitedType(type, /*location*/ undefined, /*message*/ undefined); } - + function checkAwaitedType(type: Type, location?: Node, message?: DiagnosticMessage) { return checkAwaitedTypeWorker(type); - + function checkAwaitedTypeWorker(type: Type): Type { if (type.flags & TypeFlags.Union) { let types: Type[] = []; for (let constituentType of (type).types) { types.push(checkAwaitedTypeWorker(constituentType)); } - + return getUnionType(types); } else { @@ -10677,11 +10678,11 @@ namespace ts { // if (location) { error( - location, - Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, + location, + Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, symbolToString(type.symbol)); } - + return unknownType; } @@ -10690,7 +10691,7 @@ namespace ts { awaitedTypeStack.push(type.id); let awaitedType = checkAwaitedTypeWorker(promisedType); awaitedTypeStack.pop(); - return awaitedType; + return awaitedType; } } } @@ -10750,7 +10751,7 @@ namespace ts { // type as a value. As such, we will just return unknownType; return unknownType; } - + let promiseConstructor = getMergedSymbol(promiseType.symbol); if (!promiseConstructor || !symbolIsValue(promiseConstructor)) { error(node, Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType)); @@ -10942,7 +10943,7 @@ namespace ts { if (!compilerOptions.experimentalAsyncFunctions) { error(node, Diagnostics.Experimental_support_for_async_functions_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalAsyncFunctions_to_remove_this_warning); } - + emitAwaiter = true; } @@ -10984,7 +10985,7 @@ namespace ts { if (isAsync) { promisedType = checkAsyncFunctionReturnType(node); } - + checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); } @@ -11317,7 +11318,7 @@ namespace ts { if (inBlockOrObjectLiteralExpression(node)) { if (isAsyncFunctionLike(node)) { if (node.modifiers.length > 1) { - return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); + return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); } } else { @@ -11335,7 +11336,7 @@ namespace ts { node = node.parent; } - + return false; } @@ -12160,7 +12161,7 @@ namespace ts { // It is an error to inherit an abstract member without implementing it or being declared abstract. // If there is no declaration for the derived class (as in the case of class expressions), // then the class cannot be declared abstract. - if ( baseDeclarationFlags & NodeFlags.Abstract && (!derivedClassDecl || !(derivedClassDecl.flags & NodeFlags.Abstract))) { + if (baseDeclarationFlags & NodeFlags.Abstract && (!derivedClassDecl || !(derivedClassDecl.flags & NodeFlags.Abstract))) { error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, typeToString(type), symbolToString(baseProperty), typeToString(baseType)); } @@ -13142,7 +13143,7 @@ namespace ts { forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope); potentialThisCollisions.length = 0; } - + if (emitExtends) { links.flags |= NodeCheckFlags.EmitExtends; } @@ -13154,11 +13155,11 @@ namespace ts { if (emitParam) { links.flags |= NodeCheckFlags.EmitParam; } - + if (emitAwaiter) { links.flags |= NodeCheckFlags.EmitAwaiter; } - + if (emitGenerator || (emitAwaiter && languageVersion < ScriptTarget.ES6)) { links.flags |= NodeCheckFlags.EmitGenerator; } @@ -13454,7 +13455,7 @@ namespace ts { (node.parent).moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } - // Fall through + // Fall through case SyntaxKind.NumericLiteral: // index access @@ -14129,21 +14130,21 @@ namespace ts { anyArrayType = createArrayType(anyType); } - + function createInstantiatedPromiseLikeType(): ObjectType { let promiseLikeType = getGlobalPromiseLikeType(); if (promiseLikeType !== emptyObjectType) { return createTypeReference(promiseLikeType, [anyType]); } - + return emptyObjectType; } - + function createThenableType() { // build the thenable type that is used to verify against a non-promise "thenable" operand to `await`. let thenPropertySymbol = createSymbol(SymbolFlags.Transient | SymbolFlags.Property, "then"); getSymbolLinks(thenPropertySymbol).type = globalFunctionType; - + let thenableType = createObjectType(TypeFlags.Anonymous); thenableType.properties = [thenPropertySymbol]; thenableType.members = createSymbolTable(thenableType.properties); From 07142a4ec231d56b059d87405f153a6499de65a9 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 15:37:42 -0700 Subject: [PATCH 288/309] Revert "Appeasing Jason" This reverts commit a0bd465a7d2df6cc68f1d689a0bb6431563b4def. --- src/compiler/checker.ts | 127 ++++++++++++++++++++-------------------- 1 file changed, 63 insertions(+), 64 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c408b3efc28..6110bcd4135 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -106,7 +106,7 @@ namespace ts { let globals: SymbolTable = {}; let globalESSymbolConstructorSymbol: Symbol; - + let getGlobalPromiseConstructorSymbol: () => Symbol; let globalObjectType: ObjectType; @@ -137,7 +137,7 @@ namespace ts { let getInstantiatedGlobalPromiseLikeType: () => ObjectType; let getGlobalPromiseConstructorLikeType: () => ObjectType; let getGlobalThenableType: () => ObjectType; - + let tupleTypes: Map = {}; let unionTypes: Map = {}; let stringLiteralTypes: Map = {}; @@ -146,7 +146,7 @@ namespace ts { let emitParam = false; let emitAwaiter = false; let emitGenerator = false; - + let resolutionTargets: Object[] = []; let resolutionResults: boolean[] = []; @@ -3747,12 +3747,12 @@ namespace ts { // We only support expressions that are simple qualified names. For other expressions this produces undefined. let typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (node).typeName : isSupportedExpressionWithTypeArguments(node) ? (node).expression : - undefined; + undefined; let symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol; let type = symbol === unknownSymbol ? unknownType : symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) : - symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : - getTypeFromNonGenericTypeReference(node, symbol); + symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) : + getTypeFromNonGenericTypeReference(node, symbol); // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the // type reference in checkTypeReferenceOrExpressionWithTypeArguments. links.resolvedSymbol = symbol; @@ -3817,7 +3817,7 @@ namespace ts { function getGlobalType(name: string, arity = 0): ObjectType { return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), arity); } - + function tryGetGlobalType(name: string, arity = 0): ObjectType { return getTypeOfGlobalSymbol(getGlobalSymbol(name, SymbolFlags.Type, /*diagnostic*/ undefined), arity); } @@ -4036,7 +4036,7 @@ namespace ts { } return links.resolvedType; } - + function getTypeFromTypeNode(node: TypeNode): Type { switch (node.kind) { case SyntaxKind.AnyKeyword: @@ -5928,7 +5928,7 @@ namespace ts { error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); } } - + if (node.parserContextFlags & ParserContextFlags.Await) { getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments; getNodeLinks(node).flags |= NodeCheckFlags.LexicalArguments; @@ -7244,8 +7244,7 @@ namespace ts { let declaringClass = getDeclaredTypeOfSymbol(prop.parent);; if (left.kind === SyntaxKind.SuperKeyword) { - let errorNode = node.kind === SyntaxKind.PropertyAccessExpression ? - (node).name : + let errorNode = node.kind === SyntaxKind.PropertyAccessExpression ? (node).name : (node).right; // TS 1.0 spec (April 2014): 4.8.2 @@ -7344,7 +7343,7 @@ namespace ts { } return unknownType; } - + getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & SymbolFlags.Class) { @@ -8662,7 +8661,7 @@ namespace ts { links.type = instantiateType(getTypeOfSymbol(lastOrUndefined(context.parameters)), mapper); } } - + function createPromiseType(promisedType: Type): Type { // creates a `Promise` type where `T` is the promisedType argument let globalPromiseType = getGlobalPromiseType(); @@ -8671,7 +8670,7 @@ namespace ts { promisedType = getAwaitedType(promisedType); return createTypeReference(globalPromiseType, [promisedType]); } - + return emptyObjectType; } @@ -8680,11 +8679,11 @@ namespace ts { if (!func.body) { return unknownType; } - + let isAsync = isAsyncFunctionLike(func); let type: Type; if (func.body.kind !== SyntaxKind.Block) { - type = checkExpressionCached(func.body, contextualMapper); + type = checkExpressionCached(func.body, contextualMapper); if (isAsync) { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so the @@ -8717,13 +8716,13 @@ namespace ts { error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); return unknownType; } - + return promiseType; } else { return voidType; } - } + } } // When yield/return statements are contextually typed we allow the return type to be a union type. // Otherwise we require the yield/return expressions to have a best common supertype. @@ -8746,7 +8745,7 @@ namespace ts { if (!contextualSignature) { reportErrorsFromWidening(func, type); } - + let widenedType = getWidenedType(type); if (isAsync) { // From within an async function you can return either a non-promise value or a promise. Any @@ -8757,8 +8756,8 @@ namespace ts { error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type); return unknownType; } - - return promiseType; + + return promiseType; } else { return widenedType; @@ -8793,13 +8792,13 @@ namespace ts { forEachReturnStatement(body, returnStatement => { let expr = returnStatement.expression; if (expr) { - let type = checkExpressionCached(expr, contextualMapper); + let type = checkExpressionCached(expr, contextualMapper); if (isAsync) { // From within an async function you can return either a non-promise value or a promise. Any // Promise/A+ compatible implementation will always assimilate any foreign promise, so the // return type of the body should be unwrapped to its awaited type, which should be wrapped in // the native Promise type by the caller. - type = checkAwaitedType(type, body.parent, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); + type = checkAwaitedType(type, body.parent, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); } if (!contains(aggregatedTypes, type)) { @@ -8871,12 +8870,12 @@ namespace ts { if (contextualMapper === identityMapper && isContextSensitive(node)) { return anyFunctionType; } - + let isAsync = isAsyncFunctionLike(node); if (isAsync) { emitAwaiter = true; } - + let links = getNodeLinks(node); let type = getTypeOfSymbol(node.symbol); // Check if function expression is contextually typed and assign parameter types if so @@ -8913,7 +8912,7 @@ namespace ts { function checkFunctionExpressionOrObjectLiteralMethodBody(node: FunctionExpression | MethodDeclaration) { Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node)); - + let isAsync = isAsyncFunctionLike(node); if (isAsync) { emitAwaiter = true; @@ -8924,7 +8923,7 @@ namespace ts { if (returnType && isAsync) { promisedType = checkAsyncFunctionReturnType(node); } - + if (returnType && !node.asteriskToken) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); } @@ -8958,7 +8957,7 @@ namespace ts { checkTypeAssignableTo(exprType, returnType, node.body); } } - + checkFunctionAndClassExpressionBodies(node.body); } } @@ -9080,7 +9079,7 @@ namespace ts { let operandType = checkExpression(node.expression); return checkAwaitedType(operandType, node); } - + function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type { let operandType = checkExpression(node.operand); switch (node.operator) { @@ -9553,7 +9552,7 @@ namespace ts { node.contextualType = saveContextualType; return result; } - + function checkExpressionCached(node: Expression, contextualMapper?: TypeMapper): Type { let links = getNodeLinks(node); if (!links.resolvedType) { @@ -9981,7 +9980,7 @@ namespace ts { // Abstract methods cannot have an implementation. // Extra checks are to avoid reporting multiple errors relating to the "abstractness" of the node. - if (node.flags & NodeFlags.Abstract && node.body) { + if(node.flags & NodeFlags.Abstract && node.body) { error(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name)); } } @@ -10413,8 +10412,8 @@ namespace ts { } // Abstract methods can't have an implementation -- in particular, they don't need one. - if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && - !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract)) { + if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && + !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract) ) { reportImplementationExpectedError(lastSeenNonAmbientDeclaration); } @@ -10531,13 +10530,13 @@ namespace ts { if (!message) { message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; } - + error(location, message); } - + return unknownType; } - + return type; } @@ -10560,11 +10559,11 @@ namespace ts { if (promise.flags & TypeFlags.Any) { return undefined; } - + if ((promise.flags & TypeFlags.Reference) && (promise).target === tryGetGlobalPromiseType()) { return (promise).typeArguments[0]; } - + let globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType(); if (globalPromiseLikeType === emptyObjectType || !isTypeAssignableTo(promise, globalPromiseLikeType)) { return undefined; @@ -10574,26 +10573,26 @@ namespace ts { if (thenFunction && (thenFunction.flags & TypeFlags.Any)) { return undefined; } - + let thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, SignatureKind.Call) : emptyArray; if (thenSignatures.length === 0) { return undefined; } - + let onfulfilledParameterType = getUnionType(map(thenSignatures, getTypeOfFirstParameterOfSignature)); if (onfulfilledParameterType.flags & TypeFlags.Any) { return undefined; } - + let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call); if (onfulfilledParameterSignatures.length === 0) { return undefined; } - + let valueParameterType = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature)); return valueParameterType; } - + function getTypeOfFirstParameterOfSignature(signature: Signature) { return getTypeAtPosition(signature, 0); } @@ -10608,17 +10607,17 @@ namespace ts { function getAwaitedType(type: Type) { return checkAwaitedType(type, /*location*/ undefined, /*message*/ undefined); } - + function checkAwaitedType(type: Type, location?: Node, message?: DiagnosticMessage) { return checkAwaitedTypeWorker(type); - + function checkAwaitedTypeWorker(type: Type): Type { if (type.flags & TypeFlags.Union) { let types: Type[] = []; for (let constituentType of (type).types) { types.push(checkAwaitedTypeWorker(constituentType)); } - + return getUnionType(types); } else { @@ -10678,11 +10677,11 @@ namespace ts { // if (location) { error( - location, - Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, + location, + Diagnostics._0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method, symbolToString(type.symbol)); } - + return unknownType; } @@ -10691,7 +10690,7 @@ namespace ts { awaitedTypeStack.push(type.id); let awaitedType = checkAwaitedTypeWorker(promisedType); awaitedTypeStack.pop(); - return awaitedType; + return awaitedType; } } } @@ -10751,7 +10750,7 @@ namespace ts { // type as a value. As such, we will just return unknownType; return unknownType; } - + let promiseConstructor = getMergedSymbol(promiseType.symbol); if (!promiseConstructor || !symbolIsValue(promiseConstructor)) { error(node, Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType)); @@ -10943,7 +10942,7 @@ namespace ts { if (!compilerOptions.experimentalAsyncFunctions) { error(node, Diagnostics.Experimental_support_for_async_functions_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalAsyncFunctions_to_remove_this_warning); } - + emitAwaiter = true; } @@ -10985,7 +10984,7 @@ namespace ts { if (isAsync) { promisedType = checkAsyncFunctionReturnType(node); } - + checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); } @@ -11318,7 +11317,7 @@ namespace ts { if (inBlockOrObjectLiteralExpression(node)) { if (isAsyncFunctionLike(node)) { if (node.modifiers.length > 1) { - return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); + return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); } } else { @@ -11336,7 +11335,7 @@ namespace ts { node = node.parent; } - + return false; } @@ -12161,7 +12160,7 @@ namespace ts { // It is an error to inherit an abstract member without implementing it or being declared abstract. // If there is no declaration for the derived class (as in the case of class expressions), // then the class cannot be declared abstract. - if (baseDeclarationFlags & NodeFlags.Abstract && (!derivedClassDecl || !(derivedClassDecl.flags & NodeFlags.Abstract))) { + if ( baseDeclarationFlags & NodeFlags.Abstract && (!derivedClassDecl || !(derivedClassDecl.flags & NodeFlags.Abstract))) { error(derivedClassDecl, Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, typeToString(type), symbolToString(baseProperty), typeToString(baseType)); } @@ -13143,7 +13142,7 @@ namespace ts { forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope); potentialThisCollisions.length = 0; } - + if (emitExtends) { links.flags |= NodeCheckFlags.EmitExtends; } @@ -13155,11 +13154,11 @@ namespace ts { if (emitParam) { links.flags |= NodeCheckFlags.EmitParam; } - + if (emitAwaiter) { links.flags |= NodeCheckFlags.EmitAwaiter; } - + if (emitGenerator || (emitAwaiter && languageVersion < ScriptTarget.ES6)) { links.flags |= NodeCheckFlags.EmitGenerator; } @@ -13455,7 +13454,7 @@ namespace ts { (node.parent).moduleSpecifier === node)) { return resolveExternalModuleName(node, node); } - // Fall through + // Fall through case SyntaxKind.NumericLiteral: // index access @@ -14130,21 +14129,21 @@ namespace ts { anyArrayType = createArrayType(anyType); } - + function createInstantiatedPromiseLikeType(): ObjectType { let promiseLikeType = getGlobalPromiseLikeType(); if (promiseLikeType !== emptyObjectType) { return createTypeReference(promiseLikeType, [anyType]); } - + return emptyObjectType; } - + function createThenableType() { // build the thenable type that is used to verify against a non-promise "thenable" operand to `await`. let thenPropertySymbol = createSymbol(SymbolFlags.Transient | SymbolFlags.Property, "then"); getSymbolLinks(thenPropertySymbol).type = globalFunctionType; - + let thenableType = createObjectType(TypeFlags.Anonymous); thenableType.properties = [thenPropertySymbol]; thenableType.members = createSymbolTable(thenableType.properties); From f3b1321f56bebdc9175d7eaf408661f999fcdca1 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 15:39:06 -0700 Subject: [PATCH 289/309] Appeasing Jason lite --- src/compiler/checker.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6110bcd4135..84cc67d3a02 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7244,7 +7244,8 @@ namespace ts { let declaringClass = getDeclaredTypeOfSymbol(prop.parent);; if (left.kind === SyntaxKind.SuperKeyword) { - let errorNode = node.kind === SyntaxKind.PropertyAccessExpression ? (node).name : + let errorNode = node.kind === SyntaxKind.PropertyAccessExpression ? + (node).name : (node).right; // TS 1.0 spec (April 2014): 4.8.2 From ef765e56dfa2a2668bb55b46405ecef11f6612f5 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Wed, 1 Jul 2015 16:04:29 -0700 Subject: [PATCH 290/309] Filter out would-be-duplicate names from JSX attribute completion --- src/services/services.ts | 39 ++++++++++++++++--------- tests/cases/fourslash/tsxCompletion3.ts | 1 + 2 files changed, 27 insertions(+), 13 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index c193b53582b..395bd41ac92 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -3062,20 +3062,17 @@ namespace ts { } else if(jsxContainer) { let attrsType: Type; - if (jsxContainer.kind === SyntaxKind.JsxSelfClosingElement) { - // Cursor is inside a JSX self-closing element - attrsType = typeChecker.getJsxElementAttributesType(jsxContainer); - } - else if(jsxContainer.kind === SyntaxKind.JsxOpeningElement) { - // Cursor is inside a JSX element - attrsType = typeChecker.getJsxElementAttributesType(jsxContainer); - } + if ((jsxContainer.kind === SyntaxKind.JsxSelfClosingElement) || (jsxContainer.kind === SyntaxKind.JsxOpeningElement)) { + // Cursor is inside a JSX self-closing element or opening element + attrsType = typeChecker.getJsxElementAttributesType(jsxContainer); + + if (attrsType) { + symbols = filterJsxAttributes((jsxContainer).attributes, typeChecker.getPropertiesOfType(attrsType)); + isMemberCompletion = true; + isNewIdentifierLocation = false; + return true; + } - if (attrsType) { - symbols = typeChecker.getPropertiesOfType(attrsType); - isMemberCompletion = true; - isNewIdentifierLocation = false; - return true; } } @@ -3476,6 +3473,22 @@ namespace ts { } } + function filterJsxAttributes(attributes: NodeArray, symbols: Symbol[]): Symbol[] { + let seenNames: Map = {}; + for(let attr of attributes) { + if(attr.kind === SyntaxKind.JsxAttribute) { + seenNames[(attr).name.text] = true; + } + } + let result: Symbol[] = []; + for(let sym of symbols) { + if(!seenNames[sym.name]) { + result.push(sym); + } + } + return result; + } + function getCompletionsAtPosition(fileName: string, position: number): CompletionInfo { synchronizeHostData(); diff --git a/tests/cases/fourslash/tsxCompletion3.ts b/tests/cases/fourslash/tsxCompletion3.ts index 2d87d7ed056..5ee712f7e96 100644 --- a/tests/cases/fourslash/tsxCompletion3.ts +++ b/tests/cases/fourslash/tsxCompletion3.ts @@ -11,3 +11,4 @@ goTo.marker(); verify.completionListContains('two'); +verify.not.completionListContains('one'); From 6d0c7c9f6a80f020a8cde9f594855327ee154ce7 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Wed, 1 Jul 2015 16:14:46 -0700 Subject: [PATCH 291/309] removed a comment --- src/compiler/checker.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 84cc67d3a02..d72e74f748e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12156,7 +12156,6 @@ namespace ts { // derived class inherits base without override/redeclaration let derivedClassDecl = getDeclarationOfKind(type.symbol, SyntaxKind.ClassDeclaration); - // Debug.assert(derivedClassDecl !== undefined); // It is an error to inherit an abstract member without implementing it or being declared abstract. // If there is no declaration for the derived class (as in the case of class expressions), From 9bfdc289d90d30fb16e48c787666a7d12f9ab58d Mon Sep 17 00:00:00 2001 From: Zhengbo Li Date: Wed, 1 Jul 2015 16:22:34 -0700 Subject: [PATCH 292/309] Fix issue #3216 --- src/lib/dom.generated.d.ts | 75 ++++++++++---------------------- src/lib/webworker.generated.d.ts | 6 +-- 2 files changed, 25 insertions(+), 56 deletions(-) diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts index e1f06f11009..84e959caef8 100644 --- a/src/lib/dom.generated.d.ts +++ b/src/lib/dom.generated.d.ts @@ -1092,16 +1092,11 @@ interface CanvasRenderingContext2D { clearRect(x: number, y: number, w: number, h: number): void; clip(fillRule?: string): void; closePath(): void; - createImageData(imageDataOrSw: number, sh?: number): ImageData; - createImageData(imageDataOrSw: ImageData, sh?: number): ImageData; + createImageData(imageDataOrSw: number | ImageData, sh?: number): ImageData; createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient; - createPattern(image: HTMLImageElement, repetition: string): CanvasPattern; - createPattern(image: HTMLCanvasElement, repetition: string): CanvasPattern; - createPattern(image: HTMLVideoElement, repetition: string): CanvasPattern; + createPattern(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, repetition: string): CanvasPattern; createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient; - drawImage(image: HTMLImageElement, offsetX: number, offsetY: number, width?: number, height?: number, canvasOffsetX?: number, canvasOffsetY?: number, canvasImageWidth?: number, canvasImageHeight?: number): void; - drawImage(image: HTMLCanvasElement, offsetX: number, offsetY: number, width?: number, height?: number, canvasOffsetX?: number, canvasOffsetY?: number, canvasImageWidth?: number, canvasImageHeight?: number): void; - drawImage(image: HTMLVideoElement, offsetX: number, offsetY: number, width?: number, height?: number, canvasOffsetX?: number, canvasOffsetY?: number, canvasImageWidth?: number, canvasImageHeight?: number): void; + drawImage(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, offsetX: number, offsetY: number, width?: number, height?: number, canvasOffsetX?: number, canvasOffsetY?: number, canvasImageWidth?: number, canvasImageHeight?: number): void; fill(fillRule?: string): void; fillRect(x: number, y: number, w: number, h: number): void; fillText(text: string, x: number, y: number, maxWidth?: number): void; @@ -3370,8 +3365,7 @@ interface HTMLAreasCollection extends HTMLCollection { /** * Adds an element to the areas, controlRange, or options collection. */ - add(element: HTMLElement, before?: HTMLElement): void; - add(element: HTMLElement, before?: number): void; + add(element: HTMLElement, before?: HTMLElement | number): void; /** * Removes an element from the collection. */ @@ -6119,8 +6113,7 @@ interface HTMLSelectElement extends HTMLElement { * @param element Variant of type Number that specifies the index position in the collection where the element is placed. If no value is given, the method places the element at the end of the collection. * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection. */ - add(element: HTMLElement, before?: HTMLElement): void; - add(element: HTMLElement, before?: number): void; + add(element: HTMLElement, before?: HTMLElement | number): void; /** * Returns whether a form will validate when it is submitted, without having to submit it. */ @@ -10281,8 +10274,7 @@ interface Screen extends EventTarget { systemXDPI: number; systemYDPI: number; width: number; - msLockOrientation(orientations: string): boolean; - msLockOrientation(orientations: string[]): boolean; + msLockOrientation(orientations: string | string[]): boolean; msUnlockOrientation(): void; addEventListener(type: "MSOrientationChange", listener: (ev: Event) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; @@ -10354,8 +10346,7 @@ interface SourceBuffer extends EventTarget { updating: boolean; videoTracks: VideoTrackList; abort(): void; - appendBuffer(data: ArrayBuffer): void; - appendBuffer(data: ArrayBufferView): void; + appendBuffer(data: ArrayBuffer | ArrayBufferView): void; appendStream(stream: MSStream, maxSize?: number): void; remove(start: number, end: number): void; } @@ -10463,33 +10454,18 @@ declare var StyleSheetPageList: { } interface SubtleCrypto { - decrypt(algorithm: string, key: CryptoKey, data: ArrayBufferView): any; - decrypt(algorithm: Algorithm, key: CryptoKey, data: ArrayBufferView): any; - deriveBits(algorithm: string, baseKey: CryptoKey, length: number): any; - deriveBits(algorithm: Algorithm, baseKey: CryptoKey, length: number): any; - deriveKey(algorithm: string, baseKey: CryptoKey, derivedKeyType: string, extractable: boolean, keyUsages: string[]): any; - deriveKey(algorithm: string, baseKey: CryptoKey, derivedKeyType: Algorithm, extractable: boolean, keyUsages: string[]): any; - deriveKey(algorithm: Algorithm, baseKey: CryptoKey, derivedKeyType: string, extractable: boolean, keyUsages: string[]): any; - deriveKey(algorithm: Algorithm, baseKey: CryptoKey, derivedKeyType: Algorithm, extractable: boolean, keyUsages: string[]): any; - digest(algorithm: string, data: ArrayBufferView): any; - digest(algorithm: Algorithm, data: ArrayBufferView): any; - encrypt(algorithm: string, key: CryptoKey, data: ArrayBufferView): any; - encrypt(algorithm: Algorithm, key: CryptoKey, data: ArrayBufferView): any; + decrypt(algorithm: string | Algorithm, key: CryptoKey, data: ArrayBufferView): any; + deriveBits(algorithm: string | Algorithm, baseKey: CryptoKey, length: number): any; + deriveKey(algorithm: string | Algorithm, baseKey: CryptoKey, derivedKeyType: string | Algorithm, extractable: boolean, keyUsages: string[]): any; + digest(algorithm: string | Algorithm, data: ArrayBufferView): any; + encrypt(algorithm: string | Algorithm, key: CryptoKey, data: ArrayBufferView): any; exportKey(format: string, key: CryptoKey): any; - generateKey(algorithm: string, extractable: boolean, keyUsages: string[]): any; - generateKey(algorithm: Algorithm, extractable: boolean, keyUsages: string[]): any; - importKey(format: string, keyData: ArrayBufferView, algorithm: string, extractable: boolean, keyUsages: string[]): any; - importKey(format: string, keyData: ArrayBufferView, algorithm: Algorithm, extractable: boolean, keyUsages: string[]): any; - sign(algorithm: string, key: CryptoKey, data: ArrayBufferView): any; - sign(algorithm: Algorithm, key: CryptoKey, data: ArrayBufferView): any; - unwrapKey(format: string, wrappedKey: ArrayBufferView, unwrappingKey: CryptoKey, unwrapAlgorithm: string, unwrappedKeyAlgorithm: string, extractable: boolean, keyUsages: string[]): any; - unwrapKey(format: string, wrappedKey: ArrayBufferView, unwrappingKey: CryptoKey, unwrapAlgorithm: string, unwrappedKeyAlgorithm: Algorithm, extractable: boolean, keyUsages: string[]): any; - unwrapKey(format: string, wrappedKey: ArrayBufferView, unwrappingKey: CryptoKey, unwrapAlgorithm: Algorithm, unwrappedKeyAlgorithm: string, extractable: boolean, keyUsages: string[]): any; - unwrapKey(format: string, wrappedKey: ArrayBufferView, unwrappingKey: CryptoKey, unwrapAlgorithm: Algorithm, unwrappedKeyAlgorithm: Algorithm, extractable: boolean, keyUsages: string[]): any; - verify(algorithm: string, key: CryptoKey, signature: ArrayBufferView, data: ArrayBufferView): any; - verify(algorithm: Algorithm, key: CryptoKey, signature: ArrayBufferView, data: ArrayBufferView): any; - wrapKey(format: string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: string): any; - wrapKey(format: string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: Algorithm): any; + generateKey(algorithm: string | Algorithm, extractable: boolean, keyUsages: string[]): any; + importKey(format: string, keyData: ArrayBufferView, algorithm: string | Algorithm, extractable: boolean, keyUsages: string[]): any; + sign(algorithm: string | Algorithm, key: CryptoKey, data: ArrayBufferView): any; + unwrapKey(format: string, wrappedKey: ArrayBufferView, unwrappingKey: CryptoKey, unwrapAlgorithm: string | Algorithm, unwrappedKeyAlgorithm: string | Algorithm, extractable: boolean, keyUsages: string[]): any; + verify(algorithm: string | Algorithm, key: CryptoKey, signature: ArrayBufferView, data: ArrayBufferView): any; + wrapKey(format: string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: string | Algorithm): any; } declare var SubtleCrypto: { @@ -10998,11 +10974,8 @@ interface WebGLRenderingContext { blendEquationSeparate(modeRGB: number, modeAlpha: number): void; blendFunc(sfactor: number, dfactor: number): void; blendFuncSeparate(srcRGB: number, dstRGB: number, srcAlpha: number, dstAlpha: number): void; - bufferData(target: number, size: number, usage: number): void; - bufferData(target: number, size: ArrayBufferView, usage: number): void; - bufferData(target: number, size: any, usage: number): void; - bufferSubData(target: number, offset: number, data: ArrayBufferView): void; - bufferSubData(target: number, offset: number, data: any): void; + bufferData(target: number, size: number | ArrayBufferView | ArrayBuffer, usage: number): void; + bufferSubData(target: number, offset: number, data: ArrayBufferView | ArrayBuffer): void; checkFramebufferStatus(target: number): number; clear(mask: number): void; clearColor(red: number, green: number, blue: number, alpha: number): void; @@ -11845,8 +11818,7 @@ interface WebSocket extends EventTarget { declare var WebSocket: { prototype: WebSocket; - new(url: string, protocols?: string): WebSocket; - new(url: string, protocols?: any): WebSocket; + new(url: string, protocols?: string | string[]): WebSocket; CLOSED: number; CLOSING: number; CONNECTING: number; @@ -12650,8 +12622,7 @@ interface EventListenerObject { declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject; interface ErrorEventHandler { - (event: Event, source?: string, fileno?: number, columnNumber?: number): void; - (event: string, source?: string, fileno?: number, columnNumber?: number): void; + (event: Event | string, source?: string, fileno?: number, columnNumber?: number): void; } interface PositionCallback { (position: Position): void; @@ -12978,4 +12949,4 @@ declare function addEventListener(type: "unload", listener: (ev: Event) => any, declare function addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; declare function addEventListener(type: "wheel", listener: (ev: WheelEvent) => any, useCapture?: boolean): void; -declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; +declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; \ No newline at end of file diff --git a/src/lib/webworker.generated.d.ts b/src/lib/webworker.generated.d.ts index 1ab2c7d418f..5c41869e487 100644 --- a/src/lib/webworker.generated.d.ts +++ b/src/lib/webworker.generated.d.ts @@ -571,8 +571,7 @@ interface WebSocket extends EventTarget { declare var WebSocket: { prototype: WebSocket; - new(url: string, protocols?: string): WebSocket; - new(url: string, protocols?: any): WebSocket; + new(url: string, protocols?: string | string[]): WebSocket; CLOSED: number; CLOSING: number; CONNECTING: number; @@ -807,8 +806,7 @@ interface EventListenerObject { declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject; interface ErrorEventHandler { - (event: Event, source?: string, fileno?: number, columnNumber?: number): void; - (event: string, source?: string, fileno?: number, columnNumber?: number): void; + (event: Event | string, source?: string, fileno?: number, columnNumber?: number): void; } interface PositionCallback { (position: Position): void; From 06472035a4f045b437722e399065b81aa6e46d72 Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 2 Jul 2015 09:37:14 -0700 Subject: [PATCH 293/309] Prevent extra checks once abstract new-call detected --- src/compiler/checker.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d72e74f748e..b68dc3c2e6f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -8456,6 +8456,7 @@ namespace ts { let valueDecl = expressionType.symbol && getDeclarationOfKind(expressionType.symbol, SyntaxKind.ClassDeclaration); if (valueDecl && valueDecl.flags & NodeFlags.Abstract) { error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declarationNameToString(valueDecl.name)); + return resolveErrorCall(node); } // TS 1.0 spec: 4.11 From 61a9a64619b5dcc2fea871b5cbbe4c55a5fcbdef Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 2 Jul 2015 09:37:27 -0700 Subject: [PATCH 294/309] Added conformance test --- .../classAbstractKeyword/classAbstractInstantiations1.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts index c9ca4afb18d..4daf27b53e4 100644 --- a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts @@ -6,6 +6,7 @@ class B extends A {} abstract class C extends B {} new A; +new A(1); // should report 1 error new B; new C; From 233153149a6d974db3d35b31b64c9568bbdfd42d Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 2 Jul 2015 09:37:39 -0700 Subject: [PATCH 295/309] updated baselines --- .../reference/classAbstractInstantiations1.errors.txt | 8 ++++++-- tests/baselines/reference/classAbstractInstantiations1.js | 2 ++ 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/tests/baselines/reference/classAbstractInstantiations1.errors.txt b/tests/baselines/reference/classAbstractInstantiations1.errors.txt index 0221ce07f95..6171ef2efab 100644 --- a/tests/baselines/reference/classAbstractInstantiations1.errors.txt +++ b/tests/baselines/reference/classAbstractInstantiations1.errors.txt @@ -1,8 +1,9 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(8,1): error TS2511: Cannot create an instance of the abstract class 'A'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'C'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(9,1): error TS2511: Cannot create an instance of the abstract class 'A'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts(11,1): error TS2511: Cannot create an instance of the abstract class 'C'. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts (2 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations1.ts (3 errors) ==== abstract class A {} @@ -12,6 +13,9 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst new A; ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + new A(1); // should report 1 error + ~~~~~~~~ !!! error TS2511: Cannot create an instance of the abstract class 'A'. new B; new C; diff --git a/tests/baselines/reference/classAbstractInstantiations1.js b/tests/baselines/reference/classAbstractInstantiations1.js index 39e67542926..f3a0eecada9 100644 --- a/tests/baselines/reference/classAbstractInstantiations1.js +++ b/tests/baselines/reference/classAbstractInstantiations1.js @@ -7,6 +7,7 @@ class B extends A {} abstract class C extends B {} new A; +new A(1); // should report 1 error new B; new C; @@ -45,6 +46,7 @@ var C = (function (_super) { return C; })(B); new A; +new A(1); // should report 1 error new B; new C; var a; From c06e5eb8b493e377e44400aaa4307d00524ee4bf Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 2 Jul 2015 10:26:23 -0700 Subject: [PATCH 296/309] Update test --- .../classAbstractMergedDeclaration.ts | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts index 160c0de298b..6e5686feb25 100644 --- a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts +++ b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts @@ -16,9 +16,25 @@ class CC1 {} class CC2 {} abstract class CC2 {} +declare abstract class DCI {} +interface DCI {} + +interface DIC {} +declare abstract class DIC {} + +declare abstract class DCC1 {} +declare class DCC1 {} + +declare class DCC2 {} +declare abstract class DCC2 {} + new CM; new MC; new CI; new IC; new CC1; -new CC2; \ No newline at end of file +new CC2; +new DCI; +new DIC; +new DCC1; +new DCC2; \ No newline at end of file From 3af3177fe3bae91761611fa419aedaaf5842080e Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 2 Jul 2015 10:26:36 -0700 Subject: [PATCH 297/309] update baselines --- .../reference/augmentedTypesClass2.errors.txt | 8 +-- .../augmentedTypesInterface.errors.txt | 8 +-- .../classAbstractMergedDeclaration.errors.txt | 71 ++++++++++++++----- .../classAbstractMergedDeclaration.js | 22 +++++- .../classAndInterfaceWithSameName.errors.txt | 16 ++--- .../reference/clinterfaces.errors.txt | 32 ++++----- .../baselines/reference/declInput.errors.txt | 8 +-- ...ifiersAcrossContainerBoundaries.errors.txt | 8 +-- ...IdentifiersAcrossFileBoundaries.errors.txt | 16 ++--- .../interfaceDeclaration2.errors.txt | 8 +-- .../reference/mergedClassInterface.errors.txt | 16 ++--- .../reference/nameCollisions.errors.txt | 16 ++--- ...tringsArrayTypeDefinedInES5Mode.errors.txt | 4 +- ...ingsArrayTypeRedefinedInES6Mode.errors.txt | 4 +- 14 files changed, 147 insertions(+), 90 deletions(-) diff --git a/tests/baselines/reference/augmentedTypesClass2.errors.txt b/tests/baselines/reference/augmentedTypesClass2.errors.txt index da963c59d94..278dca816fa 100644 --- a/tests/baselines/reference/augmentedTypesClass2.errors.txt +++ b/tests/baselines/reference/augmentedTypesClass2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/augmentedTypesClass2.ts(4,7): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/augmentedTypesClass2.ts(10,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesClass2.ts(4,7): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesClass2.ts(10,11): error TS2518: Only an ambient class can be merged with an interface. tests/cases/compiler/augmentedTypesClass2.ts(16,7): error TS2300: Duplicate identifier 'c33'. tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate identifier 'c33'. @@ -10,7 +10,7 @@ tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate iden // class then interface class c11 { // error ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. foo() { return 1; } @@ -18,7 +18,7 @@ tests/cases/compiler/augmentedTypesClass2.ts(21,6): error TS2300: Duplicate iden interface c11 { // error ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. bar(): void; } diff --git a/tests/baselines/reference/augmentedTypesInterface.errors.txt b/tests/baselines/reference/augmentedTypesInterface.errors.txt index 44c47e70ab3..690bf8b7a99 100644 --- a/tests/baselines/reference/augmentedTypesInterface.errors.txt +++ b/tests/baselines/reference/augmentedTypesInterface.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/augmentedTypesInterface.ts(12,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/augmentedTypesInterface.ts(16,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesInterface.ts(12,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/augmentedTypesInterface.ts(16,7): error TS2518: Only an ambient class can be merged with an interface. tests/cases/compiler/augmentedTypesInterface.ts(23,11): error TS2300: Duplicate identifier 'i3'. tests/cases/compiler/augmentedTypesInterface.ts(26,6): error TS2300: Duplicate identifier 'i3'. @@ -18,13 +18,13 @@ tests/cases/compiler/augmentedTypesInterface.ts(26,6): error TS2300: Duplicate i // interface then class interface i2 { // error ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. foo(): void; } class i2 { // error ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. bar() { return 1; } diff --git a/tests/baselines/reference/classAbstractMergedDeclaration.errors.txt b/tests/baselines/reference/classAbstractMergedDeclaration.errors.txt index ca2cc3b8c2d..b3a2dec5e9c 100644 --- a/tests/baselines/reference/classAbstractMergedDeclaration.errors.txt +++ b/tests/baselines/reference/classAbstractMergedDeclaration.errors.txt @@ -1,19 +1,26 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(7,16): error TS2300: Duplicate identifier 'CI'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(8,11): error TS2300: Duplicate identifier 'CI'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(10,11): error TS2300: Duplicate identifier 'IC'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(11,16): error TS2300: Duplicate identifier 'IC'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(7,16): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(8,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(10,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(11,16): error TS2518: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(13,16): error TS2300: Duplicate identifier 'CC1'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(14,7): error TS2300: Duplicate identifier 'CC1'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(16,7): error TS2300: Duplicate identifier 'CC2'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(17,16): error TS2300: Duplicate identifier 'CC2'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(19,1): error TS2511: Cannot create an instance of the abstract class 'CM'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(20,1): error TS2511: Cannot create an instance of the abstract class 'MC'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(21,1): error TS2511: Cannot create an instance of the abstract class 'CI'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(22,5): error TS2304: Cannot find name 'IC'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(23,1): error TS2511: Cannot create an instance of the abstract class 'CC1'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(25,24): error TS2300: Duplicate identifier 'DCC1'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(26,15): error TS2300: Duplicate identifier 'DCC1'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(28,15): error TS2300: Duplicate identifier 'DCC2'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(29,24): error TS2300: Duplicate identifier 'DCC2'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(31,1): error TS2511: Cannot create an instance of the abstract class 'CM'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(32,1): error TS2511: Cannot create an instance of the abstract class 'MC'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(33,1): error TS2511: Cannot create an instance of the abstract class 'CI'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(34,1): error TS2511: Cannot create an instance of the abstract class 'IC'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(35,1): error TS2511: Cannot create an instance of the abstract class 'CC1'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(37,1): error TS2511: Cannot create an instance of the abstract class 'DCI'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(38,1): error TS2511: Cannot create an instance of the abstract class 'DIC'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts(39,1): error TS2511: Cannot create an instance of the abstract class 'DCC1'. -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts (13 errors) ==== +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMergedDeclaration.ts (20 errors) ==== abstract class CM {} module CM {} @@ -22,17 +29,17 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst abstract class CI {} ~~ -!!! error TS2300: Duplicate identifier 'CI'. +!!! error TS2518: Only an ambient class can be merged with an interface. interface CI {} ~~ -!!! error TS2300: Duplicate identifier 'CI'. +!!! error TS2518: Only an ambient class can be merged with an interface. interface IC {} ~~ -!!! error TS2300: Duplicate identifier 'IC'. +!!! error TS2518: Only an ambient class can be merged with an interface. abstract class IC {} ~~ -!!! error TS2300: Duplicate identifier 'IC'. +!!! error TS2518: Only an ambient class can be merged with an interface. abstract class CC1 {} ~~~ @@ -48,6 +55,26 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst ~~~ !!! error TS2300: Duplicate identifier 'CC2'. + declare abstract class DCI {} + interface DCI {} + + interface DIC {} + declare abstract class DIC {} + + declare abstract class DCC1 {} + ~~~~ +!!! error TS2300: Duplicate identifier 'DCC1'. + declare class DCC1 {} + ~~~~ +!!! error TS2300: Duplicate identifier 'DCC1'. + + declare class DCC2 {} + ~~~~ +!!! error TS2300: Duplicate identifier 'DCC2'. + declare abstract class DCC2 {} + ~~~~ +!!! error TS2300: Duplicate identifier 'DCC2'. + new CM; ~~~~~~ !!! error TS2511: Cannot create an instance of the abstract class 'CM'. @@ -58,9 +85,19 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst ~~~~~~ !!! error TS2511: Cannot create an instance of the abstract class 'CI'. new IC; - ~~ -!!! error TS2304: Cannot find name 'IC'. + ~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'IC'. new CC1; ~~~~~~~ !!! error TS2511: Cannot create an instance of the abstract class 'CC1'. - new CC2; \ No newline at end of file + new CC2; + new DCI; + ~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'DCI'. + new DIC; + ~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'DIC'. + new DCC1; + ~~~~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'DCC1'. + new DCC2; \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractMergedDeclaration.js b/tests/baselines/reference/classAbstractMergedDeclaration.js index 1b4d6fea342..f6a91f870d2 100644 --- a/tests/baselines/reference/classAbstractMergedDeclaration.js +++ b/tests/baselines/reference/classAbstractMergedDeclaration.js @@ -17,12 +17,28 @@ class CC1 {} class CC2 {} abstract class CC2 {} +declare abstract class DCI {} +interface DCI {} + +interface DIC {} +declare abstract class DIC {} + +declare abstract class DCC1 {} +declare class DCC1 {} + +declare class DCC2 {} +declare abstract class DCC2 {} + new CM; new MC; new CI; new IC; new CC1; -new CC2; +new CC2; +new DCI; +new DIC; +new DCC1; +new DCC2; //// [classAbstractMergedDeclaration.js] var CM = (function () { @@ -71,3 +87,7 @@ new CI; new IC; new CC1; new CC2; +new DCI; +new DIC; +new DCC1; +new DCC2; diff --git a/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt b/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt index b2b59c29009..332024b74fd 100644 --- a/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt +++ b/tests/baselines/reference/classAndInterfaceWithSameName.errors.txt @@ -1,29 +1,29 @@ -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,7): error TS2518: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(1,11): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,11): error TS2518: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(2,15): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(5,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(5,11): error TS2518: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(6,9): error TS2300: Duplicate identifier 'bar'. -tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(9,15): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(9,15): error TS2518: Only an ambient class can be merged with an interface. tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts(10,9): error TS2300: Duplicate identifier 'bar'. ==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName.ts (8 errors) ==== class C { foo: string; } ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. ~~~ !!! error TS2300: Duplicate identifier 'foo'. interface C { foo: string; } // error ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. ~~~ !!! error TS2300: Duplicate identifier 'foo'. module M { class D { ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. bar: string; ~~~ !!! error TS2300: Duplicate identifier 'bar'. @@ -31,7 +31,7 @@ tests/cases/conformance/classes/classDeclarations/classAndInterfaceWithSameName. interface D { // error ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. bar: string; ~~~ !!! error TS2300: Duplicate identifier 'bar'. diff --git a/tests/baselines/reference/clinterfaces.errors.txt b/tests/baselines/reference/clinterfaces.errors.txt index 8d48f29aed7..5960e6ae32b 100644 --- a/tests/baselines/reference/clinterfaces.errors.txt +++ b/tests/baselines/reference/clinterfaces.errors.txt @@ -1,50 +1,50 @@ -tests/cases/compiler/clinterfaces.ts(2,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(3,15): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(4,15): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(5,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(8,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(12,7): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(16,7): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/clinterfaces.ts(20,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(2,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(3,15): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(4,15): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(5,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(8,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(12,7): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(16,7): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/clinterfaces.ts(20,11): error TS2518: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/clinterfaces.ts (8 errors) ==== module M { class C { } ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface C { } ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface D { } ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. class D { } ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. } interface Foo { ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. a: string; } class Foo{ ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. b: number; } class Bar{ ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. b: number; } interface Bar { ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. a: string; } diff --git a/tests/baselines/reference/declInput.errors.txt b/tests/baselines/reference/declInput.errors.txt index 76257de6ea9..179db3598ab 100644 --- a/tests/baselines/reference/declInput.errors.txt +++ b/tests/baselines/reference/declInput.errors.txt @@ -1,17 +1,17 @@ -tests/cases/compiler/declInput.ts(1,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/declInput.ts(5,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/declInput.ts(1,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/declInput.ts(5,7): error TS2518: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/declInput.ts (2 errors) ==== interface bar { ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. } class bar { ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. public f() { return ''; } public g() { return {a: null, b: undefined, c: void 4 }; } public h(x = 4, y = null, z = '') { x++; } diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt index 67ee1d9cc37..731e9748203 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(2,22): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(5,18): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(2,22): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(5,18): error TS2518: Only an ambient class can be merged with an interface. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(9,21): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(12,18): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(37,12): error TS2300: Duplicate identifier 'x'. @@ -10,12 +10,12 @@ tests/cases/compiler/duplicateIdentifiersAcrossContainerBoundaries.ts(41,16): er module M { export interface I { } ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. } module M { export class I { } // error ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. } module M { diff --git a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt index c98e0e9a8c6..9867441f770 100644 --- a/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt +++ b/tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.errors.txt @@ -1,10 +1,10 @@ -tests/cases/compiler/file1.ts(2,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/file1.ts(3,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/file1.ts(2,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/file1.ts(3,7): error TS2518: Only an ambient class can be merged with an interface. tests/cases/compiler/file1.ts(4,7): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/file1.ts(5,10): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/file1.ts(9,12): error TS2300: Duplicate identifier 'x'. -tests/cases/compiler/file2.ts(1,7): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/file2.ts(2,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/file2.ts(1,7): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/file2.ts(2,11): error TS2518: Only an ambient class can be merged with an interface. tests/cases/compiler/file2.ts(3,10): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/file2.ts(4,7): error TS2300: Duplicate identifier 'f'. tests/cases/compiler/file2.ts(7,8): error TS2433: A namespace declaration cannot be in a different file from a class or function with which it is merged @@ -15,10 +15,10 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. interface I { } ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. class C1 { } ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. class C2 { } ~~ !!! error TS2300: Duplicate identifier 'C2'. @@ -42,10 +42,10 @@ tests/cases/compiler/file2.ts(8,16): error TS2300: Duplicate identifier 'x'. ==== tests/cases/compiler/file2.ts (6 errors) ==== class I { } // error -- cannot merge interface with non-ambient class ~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface C1 { } // error -- cannot merge interface with non-ambient class ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. function C2() { } // error -- cannot merge function with non-ambient class ~~ !!! error TS2300: Duplicate identifier 'C2'. diff --git a/tests/baselines/reference/interfaceDeclaration2.errors.txt b/tests/baselines/reference/interfaceDeclaration2.errors.txt index 1d5807b9b1b..db525e6f21f 100644 --- a/tests/baselines/reference/interfaceDeclaration2.errors.txt +++ b/tests/baselines/reference/interfaceDeclaration2.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/interfaceDeclaration2.ts(4,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/interfaceDeclaration2.ts(4,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2518: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/interfaceDeclaration2.ts (2 errors) ==== @@ -8,10 +8,10 @@ tests/cases/compiler/interfaceDeclaration2.ts(5,7): error TS2511: Only an ambien interface I2 { } ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. class I2 { } ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface I3 { } function I3() { } diff --git a/tests/baselines/reference/mergedClassInterface.errors.txt b/tests/baselines/reference/mergedClassInterface.errors.txt index 37bd595c0b7..5b23b046db7 100644 --- a/tests/baselines/reference/mergedClassInterface.errors.txt +++ b/tests/baselines/reference/mergedClassInterface.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/classes/classDeclarations/file1.ts(11,7): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/file1.ts(13,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/file1.ts(15,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(11,7): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(13,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(15,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2518: Only an ambient class can be merged with an interface. ==== tests/cases/conformance/classes/classDeclarations/file1.ts (4 errors) ==== @@ -17,19 +17,19 @@ tests/cases/conformance/classes/classDeclarations/file1.ts(17,7): error TS2511: class C3 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface C3 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface C4 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. class C4 { } // error -- cannot merge non-ambient class and interface ~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface C5 { x1: number; diff --git a/tests/baselines/reference/nameCollisions.errors.txt b/tests/baselines/reference/nameCollisions.errors.txt index 2aba1c43f86..5c32d464070 100644 --- a/tests/baselines/reference/nameCollisions.errors.txt +++ b/tests/baselines/reference/nameCollisions.errors.txt @@ -11,10 +11,10 @@ tests/cases/compiler/nameCollisions.ts(33,11): error TS2300: Duplicate identifie tests/cases/compiler/nameCollisions.ts(34,14): error TS2300: Duplicate identifier 'C'. tests/cases/compiler/nameCollisions.ts(36,14): error TS2300: Duplicate identifier 'C2'. tests/cases/compiler/nameCollisions.ts(37,11): error TS2300: Duplicate identifier 'C2'. -tests/cases/compiler/nameCollisions.ts(42,11): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/nameCollisions.ts(43,15): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/nameCollisions.ts(45,15): error TS2511: Only an ambient class can be merged with an interface. -tests/cases/compiler/nameCollisions.ts(46,11): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(42,11): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(43,15): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(45,15): error TS2518: Only an ambient class can be merged with an interface. +tests/cases/compiler/nameCollisions.ts(46,11): error TS2518: Only an ambient class can be merged with an interface. ==== tests/cases/compiler/nameCollisions.ts (17 errors) ==== @@ -87,15 +87,15 @@ tests/cases/compiler/nameCollisions.ts(46,11): error TS2511: Only an ambient cla class cli { } ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface cli { } // error ~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. interface cli2 { } ~~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. class cli2 { } // error ~~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. } \ No newline at end of file diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt index a51eb18d98e..69d686c3156 100644 --- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(2,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(2,7): error TS2518: Only an ambient class can be merged with an interface. tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. @@ -7,7 +7,7 @@ tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2 class TemplateStringsArray { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. } function f(x: TemplateStringsArray, y: number, z: number) { diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt index d41c3d0cdbf..02ccd7f2413 100644 --- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt +++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(2,7): error TS2511: Only an ambient class can be merged with an interface. +tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(2,7): error TS2518: Only an ambient class can be merged with an interface. tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'. Property 'raw' is missing in type '{}'. @@ -7,7 +7,7 @@ tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error T class TemplateStringsArray { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2511: Only an ambient class can be merged with an interface. +!!! error TS2518: Only an ambient class can be merged with an interface. } function f(x: TemplateStringsArray, y: number, z: number) { From e8a1f16e623cfabe593a765cf5f147ea94fb7e44 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 2 Jul 2015 12:20:20 -0700 Subject: [PATCH 298/309] Added tests for index signature completion builders. --- .../completionListInIndexSignature01.ts | 20 +++++++++++++++++++ .../completionListInIndexSignature02.ts | 19 ++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 tests/cases/fourslash/completionListInIndexSignature01.ts create mode 100644 tests/cases/fourslash/completionListInIndexSignature02.ts diff --git a/tests/cases/fourslash/completionListInIndexSignature01.ts b/tests/cases/fourslash/completionListInIndexSignature01.ts new file mode 100644 index 00000000000..2db28505b3e --- /dev/null +++ b/tests/cases/fourslash/completionListInIndexSignature01.ts @@ -0,0 +1,20 @@ +/// + +////interface I { +//// [/*1*/]: T; +//// [/*2*/]: T; +////} +//// +////class C { +//// [/*3*/]: string; +//// [str/*4*/: string]: number; +////} +//// +////type T = { +//// [x/*5*/yz: number]: boolean; +//// [/*6*/ + +for (let marker of test.markers()) { + goTo.position(marker.position); + verify.completionListAllowsNewIdentifier(); +} \ No newline at end of file diff --git a/tests/cases/fourslash/completionListInIndexSignature02.ts b/tests/cases/fourslash/completionListInIndexSignature02.ts new file mode 100644 index 00000000000..d3b65dc7759 --- /dev/null +++ b/tests/cases/fourslash/completionListInIndexSignature02.ts @@ -0,0 +1,19 @@ +/// + +////interface I { +//// [x: /*1*/]: T; +//// [: /*2*/]: T +////} +//// +////class C { +//// [a: /*3*/]: string; +//// [str: string/*4*/]: number; +////} +//// +////type T = { +//// [xyz: /*5*/ + +for (let marker of test.markers()) { + goTo.position(marker.position); + verify.not.completionListAllowsNewIdentifier(); +} \ No newline at end of file From 7abe8a155021df917f50509303c989ad2f264a55 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 2 Jul 2015 12:22:07 -0700 Subject: [PATCH 299/309] Add builder in computed properties and index signatures. --- src/services/services.ts | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index b3eb58bdcb3..159b1b817b1 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -3062,7 +3062,7 @@ namespace ts { } return true; } - else if(jsxContainer) { + else if (jsxContainer) { let attrsType: Type; if ((jsxContainer.kind === SyntaxKind.JsxSelfClosingElement) || (jsxContainer.kind === SyntaxKind.JsxOpeningElement)) { // Cursor is inside a JSX self-closing element or opening element @@ -3162,7 +3162,7 @@ namespace ts { switch (previousToken.kind) { case SyntaxKind.CommaToken: return containingNodeKind === SyntaxKind.CallExpression // func( a, | - || containingNodeKind === SyntaxKind.Constructor // constructor( a, | public, protected, private keywords are allowed here, so show completion + || containingNodeKind === SyntaxKind.Constructor // constructor( a, | /* public, protected, private keywords are allowed here, so show completion */ || containingNodeKind === SyntaxKind.NewExpression // new C(a, | || containingNodeKind === SyntaxKind.ArrayLiteralExpression // [a, | || containingNodeKind === SyntaxKind.BinaryExpression // let x = (a, | @@ -3173,10 +3173,12 @@ namespace ts { || containingNodeKind === SyntaxKind.Constructor // constructor( | || containingNodeKind === SyntaxKind.NewExpression // new C(a| || containingNodeKind === SyntaxKind.ParenthesizedExpression // let x = (a| - || containingNodeKind === SyntaxKind.ParenthesizedType; // function F(pred: (a| this can become an arrow function, where 'a' is the argument + || containingNodeKind === SyntaxKind.ParenthesizedType; // function F(pred: (a| /* this can become an arrow function, where 'a' is the argument */ case SyntaxKind.OpenBracketToken: - return containingNodeKind === SyntaxKind.ArrayLiteralExpression; // [ | + return containingNodeKind === SyntaxKind.ArrayLiteralExpression // [ | + || containingNodeKind === SyntaxKind.IndexSignature // [ | : string ] + || containingNodeKind === SyntaxKind.ComputedPropertyName // [ | /* this can become an index signature */ case SyntaxKind.ModuleKeyword: // module | case SyntaxKind.NamespaceKeyword: // namespace | From e4ebf1fe4c5996d399c91429caa4217ddf55675c Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 2 Jul 2015 12:57:34 -0700 Subject: [PATCH 300/309] Change default node pos/end to -1 --- src/compiler/core.ts | 4 ++-- src/compiler/utilities.ts | 4 +--- src/services/services.ts | 4 ++-- 3 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index ec4c777852b..823349eda91 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -764,8 +764,8 @@ namespace ts { } Node.prototype = { kind: kind, - pos: 0, - end: 0, + pos: -1, + end: -1, flags: 0, parent: undefined, }; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index f48e5306dce..e66e1925519 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -144,7 +144,7 @@ namespace ts { return true; } - return node.pos === node.end && node.kind !== SyntaxKind.EndOfFileToken; + return node.pos === node.end && node.pos >= 0 && node.kind !== SyntaxKind.EndOfFileToken; } export function nodeIsPresent(node: Node) { @@ -1428,8 +1428,6 @@ namespace ts { export function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node { let node = createNode(kind); - node.pos = -1; - node.end = -1; node.startsOnNewLine = startsOnNewLine; return node; } diff --git a/src/services/services.ts b/src/services/services.ts index 159b1b817b1..3efecd68572 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -7387,8 +7387,8 @@ namespace ts { } let proto = kind === SyntaxKind.SourceFile ? new SourceFileObject() : new NodeObject(); proto.kind = kind; - proto.pos = 0; - proto.end = 0; + proto.pos = -1; + proto.end = -1; proto.flags = 0; proto.parent = undefined; Node.prototype = proto; From 738415d65cd4e6ef22f9ccb3940d30097bbdc00e Mon Sep 17 00:00:00 2001 From: Arthur Ozga Date: Thu, 2 Jul 2015 15:17:26 -0700 Subject: [PATCH 301/309] Changed tabs to spaces and reformatted file --- scripts/errorCheck.ts | 132 +++++++++++++++++++++--------------------- 1 file changed, 66 insertions(+), 66 deletions(-) diff --git a/scripts/errorCheck.ts b/scripts/errorCheck.ts index 77892cb8f0c..36489c5f312 100644 --- a/scripts/errorCheck.ts +++ b/scripts/errorCheck.ts @@ -4,84 +4,84 @@ let async = require('async'); let glob = require('glob'); fs.readFile('src/compiler/diagnosticMessages.json', 'utf-8', (err, data) => { - if (err) { - throw err; - } - - let messages = JSON.parse(data); - let keys = Object.keys(messages); - console.log('Loaded ' + keys.length + ' errors'); + if (err) { + throw err; + } - for (let k of keys) { - messages[k]['seen'] = false; - } + let messages = JSON.parse(data); + let keys = Object.keys(messages); + console.log('Loaded ' + keys.length + ' errors'); - let errRegex = /\(\d+,\d+\): error TS([^:]+):/g; + for (let k of keys) { + messages[k]['seen'] = false; + } - let baseDir = 'tests/baselines/reference/'; - fs.readdir(baseDir, (err, files) => { - files = files.filter(f => f.indexOf('.errors.txt') > 0); - let tasks: Array<(callback: () => void) => void> = []; - files.forEach(f => tasks.push(done => { - fs.readFile(baseDir + f, 'utf-8', (err, baseline) => { - if (err) throw err; + let errRegex = /\(\d+,\d+\): error TS([^:]+):/g; - let g: string[]; - while (g = errRegex.exec(baseline)) { - var errCode = +g[1]; - let msg = keys.filter(k => messages[k].code === errCode)[0]; - messages[msg]['seen'] = true; - } + let baseDir = 'tests/baselines/reference/'; + fs.readdir(baseDir, (err, files) => { + files = files.filter(f => f.indexOf('.errors.txt') > 0); + let tasks: Array<(callback: () => void) => void> = []; + files.forEach(f => tasks.push(done => { + fs.readFile(baseDir + f, 'utf-8', (err, baseline) => { + if (err) throw err; - done(); - }); - })); + let g: string[]; + while (g = errRegex.exec(baseline)) { + var errCode = +g[1]; + let msg = keys.filter(k => messages[k].code === errCode)[0]; + messages[msg]['seen'] = true; + } - async.parallelLimit(tasks, 25, done => { - console.log('== List of errors not present in baselines =='); - let count = 0; - for (let k of keys) { - if (messages[k]['seen'] !== true) { - console.log(k); - count++; - } - } - console.log(count + ' of ' + keys.length + ' errors are not in baselines'); - }); - }); + done(); + }); + })); + + async.parallelLimit(tasks, 25, done => { + console.log('== List of errors not present in baselines =='); + let count = 0; + for (let k of keys) { + if (messages[k]['seen'] !== true) { + console.log(k); + count++; + } + } + console.log(count + ' of ' + keys.length + ' errors are not in baselines'); + }); + }); }); fs.readFile('src/compiler/diagnosticInformationMap.generated.ts', 'utf-8', (err, data) => { - let errorRegexp = /\s(\w+): \{ code/g; - let errorNames: string[] = []; - let errMatch: string[]; - while (errMatch = errorRegexp.exec(data)) { - errorNames.push(errMatch[1]); - } + let errorRegexp = /\s(\w+): \{ code/g; + let errorNames: string[] = []; + let errMatch: string[]; + while (errMatch = errorRegexp.exec(data)) { + errorNames.push(errMatch[1]); + } - let allSrc: string = ''; - glob('./src/**/*.ts', {}, (err, files) => { - console.log('Reading ' + files.length + ' source files'); - for(let file of files) { - if (file.indexOf('diagnosticInformationMap.generated.ts') > 0) { - continue; - } + let allSrc: string = ''; + glob('./src/**/*.ts', {}, (err, files) => { + console.log('Reading ' + files.length + ' source files'); + for (let file of files) { + if (file.indexOf('diagnosticInformationMap.generated.ts') > 0) { + continue; + } - let src = fs.readFileSync(file, 'utf-8'); - allSrc = allSrc + src; - } + let src = fs.readFileSync(file, 'utf-8'); + allSrc = allSrc + src; + } - console.log('Consumed ' + allSrc.length + ' characters of source'); + console.log('Consumed ' + allSrc.length + ' characters of source'); - let count = 0; - console.log('== List of errors not used in source ==') - for(let errName of errorNames) { - if (allSrc.indexOf(errName) < 0) { - console.log(errName); - count++; - } - } - console.log(count + ' of ' + errorNames.length + ' errors are not used in source'); - }); + let count = 0; + console.log('== List of errors not used in source ==') + for (let errName of errorNames) { + if (allSrc.indexOf(errName) < 0) { + console.log(errName); + count++; + } + } + console.log(count + ' of ' + errorNames.length + ' errors are not used in source'); + }); }); From 1085e39b9a489f82b65c8dfff0e303abdf9e27d8 Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Thu, 2 Jul 2015 15:20:57 -0700 Subject: [PATCH 302/309] Always take the apparent type when you retrieve a contextual type --- src/compiler/checker.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d3d8ac1bc1b..65545efbcd2 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6442,6 +6442,11 @@ namespace ts { // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily // be "pushed" onto a node using the contextualType property. function getContextualType(node: Expression): Type { + let type = getContextualTypeWorker(node); + return type && getApparentType(type); + } + + function getContextualTypeWorker(node: Expression): Type { if (isInsideWithStatementBody(node)) { // We cannot answer semantic questions within a with block, do not proceed any further return undefined; From 98de6117f1cab5861bece38ece96b7e3b56abb5a Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Thu, 2 Jul 2015 15:21:09 -0700 Subject: [PATCH 303/309] Accept baselines --- ...ndAdditionAssignmentLHSCanBeAssigned.types | 2 +- ...ualTypeWithUnionTypeCallSignatures.symbols | 2 ++ ...xtualTypeWithUnionTypeCallSignatures.types | 12 ++++---- .../functionConstraintSatisfaction3.types | 28 +++++++++---------- .../genericCallWithTupleType.errors.txt | 8 +++--- .../reference/noErrorsInCallback.errors.txt | 8 +++--- .../typeParameterFixingWithConstraints.types | 10 +++---- ...wrappedAndRecursiveConstraints4.errors.txt | 4 +-- 8 files changed, 38 insertions(+), 36 deletions(-) diff --git a/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.types b/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.types index e40422450b4..92835611c6d 100644 --- a/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.types +++ b/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.types @@ -98,7 +98,7 @@ x2 += E.a; x2 += {}; >x2 += {} : string >x2 : string ->{} : {} +>{} : { [x: number]: undefined; } x2 += null; >x2 += null : string diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols index 172336603ab..3e23a7812f5 100644 --- a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols +++ b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols @@ -82,5 +82,7 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1)) >IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52)) +>a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.types b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.types index 02dfecf5c08..8e1915d4754 100644 --- a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.types +++ b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.types @@ -90,10 +90,10 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any >x4 : IWithCallSignatures | IWithCallSignatures4 >IWithCallSignatures : IWithCallSignatures >IWithCallSignatures4 : IWithCallSignatures4 ->a => /*here a should be any*/ a.toString() : (a: any) => any ->a : any ->a.toString() : any ->a.toString : any ->a : any ->toString : any +>a => /*here a should be any*/ a.toString() : (a: number) => string +>a : number +>a.toString() : string +>a.toString : (radix?: number) => string +>a : number +>toString : (radix?: number) => string diff --git a/tests/baselines/reference/functionConstraintSatisfaction3.types b/tests/baselines/reference/functionConstraintSatisfaction3.types index 04963c36519..c58e62f6995 100644 --- a/tests/baselines/reference/functionConstraintSatisfaction3.types +++ b/tests/baselines/reference/functionConstraintSatisfaction3.types @@ -37,12 +37,12 @@ var c: { (): string; (x): string }; >x : any var r1 = foo((x) => x); ->r1 : (x: any) => any ->foo((x) => x) : (x: any) => any +>r1 : (x: string) => string +>foo((x) => x) : (x: string) => string >foo : string>(x: T) => T ->(x) => x : (x: any) => any ->x : any ->x : any +>(x) => x : (x: string) => string +>x : string +>x : string var r2 = foo((x: string) => x); >r2 : (x: string) => string @@ -53,12 +53,12 @@ var r2 = foo((x: string) => x); >x : string var r3 = foo(function (x) { return x }); ->r3 : (x: any) => any ->foo(function (x) { return x }) : (x: any) => any +>r3 : (x: string) => string +>foo(function (x) { return x }) : (x: string) => string >foo : string>(x: T) => T ->function (x) { return x } : (x: any) => any ->x : any ->x : any +>function (x) { return x } : (x: string) => string +>x : string +>x : string var r4 = foo(function (x: string) { return x }); >r4 : (x: string) => string @@ -130,8 +130,8 @@ var c2: { (x: T): T; (x: T, y: T): T }; >T : T var r9 = foo(function (x: U) { return x; }); ->r9 : (x: U) => U ->foo(function (x: U) { return x; }) : (x: U) => U +>r9 : (x: string) => string +>foo(function (x: U) { return x; }) : (x: string) => string >foo : string>(x: T) => T >function (x: U) { return x; } : (x: U) => U >U : U @@ -140,8 +140,8 @@ var r9 = foo(function (x: U) { return x; }); >x : U var r10 = foo((x: U) => x); ->r10 : (x: U) => U ->foo((x: U) => x) : (x: U) => U +>r10 : (x: string) => string +>foo((x: U) => x) : (x: string) => string >foo : string>(x: T) => T >(x: U) => x : (x: U) => U >U : U diff --git a/tests/baselines/reference/genericCallWithTupleType.errors.txt b/tests/baselines/reference/genericCallWithTupleType.errors.txt index bcf580320e5..d03f8d5e68a 100644 --- a/tests/baselines/reference/genericCallWithTupleType.errors.txt +++ b/tests/baselines/reference/genericCallWithTupleType.errors.txt @@ -9,9 +9,9 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTup tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(22,1): error TS2322: Type '[number, string]' is not assignable to type '[string, number]'. Types of property '0' are incompatible. Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(23,1): error TS2322: Type '[{}, {}]' is not assignable to type '[string, number]'. +tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(23,1): error TS2322: Type '[{ [x: number]: undefined; }, {}]' is not assignable to type '[string, number]'. Types of property '0' are incompatible. - Type '{}' is not assignable to type 'string'. + Type '{ [x: number]: undefined; }' is not assignable to type 'string'. tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(24,1): error TS2322: Type '[{}]' is not assignable to type '[{}, {}]'. Property '1' is missing in type '[{}]'. @@ -55,9 +55,9 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTup !!! error TS2322: Type 'number' is not assignable to type 'string'. i1.tuple1 = [{}, {}]; ~~~~~~~~~ -!!! error TS2322: Type '[{}, {}]' is not assignable to type '[string, number]'. +!!! error TS2322: Type '[{ [x: number]: undefined; }, {}]' is not assignable to type '[string, number]'. !!! error TS2322: Types of property '0' are incompatible. -!!! error TS2322: Type '{}' is not assignable to type 'string'. +!!! error TS2322: Type '{ [x: number]: undefined; }' is not assignable to type 'string'. i2.tuple1 = [{}]; ~~~~~~~~~ !!! error TS2322: Type '[{}]' is not assignable to type '[{}, {}]'. diff --git a/tests/baselines/reference/noErrorsInCallback.errors.txt b/tests/baselines/reference/noErrorsInCallback.errors.txt index f0bfe00199e..90fdbbd77a5 100644 --- a/tests/baselines/reference/noErrorsInCallback.errors.txt +++ b/tests/baselines/reference/noErrorsInCallback.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/noErrorsInCallback.ts(4,19): error TS2345: Argument of type '{}' is not assignable to parameter of type 'string'. -tests/cases/compiler/noErrorsInCallback.ts(6,23): error TS2345: Argument of type '{}' is not assignable to parameter of type 'string'. +tests/cases/compiler/noErrorsInCallback.ts(4,19): error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'string'. +tests/cases/compiler/noErrorsInCallback.ts(6,23): error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'string'. ==== tests/cases/compiler/noErrorsInCallback.ts (2 errors) ==== @@ -8,10 +8,10 @@ tests/cases/compiler/noErrorsInCallback.ts(6,23): error TS2345: Argument of type } var one = new Bar({}); // Error ~~ -!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'string'. +!!! error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'string'. [].forEach(() => { var two = new Bar({}); // No error? ~~ -!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'string'. +!!! error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'string'. }); \ No newline at end of file diff --git a/tests/baselines/reference/typeParameterFixingWithConstraints.types b/tests/baselines/reference/typeParameterFixingWithConstraints.types index 64876952852..22d294f9d2e 100644 --- a/tests/baselines/reference/typeParameterFixingWithConstraints.types +++ b/tests/baselines/reference/typeParameterFixingWithConstraints.types @@ -31,17 +31,17 @@ var foo: IFoo; >IFoo : IFoo foo.foo({ bar: null }, bar => null, bar => null); ->foo.foo({ bar: null }, bar => null, bar => null) : IBar +>foo.foo({ bar: null }, bar => null, bar => null) : { [x: string]: any; bar: any; } >foo.foo : (bar: TBar, bar1: (bar: TBar) => TBar, bar2: (bar: TBar) => TBar) => TBar >foo : IFoo >foo : (bar: TBar, bar1: (bar: TBar) => TBar, bar2: (bar: TBar) => TBar) => TBar >{ bar: null } : { [x: string]: null; bar: null; } >bar : null >null : null ->bar => null : (bar: IBar) => any ->bar : IBar +>bar => null : (bar: { [x: string]: any; bar: any; }) => any +>bar : { [x: string]: any; bar: any; } >null : null ->bar => null : (bar: IBar) => any ->bar : IBar +>bar => null : (bar: { [x: string]: any; bar: any; }) => any +>bar : { [x: string]: any; bar: any; } >null : null diff --git a/tests/baselines/reference/wrappedAndRecursiveConstraints4.errors.txt b/tests/baselines/reference/wrappedAndRecursiveConstraints4.errors.txt index 47e8e6ff4f2..60602351b46 100644 --- a/tests/baselines/reference/wrappedAndRecursiveConstraints4.errors.txt +++ b/tests/baselines/reference/wrappedAndRecursiveConstraints4.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/types/typeParameters/typeArgumentLists/wrappedAndRecursiveConstraints4.ts(13,12): error TS2345: Argument of type '{ length: number; charAt: (x: number) => void; }' is not assignable to parameter of type 'string'. +tests/cases/conformance/types/typeParameters/typeArgumentLists/wrappedAndRecursiveConstraints4.ts(13,12): error TS2345: Argument of type '{ [x: number]: undefined; length: number; charAt: (x: number) => void; }' is not assignable to parameter of type 'string'. ==== tests/cases/conformance/types/typeParameters/typeArgumentLists/wrappedAndRecursiveConstraints4.ts (1 errors) ==== @@ -16,4 +16,4 @@ tests/cases/conformance/types/typeParameters/typeArgumentLists/wrappedAndRecursi var r = c.foo(''); var r2 = r({ length: 3, charAt: (x: number) => { '' } }); // error ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2345: Argument of type '{ length: number; charAt: (x: number) => void; }' is not assignable to parameter of type 'string'. \ No newline at end of file +!!! error TS2345: Argument of type '{ [x: number]: undefined; length: number; charAt: (x: number) => void; }' is not assignable to parameter of type 'string'. \ No newline at end of file From 652995181e41ca5b4347fdbd8f5377c2b944da6f Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Thu, 2 Jul 2015 15:21:43 -0700 Subject: [PATCH 304/309] Add tests for inferential typing --- .../inferentialTypingUsingApparentType1.js | 12 +++ ...nferentialTypingUsingApparentType1.symbols | 20 +++++ .../inferentialTypingUsingApparentType1.types | 22 ++++++ .../inferentialTypingUsingApparentType2.js | 12 +++ ...nferentialTypingUsingApparentType2.symbols | 22 ++++++ .../inferentialTypingUsingApparentType2.types | 24 ++++++ .../inferentialTypingUsingApparentType3.js | 56 ++++++++++++++ ...nferentialTypingUsingApparentType3.symbols | 69 +++++++++++++++++ .../inferentialTypingUsingApparentType3.types | 75 +++++++++++++++++++ .../inferentialTypingUsingApparentType1.ts | 5 ++ .../inferentialTypingUsingApparentType2.ts | 5 ++ .../inferentialTypingUsingApparentType3.ts | 26 +++++++ 12 files changed, 348 insertions(+) create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType1.js create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType1.symbols create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType1.types create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType2.js create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType2.symbols create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType2.types create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType3.js create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType3.symbols create mode 100644 tests/baselines/reference/inferentialTypingUsingApparentType3.types create mode 100644 tests/cases/compiler/inferentialTypingUsingApparentType1.ts create mode 100644 tests/cases/compiler/inferentialTypingUsingApparentType2.ts create mode 100644 tests/cases/compiler/inferentialTypingUsingApparentType3.ts diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType1.js b/tests/baselines/reference/inferentialTypingUsingApparentType1.js new file mode 100644 index 00000000000..02161a98695 --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType1.js @@ -0,0 +1,12 @@ +//// [inferentialTypingUsingApparentType1.ts] +function foo number>(x: T): T { + return undefined; +} + +foo(x => x.length); + +//// [inferentialTypingUsingApparentType1.js] +function foo(x) { + return undefined; +} +foo(function (x) { return x.length; }); diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols b/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols new file mode 100644 index 00000000000..4babc614183 --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols @@ -0,0 +1,20 @@ +=== tests/cases/compiler/inferentialTypingUsingApparentType1.ts === +function foo number>(x: T): T { +>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType1.ts, 0, 0)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13)) +>p : Symbol(p, Decl(inferentialTypingUsingApparentType1.ts, 0, 24)) +>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 0, 46)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13)) + + return undefined; +>undefined : Symbol(undefined) +} + +foo(x => x.length); +>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType1.ts, 0, 0)) +>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4)) +>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4)) +>length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) + diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType1.types b/tests/baselines/reference/inferentialTypingUsingApparentType1.types new file mode 100644 index 00000000000..b56f3670ddc --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType1.types @@ -0,0 +1,22 @@ +=== tests/cases/compiler/inferentialTypingUsingApparentType1.ts === +function foo number>(x: T): T { +>foo : number>(x: T) => T +>T : T +>p : string +>x : T +>T : T +>T : T + + return undefined; +>undefined : undefined +} + +foo(x => x.length); +>foo(x => x.length) : (x: string) => number +>foo : number>(x: T) => T +>x => x.length : (x: string) => number +>x : string +>x.length : number +>x : string +>length : number + diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType2.js b/tests/baselines/reference/inferentialTypingUsingApparentType2.js new file mode 100644 index 00000000000..7cb7e49cd62 --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType2.js @@ -0,0 +1,12 @@ +//// [inferentialTypingUsingApparentType2.ts] +function foo(x: T): T { + return undefined; +} + +foo({ m(x) { return x.length } }); + +//// [inferentialTypingUsingApparentType2.js] +function foo(x) { + return undefined; +} +foo({ m: function (x) { return x.length; } }); diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols b/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols new file mode 100644 index 00000000000..3c47eb4c697 --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols @@ -0,0 +1,22 @@ +=== tests/cases/compiler/inferentialTypingUsingApparentType2.ts === +function foo(x: T): T { +>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType2.ts, 0, 0)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13)) +>m : Symbol(m, Decl(inferentialTypingUsingApparentType2.ts, 0, 24)) +>p : Symbol(p, Decl(inferentialTypingUsingApparentType2.ts, 0, 27)) +>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 0, 49)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13)) + + return undefined; +>undefined : Symbol(undefined) +} + +foo({ m(x) { return x.length } }); +>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType2.ts, 0, 0)) +>m : Symbol(m, Decl(inferentialTypingUsingApparentType2.ts, 4, 5)) +>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8)) +>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8)) +>length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) + diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType2.types b/tests/baselines/reference/inferentialTypingUsingApparentType2.types new file mode 100644 index 00000000000..597f5885f5a --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType2.types @@ -0,0 +1,24 @@ +=== tests/cases/compiler/inferentialTypingUsingApparentType2.ts === +function foo(x: T): T { +>foo : (x: T) => T +>T : T +>m : (p: string) => number +>p : string +>x : T +>T : T +>T : T + + return undefined; +>undefined : undefined +} + +foo({ m(x) { return x.length } }); +>foo({ m(x) { return x.length } }) : { } +>foo : (x: T) => T +>{ m(x) { return x.length } } : { m(x: string): number; } +>m : (x: string) => number +>x : string +>x.length : number +>x : string +>length : number + diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType3.js b/tests/baselines/reference/inferentialTypingUsingApparentType3.js new file mode 100644 index 00000000000..819ca05098d --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType3.js @@ -0,0 +1,56 @@ +//// [inferentialTypingUsingApparentType3.ts] +interface Field { + clean(input: T): T +} + +class CharField implements Field { + clean(input: string) { + return "Yup"; + } +} + +class NumberField implements Field { + clean(input: number) { + return 123; + } +} + +class ObjectField }> { + constructor(public fields: T) { } +} + +var person = new ObjectField({ + id: new NumberField(), + name: new CharField() +}); + +person.fields.id; + +//// [inferentialTypingUsingApparentType3.js] +var CharField = (function () { + function CharField() { + } + CharField.prototype.clean = function (input) { + return "Yup"; + }; + return CharField; +})(); +var NumberField = (function () { + function NumberField() { + } + NumberField.prototype.clean = function (input) { + return 123; + }; + return NumberField; +})(); +var ObjectField = (function () { + function ObjectField(fields) { + this.fields = fields; + } + return ObjectField; +})(); +var person = new ObjectField({ + id: new NumberField(), + name: new CharField() +}); +person.fields.id; diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType3.symbols b/tests/baselines/reference/inferentialTypingUsingApparentType3.symbols new file mode 100644 index 00000000000..ac3058e8649 --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType3.symbols @@ -0,0 +1,69 @@ +=== tests/cases/compiler/inferentialTypingUsingApparentType3.ts === +interface Field { +>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16)) + + clean(input: T): T +>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 0, 20)) +>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 1, 10)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16)) +} + +class CharField implements Field { +>CharField : Symbol(CharField, Decl(inferentialTypingUsingApparentType3.ts, 2, 1)) +>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0)) + + clean(input: string) { +>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 4, 42)) +>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 5, 10)) + + return "Yup"; + } +} + +class NumberField implements Field { +>NumberField : Symbol(NumberField, Decl(inferentialTypingUsingApparentType3.ts, 8, 1)) +>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0)) + + clean(input: number) { +>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 10, 44)) +>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 11, 10)) + + return 123; + } +} + +class ObjectField }> { +>ObjectField : Symbol(ObjectField, Decl(inferentialTypingUsingApparentType3.ts, 14, 1)) +>A : Symbol(A, Decl(inferentialTypingUsingApparentType3.ts, 16, 18)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 16, 20)) +>name : Symbol(name, Decl(inferentialTypingUsingApparentType3.ts, 16, 34)) +>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0)) + + constructor(public fields: T) { } +>fields : Symbol(fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16)) +>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 16, 20)) +} + +var person = new ObjectField({ +>person : Symbol(person, Decl(inferentialTypingUsingApparentType3.ts, 20, 3)) +>ObjectField : Symbol(ObjectField, Decl(inferentialTypingUsingApparentType3.ts, 14, 1)) + + id: new NumberField(), +>id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30)) +>NumberField : Symbol(NumberField, Decl(inferentialTypingUsingApparentType3.ts, 8, 1)) + + name: new CharField() +>name : Symbol(name, Decl(inferentialTypingUsingApparentType3.ts, 21, 26)) +>CharField : Symbol(CharField, Decl(inferentialTypingUsingApparentType3.ts, 2, 1)) + +}); + +person.fields.id; +>person.fields.id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30)) +>person.fields : Symbol(ObjectField.fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16)) +>person : Symbol(person, Decl(inferentialTypingUsingApparentType3.ts, 20, 3)) +>fields : Symbol(ObjectField.fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16)) +>id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30)) + diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType3.types b/tests/baselines/reference/inferentialTypingUsingApparentType3.types new file mode 100644 index 00000000000..7d0da8f4b06 --- /dev/null +++ b/tests/baselines/reference/inferentialTypingUsingApparentType3.types @@ -0,0 +1,75 @@ +=== tests/cases/compiler/inferentialTypingUsingApparentType3.ts === +interface Field { +>Field : Field +>T : T + + clean(input: T): T +>clean : (input: T) => T +>input : T +>T : T +>T : T +} + +class CharField implements Field { +>CharField : CharField +>Field : Field + + clean(input: string) { +>clean : (input: string) => string +>input : string + + return "Yup"; +>"Yup" : string + } +} + +class NumberField implements Field { +>NumberField : NumberField +>Field : Field + + clean(input: number) { +>clean : (input: number) => number +>input : number + + return 123; +>123 : number + } +} + +class ObjectField }> { +>ObjectField : ObjectField +>A : A +>T : T +>name : string +>Field : Field + + constructor(public fields: T) { } +>fields : T +>T : T +} + +var person = new ObjectField({ +>person : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }> +>new ObjectField({ id: new NumberField(), name: new CharField()}) : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }> +>ObjectField : typeof ObjectField +>{ id: new NumberField(), name: new CharField()} : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; } + + id: new NumberField(), +>id : NumberField +>new NumberField() : NumberField +>NumberField : typeof NumberField + + name: new CharField() +>name : CharField +>new CharField() : CharField +>CharField : typeof CharField + +}); + +person.fields.id; +>person.fields.id : NumberField +>person.fields : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; } +>person : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }> +>fields : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; } +>id : NumberField + diff --git a/tests/cases/compiler/inferentialTypingUsingApparentType1.ts b/tests/cases/compiler/inferentialTypingUsingApparentType1.ts new file mode 100644 index 00000000000..98920cf693f --- /dev/null +++ b/tests/cases/compiler/inferentialTypingUsingApparentType1.ts @@ -0,0 +1,5 @@ +function foo number>(x: T): T { + return undefined; +} + +foo(x => x.length); \ No newline at end of file diff --git a/tests/cases/compiler/inferentialTypingUsingApparentType2.ts b/tests/cases/compiler/inferentialTypingUsingApparentType2.ts new file mode 100644 index 00000000000..8290b14927d --- /dev/null +++ b/tests/cases/compiler/inferentialTypingUsingApparentType2.ts @@ -0,0 +1,5 @@ +function foo(x: T): T { + return undefined; +} + +foo({ m(x) { return x.length } }); \ No newline at end of file diff --git a/tests/cases/compiler/inferentialTypingUsingApparentType3.ts b/tests/cases/compiler/inferentialTypingUsingApparentType3.ts new file mode 100644 index 00000000000..d1734b0d100 --- /dev/null +++ b/tests/cases/compiler/inferentialTypingUsingApparentType3.ts @@ -0,0 +1,26 @@ +interface Field { + clean(input: T): T +} + +class CharField implements Field { + clean(input: string) { + return "Yup"; + } +} + +class NumberField implements Field { + clean(input: number) { + return 123; + } +} + +class ObjectField }> { + constructor(public fields: T) { } +} + +var person = new ObjectField({ + id: new NumberField(), + name: new CharField() +}); + +person.fields.id; \ No newline at end of file From 0fcc63e33e5a8d1f9d63e28d3de5e356c0e3f7e4 Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Thu, 2 Jul 2015 16:13:38 -0700 Subject: [PATCH 305/309] Disallow modifiers on rest parameters --- src/compiler/parser.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index c257f6c702e..f2f39b7495c 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1979,8 +1979,8 @@ namespace ts { function parseParameter(): ParameterDeclaration { let node = createNode(SyntaxKind.Parameter); node.decorators = parseDecorators(); - node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); setModifiers(node, parseModifiers()); + node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); // FormalParameter [Yield,Await]: // BindingElement[?Yield,?Await] From 35db9f68f426e452322c05619ad92ae45c6f626b Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Thu, 2 Jul 2015 16:13:47 -0700 Subject: [PATCH 306/309] Add tests --- .../reference/restParamModifier.errors.txt | 21 +++++++++++++++++++ .../baselines/reference/restParamModifier.js | 12 +++++++++++ .../reference/restParamModifier2.errors.txt | 9 ++++++++ .../baselines/reference/restParamModifier2.js | 15 +++++++++++++ tests/cases/compiler/restParamModifier.ts | 3 +++ tests/cases/compiler/restParamModifier2.ts | 3 +++ 6 files changed, 63 insertions(+) create mode 100644 tests/baselines/reference/restParamModifier.errors.txt create mode 100644 tests/baselines/reference/restParamModifier.js create mode 100644 tests/baselines/reference/restParamModifier2.errors.txt create mode 100644 tests/baselines/reference/restParamModifier2.js create mode 100644 tests/cases/compiler/restParamModifier.ts create mode 100644 tests/cases/compiler/restParamModifier2.ts diff --git a/tests/baselines/reference/restParamModifier.errors.txt b/tests/baselines/reference/restParamModifier.errors.txt new file mode 100644 index 00000000000..87c73fcdc71 --- /dev/null +++ b/tests/baselines/reference/restParamModifier.errors.txt @@ -0,0 +1,21 @@ +tests/cases/compiler/restParamModifier.ts(2,17): error TS2370: A rest parameter must be of an array type. +tests/cases/compiler/restParamModifier.ts(2,27): error TS1005: '=' expected. +tests/cases/compiler/restParamModifier.ts(2,27): error TS2304: Cannot find name 'rest'. +tests/cases/compiler/restParamModifier.ts(2,31): error TS1005: ',' expected. +tests/cases/compiler/restParamModifier.ts(2,39): error TS1005: '=' expected. + + +==== tests/cases/compiler/restParamModifier.ts (5 errors) ==== + class C { + constructor(...public rest: string[]) {} + ~~~~~~~~~~~~~~ +!!! error TS2370: A rest parameter must be of an array type. + ~~~~ +!!! error TS1005: '=' expected. + ~~~~ +!!! error TS2304: Cannot find name 'rest'. + ~ +!!! error TS1005: ',' expected. + ~ +!!! error TS1005: '=' expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/restParamModifier.js b/tests/baselines/reference/restParamModifier.js new file mode 100644 index 00000000000..9a780321dc9 --- /dev/null +++ b/tests/baselines/reference/restParamModifier.js @@ -0,0 +1,12 @@ +//// [restParamModifier.ts] +class C { + constructor(...public rest: string[]) {} +} + +//// [restParamModifier.js] +var C = (function () { + function C(public, string) { + if (string === void 0) { string = []; } + } + return C; +})(); diff --git a/tests/baselines/reference/restParamModifier2.errors.txt b/tests/baselines/reference/restParamModifier2.errors.txt new file mode 100644 index 00000000000..773592fa9bf --- /dev/null +++ b/tests/baselines/reference/restParamModifier2.errors.txt @@ -0,0 +1,9 @@ +tests/cases/compiler/restParamModifier2.ts(2,24): error TS1005: ',' expected. + + +==== tests/cases/compiler/restParamModifier2.ts (1 errors) ==== + class C { + constructor(public ...rest: string[]) {} + ~~~ +!!! error TS1005: ',' expected. + } \ No newline at end of file diff --git a/tests/baselines/reference/restParamModifier2.js b/tests/baselines/reference/restParamModifier2.js new file mode 100644 index 00000000000..c588c945ce4 --- /dev/null +++ b/tests/baselines/reference/restParamModifier2.js @@ -0,0 +1,15 @@ +//// [restParamModifier2.ts] +class C { + constructor(public ...rest: string[]) {} +} + +//// [restParamModifier2.js] +var C = (function () { + function C(public) { + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } + } + return C; +})(); diff --git a/tests/cases/compiler/restParamModifier.ts b/tests/cases/compiler/restParamModifier.ts new file mode 100644 index 00000000000..220b7d36d5e --- /dev/null +++ b/tests/cases/compiler/restParamModifier.ts @@ -0,0 +1,3 @@ +class C { + constructor(...public rest: string[]) {} +} \ No newline at end of file diff --git a/tests/cases/compiler/restParamModifier2.ts b/tests/cases/compiler/restParamModifier2.ts new file mode 100644 index 00000000000..e007bc56d7c --- /dev/null +++ b/tests/cases/compiler/restParamModifier2.ts @@ -0,0 +1,3 @@ +class C { + constructor(public ...rest: string[]) {} +} \ No newline at end of file From 144a635bc54bf90515c55fccccac2bb62b949270 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 3 Jul 2015 11:20:44 -0700 Subject: [PATCH 307/309] Changing comment per CR feedback --- src/compiler/checker.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index be823989b82..1e57cba0077 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4486,9 +4486,9 @@ namespace ts { } } else { - // A check of the form A | B = C & D can be satisfied either by having C be related to A | B, - // D be related to A | B, C & D be related to A, or C & D be related to B. Thus, we need to - // check both sides here. + // It is necessary to try "each" checks on both sides because there may be nested "some" checks + // on either side that need to be prioritized. For example, A | B = (A | B) & (C | D) or + // A & B = (A & B) | (C & D). if (source.flags & TypeFlags.Intersection) { // If target is a union type the following check will report errors so we suppress them here if (result = someTypeRelatedToType(source, target, reportErrors && !(target.flags & TypeFlags.Union))) { From af94f1c5d09c3c8953b7f52b03b41bbf313b69c0 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Mon, 6 Jul 2015 14:04:42 -0700 Subject: [PATCH 308/309] Throttle how often we call into the host side to check for cancellation. --- src/services/services.ts | 1 - src/services/shims.ts | 26 +++++++++++++++++++++++++- 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/src/services/services.ts b/src/services/services.ts index 19dd5288721..1e98e29d4cf 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1618,7 +1618,6 @@ namespace ts { export class OperationCanceledException { } export class CancellationTokenObject { - public static None: CancellationTokenObject = new CancellationTokenObject(null) constructor(private cancellationToken: CancellationToken) { diff --git a/src/services/shims.ts b/src/services/shims.ts index 2e8b3eb774d..22c0d3f6065 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -327,7 +327,8 @@ namespace ts { } public getCancellationToken(): CancellationToken { - return this.shimHost.getCancellationToken(); + var hostCancellationToken = this.shimHost.getCancellationToken(); + return new ThrottledCancellationToken(hostCancellationToken); } public getCurrentDirectory(): string { @@ -346,6 +347,29 @@ namespace ts { } } + /** A cancellation that throttles calls to the host */ + class ThrottledCancellationToken implements CancellationToken { + // Store when we last tried to cancel. Checking cancellation can be expensive (as we have + // to marshall over to the host layer). So we only bother actually checking once enough + // time has passed. + private lastCancellationCheckTime = 0; + + constructor(private hostCancellationToken: CancellationToken) { + } + + public isCancellationRequested(): boolean { + var time = Date.now(); + var duration = Math.abs(time - this.lastCancellationCheckTime); + if (duration > 10) { + // Check no more than once every 10 ms. + this.lastCancellationCheckTime = time; + return this.hostCancellationToken.isCancellationRequested(); + } + + return false; + } + } + export class CoreServicesShimHostAdapter implements ParseConfigHost { constructor(private shimHost: CoreServicesShimHost) { From 370372e043dacde018f0689c1f4b836116e4260d Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Mon, 6 Jul 2015 14:25:18 -0700 Subject: [PATCH 309/309] Remove shim cancellation test. --- ...cellationWhenfindingAllRefsOnDefinition.ts | 38 ------------------- 1 file changed, 38 deletions(-) delete mode 100644 tests/cases/fourslash/shims/cancellationWhenfindingAllRefsOnDefinition.ts diff --git a/tests/cases/fourslash/shims/cancellationWhenfindingAllRefsOnDefinition.ts b/tests/cases/fourslash/shims/cancellationWhenfindingAllRefsOnDefinition.ts deleted file mode 100644 index 09f580bb965..00000000000 --- a/tests/cases/fourslash/shims/cancellationWhenfindingAllRefsOnDefinition.ts +++ /dev/null @@ -1,38 +0,0 @@ -/// - -//@Filename: findAllRefsOnDefinition-import.ts -////export class Test{ -//// -//// constructor(){ -//// -//// } -//// -//// public /*1*/start(){ -//// return this; -//// } -//// -//// public stop(){ -//// return this; -//// } -////} - -//@Filename: findAllRefsOnDefinition.ts -////import Second = require("findAllRefsOnDefinition-import"); -//// -////var second = new Second.Test() -////second.start(); -////second.stop(); - -goTo.file("findAllRefsOnDefinition-import.ts"); -goTo.marker("1"); - -verify.referencesCountIs(2); - -cancellation.setCancelled(); -goTo.marker("1"); -verifyOperationIsCancelled(() => verify.referencesCountIs(0) ); - -// verify that internal state is still correct -cancellation.resetCancelled(); -goTo.marker("1"); -verify.referencesCountIs(2);